This section presents a short overview towards the theory of the soluble quotient algorithm, the functions designed for computing soluble quotients and the functions designed for dealing with soluble quotient processes.
For a finite group G, the property of being soluble means that the derived series G = G^((0)) > G^((1)) > ... > G^((n)) terminates with G^((n)) = < 1 >. Each section G^((i))/G^((i + 1)) is a finite abelian group, hence it can be identified with a Z G/G^((i))-module M, where the action of G/G^((i)) on M is given by the conjugation action on G^((i))/G^((i + 1)).
From module theory we see that there exists a series M = M^((0)) > M^((1)) > ... > M^((r_i)), where each section is an irreducible GF(p) G/G((i))-module for some prime p. Using these series we obtain a refinement G = G_((0)) > G_((1)) > ... > G_((n)) = < 1 > of the commutator series with the properties:
The soluble quotient algorithm uses these series to construct soluble groups. Starting with the trivial group G/G_((0)), it successively chooses irreducible G/G_((i)) modules M_i and extensions zeta_i in H^2(G/G_((i)), M_i) which give rise to exact sequences 1 -> M_i -> G/G_((i + 1))=G/G_((i)).M_i -> G/G_((i)) -> 1. To describe the algorithmic approach, we consider the following situation. Let G be a finite soluble group, M a normal elementary abelian subgroup of G such that M is a H=G/M irreducible module. (The action of H on M is identified with the conjugation action of G/M on the subgroup M.) Then the relations of the group G have the shape g_i^(p_i)=w_im_i ( resp.) g_j^(g_i)=w_(ij)m_(ij), m_i, m_(ij) in M where w_i, w_(ij) are the canonical representatives of H in G. Then bar(g_i^(p_i))=bar(w_i) resp. bar(g_j)^(bar(g_i)) =bar(w_(ij)) is a PC-presentation of H and the set of images ((g_i^(p_i - 1), g_i) -> m_i, (g_j, g_i) |-> m_(ij)) determines a unique element of the cocycle space C^2(H, M).
According to the p-group situation, we call the system t= (m_i, m_(ij)), the tail defining G = H.M_t as an extension of M by H.
Not every choice of a system t = (m_i, m_(ij)) defines an extension. To make sure that t corresponds to an element s of C^2(G, M) it must satisfy a certain equation system, the so-called consistency equations (see Vaughan-Lee). These are linear homogeneous equations in M, so the solution space can be determined.
For the construction of soluble quotients we also have to find the epimorphism varepsilon: F mapsur G. The existence of the epimorphism is obviously a restriction of the possible images G, and it can be checked simultaneously with constructing G. Let G be an extension G = H.M, where M is a H-module and H is a known soluble quotient delta: F mapsur H. Then delta is uniquely determined by the images delta(f_i)=h_i, 1 <= i <= r, where {f_1, ..., f_r} is a generating set of F. We want to find a lift varepsilon of delta, i.e. varepsilon (f)=delta(f) ( mod) M for all f in F. This means that varepsilon(f_i)=h_i x_i for all i <= r, where x_i in M are to be determined. Since varepsilon will be a homomorphism, we require varepsilon(r_j(f_1, ..., f_r))=1_G for the defining relations r_j of F. This leads to a linear equation system for the variables (x_1, ..., x_r) in M^r. We solve this equation system together with the consistency equations, hence we find a subspace S of M^r x H^2(H, M) of those extensions for which the epimorphism delta has a lift. Let us call an element of S an extended tail.
Let K be the minimal splitting field of M, i.e. the character field of the unique character of H which corresponds to M. Then M is obviously a KH-module and S is also a K-space. The space S has a K-subspace S_S of split extensions, i.e. the projection of S_S into H^2(H, M) is only the trivial element. For any element t in S/S_S the corresponding map varepsilon_t: F -> H.M_t is necessarily surjective, hence defines a soluble quotient. Let s_1, s_2 be two elements of S/S_S and let varepsilon_i: F mapsur H.M_(s_i) =: G_i denote the corresponding soluble quotients. If s_1 and s_2 are K-linear dependent, the groups G_1 and G_2 will be isomorphic. Unfortunately, the converse is not true, even K-linear independent elements may lead to isomorphic groups. Nevertheless, if s_1 and s_2 are independent, the kernels of the epimorphisms will be different, hence one can iterate the lifting to varepsilon_(1, 2): F mapsur (G_1).M_(s_2) = (H.M_(s_1)).M_(s_2) = H.(M direct-sum M)_(s_1.s_2). (The last equality can be read as a definition of s_1.s_2 in the righthand side term.)
The dimension a=dim_K(S/S_S) is therefore characterised as the maximal multiplicity a = max {z in Z^ + | exists varepsilon:F mapsur H, M^z }. S_S itself also has a K-subspace S_C, for which the map varepsilon_s: F -> H.M_s, s in S_C is not surjective. The K-dimension b=dim_K(S_S/S_C) is again characterised as the maximal multiplicity b=max{z in Z^ + | exists varepsilon:F mapsur H, M^z }. Moreover, after taking a maximal extension varepsilon:F mapsur H.M^b, M never has to be considered for split extensions again.
A crucial step in finding finite soluble quotients varepsilon: F mapsur G is the calculation of the relevant primes, i.e. the prime divisors of |G|. This is the most time consuming part of the algorithm, so it is crucial to apply it as efficiently as possible, and any other information about possible prime divisors is very helpful. We do not explain this calculation in detail. However, to use the functions and options provided by Magma in a correct manner, we outline the idea of the calculation.
Let varepsilon:F mapsur G be a finite soluble quotient and let N denote the kernel of varepsilon. If a module M allows an extension bar(varepsilon):F mapsur G.M, then M must be a constituent of N/N^prime, and the relevant primes are the prime divisors of N/N^prime. Again N/N^prime can be viewed as an F/N- module, hence an H-module. Therefore it is a direct sum N/N^prime isomorphic to M_(p_1) direct-sum M_(p_2) direct-sum ... direct-sum Z^d, where the M_(p_i) are finite modules of order a power of the prime p_i. Let p not divide |H|. Then by Zassenhaus the extension H.M_p must split. We consider an irreducible module M in the head of M_p, i.e. there is an H-epimorphism M_p mapsur M. Then there is a valid soluble quotient varepsilon: F mapsur H.M and the extension H.M splits.
Now there exists an irreducible Z H- module L such that M is a GF(p)-modular constituent of L/pL. Moreover, Delta: H -> GL(L) is the corresponding representation of H and any Delta-module will have this property.
Now using the theory of space groups, one can construct homomorphisms varepsilon_1: F mapsur H.L and varepsilon_2: H.L mapsur H.M such that the composition is surjective. Hence p can be detected in Delta. Let P_Delta denote the set of primes obtained from Delta. To find these primes, we have to know a set D of representatives of the irreducible rational representations of F/N, hence of H. The set of prime divisors of K/K^prime is a subset of P= bigcup_(Delta in D) P_(Delta) union {p | p ( prime ), p | |G|}. We want to point out the following:
Magma provides two different ways to calculate finite soluble quotients: a main function for the whole calculation, and a process which gives control over each individual step.
Let F be a finitely presented group.
Find a soluble quotient varepsilon:F mapsur G with a specified order. n must be a nonnegative integer. P must be a set of primes. S must be a sequence of tuples < p, e >, p a prime or zero and e a nonnegative integer.The four forms reflect possible information about the order of an expected soluble quotient. In the first form the order of G is given by n, if n is greater than zero. If n equals zero, nothing about the order is known and the relevant primes will be calculated completely.
The second form, with no n argument, is equivalent to the first with n = 0. This is a standard argument, and usually it is the most efficient way to calculate soluble quotients.
Note that, if n>0 is not the order of the maximal finite soluble quotient, it may happen that no group of order n can be found, since an epimorphic image of size n may not be exhibited by the chosen series.
In the third form a set P of relevant primes is given. The algorithm calculates the biggest quotient such that the order has prime divisors only in P. P may have a zero as element, this is just for consistency reasons. It is equivalent to the first form with n equal zero.
The fourth form is the most explicit input form. The sequence may consist of tuples of the form:
The returned values are the group G and the epimorphism varepsilon: F mapsur G. The third returned value is a sequence describing the series and modules by which G has been constructed.
- < p, e >: p is a prime divisor of |G| and the exponent of p in |G| is limited by e.
- < p, 0 >: p is a prime divisor of |G| and no limit on the exponent is given.
- < 0, e >: The relevant primes will be calculated. For any relevant prime q not occurring elsewhere in the sequence, its exponent in |G| is limited by e. e=0 is also possible, which means no limit on the exponent.
The fourth value is a string which explain the reason for termination. The following list gives the termination conditions. The algorithm terminates normally if:
The algorithm will be aborted and returns a warning if:
- A quotient of the given order has been constructed.
- A maximal quotient (with respect to the conditions given on the order) has been constructed.
With the following options one can define abort conditions corresponding to the third and fourth item. The idea of all these conditions is to control the occurrence of infinite soluble quotients.
- A bound on the length of a series or subseries has been hit.
- A limit on the size of the quotient or a section has been hit.
- The algorithm detects a free abelian section.
SeriesLength: RngIntElt Default: 0Limits the length of the chief series to r. For sag-series it is the nilpotent length of the series, for derived series it is the derived length. The default value of zero means no limit.
If the algorithm hits the limit, it gives a warning message and returns the last soluble quotient.
SubseriesLength: RngIntElt Default: 0Limits the length of a series in a section. If the sag-series is used, it is the length of the lower descending series. For the derived series, the limit is applied to the exponent of an element of a section with maximal prime power order. For example, if the limit is set to 3, the limit would be hit by a section of type C_8, but not by C_2^3 and not even by C_4^2.
vapour QuotientSize: RngIntElt Default: 0If the value n is bigger than zero, the algorithm returns if a quotient of order bigger or equal to n has been found. A warning message will be printed.
vapour SectionSize: RngIntElt Default: 0If the value s is bigger than zero, the algorithm returns if the order of a section is bigger than or equal to s. A warning message will be printed.
Note: Since an additive bound on a group order is not as meaningful as a multiplicative bound, the latter options are only useful as break conditions when the quotient gets too big for further calculations. The return quotient which hits such a bound is somewhat randomly chosen, since only a change in the order of checking modules may lead to other quotients.
With the following options the strategy of the algorithm and some subalgorithms can be chosen.
vapour MSQ_Series: MonStgElt Default: "sag"Determines the series which is used for the construction of soluble groups.
The default value is "sag", since it is usually the most efficient choice. Of course, there is a value "derived", exhibiting the derived series.
Another choice is "lowercentral", choosing the lower central series. This restricts the algorithm to finite nilpotent quotients. The choice "pcentral" only exhibits p-groups as quotients.
The nilpotent resp. p-quotient algorithms are usually more efficient, so these options may only be useful to obtain additional information needed for a SQ-process.
MSQ_PrimeSearchModus: RngIntElt Default: 3Defines at what status of the algorithm the relevant prime search is called.
The possible choices reflect the different intentions of constructing a soluble quotient; for the general situation, (i.e. finding a finite soluble quotient without any information about relevant primes and check its maximality) this option makes only little difference in runtime behaviour.
- No calculation of relevant primes. This is the default value, if the second argument does not request a prime calculation, e.g. if the order of the quotient or its relevant primes are known.
- The relevant primes will be calculated after the soluble quotient algorithm (with the given input) terminates normally. Possibly new relevant primes are returned in a message. If, for example, the second argument is a set S (so no limit on the exponent) and no new relevant primes have been found, the maximality of the soluble quotient is proved.
- As 1, but continues the algorithm when finding new relevant primes.
- Perform the relevant prime calculation after a "main" step in the series, i.e. after completing a nilpotent section in a sag-series resp. a commutator section for the derived series. This is the default value, if prime calculation is required by the second argument. It is a good choice if one wants to construct large finite quotients quickly.
- Note: This option can cause problems in case of a sag-series when infinite soluble quotients exist. For finite quotients, it seems to be the best choice.
- Perform the relevant prime calculation after calculating an elementary abelian layer. This option is preferable, if the sag-series is used and an infinite soluble quotient is possible.
- Perform the relevant prime calculation after each successful lift of a quotient. This option is preferable when infinite sections shall be detected as soon as possible (with respect to the chosen series).
MSQ_ModuleCalcModus: RngIntElt Default: 0In the construction of soluble quotients using a sag-series one can restrict the number of modules by using tensor products and skew symmetric products. This can improve the performance in the case of big soluble quotients, for small quotients the overhead may invalidate the improvement. For other series this option has no meaning. The possible values are:
- Do not apply this technique (default).
- Fast version, just apply those parts which can be calculated quickly.
- Full version, this is only recommended for "big" soluble quotients, i.e. quotients with long descending series in nilpotent sections.
MSQ_CollectorModus: RngIntElt Default: 2Defines the setup modus for the symbolic collector, i.e. the ratio of precalculation to dynamic setup:
The function also provides a general print option determining the amount of timings status information during the function call. Additionally there are some verbose flags which determine the amount of information given about various subalgorithms. If both a general print value and a verbose flag are given, the verbose flag has higher preference.
- Full precalculation, preferable for small soluble groups.
- Partial precalculation (test version).
- Dynamic setup (default).
Print: RngIntElt Default: 0Determines what timing information and status messages are given during the calculation (0 = no printing, 5 = maximal information).
SetVerbose("MSQ_Verbose_Messages", n): Maximum: 2If set to 1, the sizes of new soluble quotients are printed.
SetVerbose("MSQ_Verbose_PrimeSearch", n): Maximum: 15Bitflag for print levels during the calculation of relevant primes:
- Timings and statistics about the calculation of rational representations.
- Timings for transforming rational into integral representations.
- Timing for finding the relevant primes.
- Printing of new relevant primes.
SetVerbose("MSQ_Verbose_RepsCheck", n): Maximum: 3
- Timing for checking extensions of modules.
- Statistics about the modules to be checked.
SetVerbose("MSQ_Verbose_RepsCalc", n): Maximum: 3
- Timing information about the module calculation.
- Statistics about the module calculation.
SetVerbose("MSQ_Verbose_Collector", n): Maximum: 1If set to 1, the timing for the setup of the symbolic collector is printed.
SetVerbose("MSQ_Verbose_TraceFunc", n): Maximum: 2Give messages about the main function calls (1) resp. most function calls (2) in the Magma language during the algorithm.
In addition to these main functions for the calculation of Soluble Quotients Magma provides a set of functions to construct the quotients interactively, the SQ Process functions. These functions allow a step-by-step construction, giving full control of the extension and normal series to the user. There are various reasons to prefer the SQ Process functions, e.g:
To start a soluble quotient process to calculate a new soluble quotient or to continue with a known quotient, the first step is to initialise a soluble quotient process type:
Initialises a soluble quotient process for the finitely presented group F, i.e. the epimorphism varepsilon: F mapsur < 1 > is created.
Initialises a soluble quotient process for the epimorphism e: F mapsur G. F must be a finitely presented group and G a finite soluble group.
This function is the analogue to SolubleQuotient, returning a soluble quotient process. The argument v and the possible parameters are identical to those in SolubleQuotient. The advantage of this function, over using the SolubleQuotient function, is that much data calculated during the construction of the quotient is stored and available, e.g. the lists of modules or the relevant primes.
Usually the functions for the soluble quotient process run silently, writing the data into the process structure. To obtain and get access to this data, certain functions are provided. We now give a collection of these functions with a brief description of their output. For more detailed information we refer to the corresponding sections and the examples.
The print functions have an optional parameter Print, determining the amount of information printed. The default value is 1, higher values lead to more detailed information.
Print: RngIntElt Default: 1
Prints the pc presentation of the soluble group G in the SQ process. Optionally the images varepsilon(f) for the generators f of F are printed.
Returns the soluble group G and the epimorphism varepsilon : F mapsur G.
Print: RngIntElt Default: 1
Print information about the collectors in SQP. The second version prints information about the actual collector for calculations in characteristic p. We do not provide an access function for the Collector because the structure is for internal use only.
Print: RngIntElt Default: 1
Prints the set of relevant primes stored in SQP, together with a comment whether or not the completeness of the set has been proved.
Returns the set of relevant primes stored in SQP. If a free abelian section has been detected, the set has a 0 as its only element. The second argument is true, if and only if a free abelian section has been detected or the completeness of the set has been proved.
Print: RngIntElt Default: 1
Print the lists of all modules resp. all p-modules stored in SQP. A comment is printed when the list holds a full set of representatives of absolutely irreducible modules. Optionally, information about selected subsets can be printed.
Return p-modules stored in SQP. The first version returns a list of all p-modules stored in SQP, the second the l-th list (specified earlier). The third version returns the i-th module from the list of modules in characteristic p.
Print: RngIntElt Default: 1
Print information about possible split or non-split extensions of (all/ characteristic p) modules stored in SQP. Optionally, the bases of the vector spaces for the tails is printed.
Print: RngIntElt Default: 1
Prints the `relatives' of SQP, i.e. the quotients which can be lifted to the quotient in SQP and those quotients which are lifts of SQP.
Returns a list of soluble quotient processes which can be lifted immediately to SQP.
Returns a list of soluble quotient processes which are lifted immediately from SQP.
Returns the i-th soluble quotient process which is lifted immediately from SQP. In these functions the term `immediate' does not mean that there is no intermediate quotient, it simply means that no intermediate soluble quotient process has been constructed.
Print: RngIntElt Default: 1
Prints information about the weight series, if calculated. Optionally, the list of modules and tails used for the construction of the soluble quotient is printed.The different print functions are sampled in the following functions. The optional argument `Print' is replaced by a set of optional arguments, specifying the amount of printing for each corresponding topic.
Print: RngIntElt Default: 1
Samples the print outputs of the previous functions. If a prime p is specified the information about collectors, modules and extensions is restricted to the characteristic p case. The optional arguments are: `Quotient', `Series', `Primes', `Collector', `Relat', `Modules' and `Extensions'. They define the print level of the corresponding section.
The purpose of the symbolic collector in the context of the SQ algorithm is the setup of the equation systems to determine the possible extensions. In advance some additional conditions can be specified. Typically, these conditions guarantee certain properties of the normal series, e.g. that it is a refinement of the derived series (see example 2). They also decrease the number of indeterminates and may improve the performance of the algorithm.
Let G be a finite soluble group and M a Zfin_p G-module for a prime p. The equation system is of the shape sum_(i, j=1)^n x_(i, j)^(a_(i, j)) = 0, where the x_(i, j) are indeterminates taking values in M.
The a_(i, j) are elements of the group order Zint G. If we fix an irreducible Zfin_p-module, the natural epimorphism Zint G mapsur End (M) induced by the representation G map GL(M) transforms the above equation system into a Zfin_p-linear equation system which can be solved much more easily than the Zint-equations. Although the general setup should always work in principle, the performance can be increased greatly by using additional information, especially:
Setup: MonStgElt Default: "Dynamic"
Setup of the collector for the image G of the soluble quotient stored in SQP. p is either 0 or a prime and defines the characteristic of the coefficient ring. In the prime case the collector is valid only for modules with the same characteristic. tr is a sequence of sequences [j, i] with 1 <= i<j <= n and indicates that only solutions are calculated with trivial x_(i, j). epi:G mapsur Q may give a quotient of G, where Q is also a soluble group. If this argument is given, the collector is valid only for G-modules M with the property all g in Ker(epi) act trivial on M: {g in G | mg=m forall m in M} supset Ker(epi).Note that tr gives additional conditions to the solution space, hence only a (maybe trivial) subspace of all solutions is taken into account. This option can be very useful when calculating certain series, but you should keep in mind that these conditions are applied to any calculation where the collector is used. The function call PrintCollector(SQP, p : Print := 2) shows the argument tr of the collector which is in use for characteristic p.
The argument ws as well as the parameter Setup does only have influence on the performance of the collector. However, the default values of ws and Setup are usually very good, only in a few cases can explicit choices improve the performance. ws defines a weight function on G (see also "Weight Class"). The sequence ws is of increasing integers 1 <= ws[1] <ws[2] ... <ws[k] <= n. It must have the property that the series G > G_1 > ... > G_k > G_(k + 1)= Id, defined by G_i = < h_j | ws [i] <= j <= n > is normal and each section is elementary abelian of prime power order.
The parameter Setup determines whether the data needed during a collection are precalculated ("static") or calculated when needed ("Dynamic"). The latter value is the default value, and generally the performance is better for smaller k. On the other hand, if G itself is small or G only admits a quite long series (i.e. k >= n/2), the "static" setup might lead to better performance.
Delete all/split/nonsplit collectors of SQP with coefficient ring of characteristic p (p a prime or 0).
Delete all/split/nonsplit collectors of SQP with coefficient ring of any characteristic.
Calculates the set of relevant primes for the soluble quotient stored in SQP. If a free abelian section is detected, the set of relevant primes is set to { 0 } for this quotient and all lifts of it.
IsComplete: BoolElt Default:
Add the given prime resp. the given set of primes to the set of relevant primes.
IsComplete: Any Default:
Replace the set of relevant primes by the given set. The optional parameter IsComplete must be of type BoolElt and determines whether the new set of relevant primes is marked as being complete. If the parameter is omitted, the old status will be kept unchanged.We point out that these functions allow direct data manipulation, so they must be used very carefully. The main purposes of these functions are:
- To enter additional information to the algorithm.
- To focus on a special set of primes for further computation, e.g. to continue the calculation for certain primes in case of a free abelian section.
- To avoid the prime calculation for a soluble quotient.
Calculate lists of irreducible modules of the group G. If no further argument is given (and no free abelian module has been detected), the modules in the characteristics of all (known) relevant primes will be calculated. (See also the previous section.) For other primes or in case of the existence of an extension of a free abelian section, the prime can be specified by the second argument. The optional parameters and their default values are:
MaxDimension: RngIntElt Default: 0Put a limit on the GF(p) -dimension of the modules. The default value 0 means no limit.
ExactDimension: SetEnum[RngIntElt] Default: emptysetIf this set is nonempty, it is required that the GF(p) -dimension of the modules must be in the set.
Calculate the solution spaces of splitting extensions that lift to bigger quotients. The first three versions use the lists of modules stored in SQP and can recognise results from earlier calculations. The latter two versions always perform the complete calculation.These functions need the symbolic collector. It searches for a collector in the following manner:
The return is an integer resp. a sequence of integers and indicates the kind of the solution space for the checked modules. A -1 in the return indicates that there is no nontrivial solution, independent of the choice of the collector. (Let me remind you that additional conditions can be introduced with the setup of the collector.) A 0 is returned if no nontrivial solution for this collector exists. If nontrivial solutions exist, the dimension of the solution space over the minimal splitting field of the module is returned.
- Use a collector with a coefficient ring R of the same characteristic, if it exists.
- Use a collector with Zint as coefficient ring, if it exists.
- Create a general symbolic collector with coefficient ring Zint .
Calculate the solution spaces for non-split extensions that lift to bigger quotients. These functions need the symbolic collector. The collector is chosen in the same way as described above. The return has also the same interpretation as above. We want to point out that the solution space and the performance of these functions heavily depend on the choice of the collector. The choice of pairs < j, i > of trivial tails can improve the performance drastically, yet it can also remove solutions. Therefore, the solution spaces are always linked to the module and the collector. We strongly recommend that users check these choices carefully. Because of different choices of collectors, more than one solution space can be stored for each module. In case of several solution spaces the one calculated last is marked as the actual solution space and is the default space for further functions.
Delete the k-th split / non-split solution space of the i-th p-module.
The construction of the extension group G.M together with the lift of the epimorphism varepsilon is the final step in the soluble quotient algorithm. Let us point out the following items you should keep in mind when using these functions:
LinComb: [[FldFinElt]] Default: [[]]
Build the standard split extension G.M and lift the epimorphism varepsilon to a bigger quotient. In the first function, M is the i-th module in characteristic p, and the lift will use the k-th solution space calculated for M. The other functions work iteratively over the specified list of modules, and the actual solution spaces will be used. The second function uses the l-th list of p-modules, the third function all p-modules. Finally the fourth function takes all modules stored in SQP into account. For the meaning of the optional parameter Lincomb in the first form please see the next subsection. The return is the number of modules by which the quotient has been lifted, and the final soluble quotient. For example, if nontrivial solution spaces exist for three modules M_1, M_2, M_3, the soluble group returned is ((G.M_1).M_2).M_3. The intermediate quotients G.M_1 and (G.M_1).M_2 will also be created; they are stored as child resp. child of child of SQP.
Build the standard split extension G.M and lift the epimorphism varepsilon to a bigger quotient. These functions differ from the above group of functions in that way that for each specified module M_i with a nontrivial solution is the number m of modules with lifts. The returned soluble quotient is the input quotient, where m new children have been appended to the list of children.
LinComb: [[FldFinElt]] Default: [[]]
Build the non-split extension G.M and lift the epimorphism varepsilon to a bigger quotient. The meaning of the arguments and the iteration is done in the same way as for the corresponding split extension functions. For the meaning of the optional parameter Lincomb in the first form please see the next subsection.
Build the non-split extension G.M and lift the epimorphism varepsilon to a bigger quotient. The meaning of the arguments and the iteration is done in the same way as for the corresponding split extension functions.
Two functions in the previous section have an optional parameter LinComb, which need some detailed explanation. Using this parameter it is possible to choose a set of individual cocycles from the solution space. Since one can specify additional conditions for the solution space in the collector, there is usually no need to use this parameter in an average application. We recommend that this feature be used very carefully and the results double-check, since incorrect arguments can easily lead to wrong or misleading results. Typically either a soluble group may appear such that the homomorphism is not surjective, or (the series of) the soluble group does not have the desired properties. However, this function parameter may be particularly interesting in the situation of constructing a soluble group as a quotient of a free group.
To describe the use of this parameter, we need to explain the representation of cocycles in Magma. Let us remind you of some theory noted in the beginning of this section: Let F = < f_1, ..., f_r > be a finitely presented group on r generators. Let G denote a finite soluble group which is the image of a quotient varepsilon: F map G. Let M be a KG -module of dimension c, with K = GF(q), q = p^d is the minimal splitting field of M. We identified a K-space S subset M^r x C^2(G, M) as the space of extended tails, and a K-subspace S_S subset S for which the extension M.G splits. Each element of S is described by a set of images (g_i^(p_i - 1), g_i) emap m_(ii), (g_j, g_i) emap m_(ij), f_k emap m_(k0) (1 <= i <= n, i < j <= n, 1 <= k <= r).
It is crucial to understand S as a K-space, e.g. to obtain the maximal multiplicity a as the dimension of S\ S_S. Therefore we decided to choose an K-representation for the extended tails. On the other hand the pc-presentation of M.G only reflects M as an elementary abelian group, generated by the elements of an GF(p)-base of M. The correspondence of M as an abelian group to M viewed as an GF(p)-module is induced by the regular representation of GF(q) as GF(p) -algebra: GF(q) hookrightarrow GF(p)^(d x d). Applying this homomorphism to each entry of the elements of M, we obtain a homomorphism: mu: M isom GF(q)^c map GF(p)^(d x cd) This homomorphism can be used to read the presentation of the lift from the chosen element of S\ S_S. S is represented by an K-base with these properties:
Returns true if and only if SQP is a valid soluble quotient, that is:There are several checks to avoid invalid quotients, and the first case shall never happen. However, some functions allow data manipulation that may lead to a violation of the second item. In this case, please check carefully the steps that lead to this soluble quotient process.
- The map varepsilon: F map G is indeed a homomorphism, and
- varepsilon is surjective.
Checks the equivalence of two soluble quotients, i.e. the return is true if and only if both epimorphisms have the same kernel. The default use of this function is only to check the equivalence. If the quotients are not equivalent and optional parameter Construct is set true, a bigger soluble quotient will be returned, where the kernel of the epimorphism is the intersection of the given kernels. (See also IntersectKernels)
Many normal series, like the derived series, the nilpotent series or the sag series can be used to construct a soluble group in a soluble quotient algorithm. To obtain such a series, additional conditions for the extension must be required, most commonly that certain tails must be trivial. Choosing a series with some additional properties is often not only desirable, but also an improvement in the performance of the algorithm. For example, the main SolubleQuotient function uses the sag series because in most cases this series is the most efficient way to construct the quotients. The following group of functions create sequences to formulate such requirements. The sequences are intended to be used as input arguments for the setup functions for the collector (in case of a non-split extension). Again let G = < g_1, ... , g_n | ... > denote the pc presentation of the soluble group G. Let p_1, ... p_n denote the indices of g_i. A general property is that the order of elements is not mixed up Hall property, i.e.
Returns a sequence of indices [i, i], [j, i] with p_i != p resp. i < j and p not in {p_i, p_j}. If one requires the above property, these tails must be trivial for an extension of a p-module. Unless one wants to use a series that contradicts this property, we recommend using this feature systematically, especially for big soluble quotients, since it improves the performance a lot. On the other hand, if you have already constructed a quotient without this property, you must not use this function any more, since possible solutions might get lost.Let H = < g_1, ... g_n, h_(1) ... h_(r) | ... > be a soluble group which is a lift of G. Let q_1, ..., q_r denote the indices of h_1, ... h_r, and S = <h_1, ..., h_r> denote the subgroup generated by h_1, ... h_r. To lift a quotient with H in a certain way, the relations of H can be divided into 5 groups, depending on their left-hand side:
These functions return sequences of pairs of indices <i, i> resp. <i, j> of one or more of these groups. Their names indicate their primary purpose, however, they can be used in any context. SQG is the soluble quotient process with soluble group G, SQH is related to H.
- The left-hand side of the relation is g_i^(p_i) (1 <= i <= n).
- The left-hand side of the relation is g_j^(g_i) (1 <= i < j <= n).
- The left-hand side of the relation is h_i^(q_i) (1 <= i <= r).
- The left-hand side of the relation is h_j^(h_i) (1 <= i < j <= r).
- The left-hand side of the relation is h_j^(g_i) (1 <= i <= n, 1 <= j <= r).
Returns the sequence of indices belonging to the first type. This means that the order of the generators g_1, ... g_n is kept unchanged.
Returns the sequence of indices belonging to the second type. This means that the conjugation action in G is kept unchanged.
Returns the sequence of indices belonging to the first and second type. This means that the relations of G are kept unchanged. Especially, if H is a split extension of S by G, then the lift will be a split extension of the lift of S by G.
The next three functions get their names from the situation that S is (elementary) abelian, but this property is not required.
Returns the sequence of indices belonging to the third type. This means that the order of the generators h_1, ... h_n is kept unchanged.
Returns the sequence of indices belonging to the fourth type. This means that the conjugation action in S is kept unchanged. Especially, if this subgroup is abelian, the lift of it will also be abelian.
Returns the sequence of indices belonging to the third and fourth type. This means that the relations of S are kept unchanged. Especially, if S is elementary abelian, the lift of it will also be elementary abelian.
Returns the sequence of indices belonging to the fifth type. This means that the conjugation action of g_1, ..., g_n on the subgroup S is kept unchanged. Especially, if H is a direct sum of G and S and we are interested in S-modules (i.e. G acts trivially), then the lift will be a direct sum of G and the lift of S.
Returns the sequence of indices belonging to the first, second and fourth type. If H is a split extension of S by G and S is abelian, then the lift of S is still abelian, and the extension by G splits.
Returns the sequence of indices belonging to type 1 - 4. If H is a split extension of S by G and S is elementary abelian, then the lift of S is still elementary abelian, and the extension by G splits.Note that the sequence belonging to all types 1-5 would mean that the extension splits, hence is covered by the separate functions for split extensions.
Build a bigger soluble quotient from the given quotients by intersecting the kernels. The second and third return values are (surjective) maps from the new soluble group to the given soluble groups. If the intersection of the kernels is equal to one of the given kernels, a warning message will be printed, and the return is just the corresponding soluble quotient.Note: The main purpose of this function is to build big quotients from different small ones. This function does not necessarily respect the structure of the series of the input soluble groups. Also the new soluble quotient will inherit only few data from the given ones, like the sets of relevant primes. Information about modules and extension spaces of the input quotients will not be inherited.
Build a bigger soluble quotient from the given lifts SQ2 and SQ3 of Q1, respecting the series of the soluble groups in the following sense: Let varepsilon_i: F map G_i denote the soluble quotients of SQi, i in {1..3} Then the soluble group G of the quotient returned is G = G_2.S_3, where S_3 is the subgroup of G_3 extended by G_1, i.e. G_3 = G_1.S_3. To that purpose SQ2 and SQ3 must be two totally different lifts of SQ1 the sense that the intersection of the kernels of varepsilon_1 and varepsilon_2 must have maximal index: [Ker(varepsilon): Ker(varepsilon_1)] = [Ker(varepsilon_2): Ker(varepsilon_1)][Ker(varepsilon_3): Ker(varepsilon_1)]. If the optional boolean parameter Check is set true (default), this condition will be checked. The return is true and the composed soluble quotient if the condition is fulfilled, otherwise the return is false and the soluble quotient returned by the above function IntersectKernels. So this function may be used in any case; however, if the return is false, the series structure cannot be guaranteed. The above condition will not be checked if the optional parameter Check is set to false. In this case the map in the structure returned is always varepsilon: F -> G= G_2.S_3, and the boolean indicates whether or not this is a valid quotient. (If the returned boolean is false, the map is not surjective.)
The functions and tools presented so far are designed to calculate soluble quotients in full generality and with the highest freedom of choice of the series. But often one is interested in some standard series, e.g. the derived series or the Fitting series. This means on one hand that the algorithm provides more information than we are really interested in, on the other hand we need to investigate more work to ensure that we actually do calculate the soluble quotient using a specific series. To illustrate this point, let us focus on a soluble quotient using the derives series: All information we really need is to find the maximal module with a lift of the known quotient. To determine this module, the following steps must be performed. (As usually, we denote the soluble quotient varepsilon: F map G.
PrimeCalc: BoolElt Default: true
ModuleList: RngIntElt Default: -1
TrivialTails: SeqEnum Default: []
Calculates the biggest module M which leads to a lift. If the prime p is given, then M is of p-power order, otherwise the prime divisors of the order of M are elements of the set of relevant primes Note that the iterative use of this function leads to the derived series of the quotient group.
PrimeCalc: BoolElt Default: true
ModuleList: RngIntElt Default: -1
TrivialTails: SeqEnum Default: []
If the prime p is given, the function calculates the biggest elementary abelian p-module M which has a lift. If the prime is not specified, then M is the direct sum of elementary abelian modules of characteristics in the set of relevant primes. Let us point out that an iterative use of this function is not a refinement of the derived series. In case of a p-group the iterative use leads to the p-lower descending central series.
PrimeCalc: BoolElt Default: true
ModuleList: RngIntElt Default: -1
TrivialTails: SeqEnum Default: []
Calculates the biggest p-group resp. nilpotent group with a split extension that leads to a lift of the soluble quotient. Note that this function may not return in case of an infinite abelian section.
PrimeCalc: BoolElt Default: true
ModuleList: RngIntElt Default: -1
TrivialTails: SeqEnum Default: []
Calculates the biggest module M with a split extension that leads to a lift. If the prime p is given, then M is of p-power order, otherwise the prime divisors of the order of M are in the actual set of relevant primes.
PrimeCalc: BoolElt Default: true
ModuleList: RngIntElt Default: -1
TrivialTails: SeqEnum Default: []
If the prime p is given, the function calculates the biggest elementary abelian p-module M with a split extension that leads to a lift. If the prime is not specified, then M is the direct sum of elementary abelian modules of characteristics in the actual set of relevant primes.
PrimeCalc: BoolElt Default: true
ModuleList: RngIntElt Default: -1
TrivialTails: SeqEnum Default: []
These functions correspond to the respective earlier functions; now only non-split extensions are taken into account. Note that the two last functions lead to Frattini extensions of the soluble quotient.
PrimeCalc: BoolElt Default: true
ModuleList: RngIntElt Default: -1
TrivialTails: SeqEnum Default: []
Steps: RngIntElt Default: -1
Calculate the biggest p-group resp. nilpotent group with a lift of the soluble quotient. The groups are calculated using the descending series, so a weight function is introduced and used to improve the performance of the algorithm. Note that the iterative use of this function leads to a SAG-series for the soluble quotient. For these functions we assume that there is no non-split extension with a lift for the initial soluble quotient possible. We recommend to check non-split extensions before using these functions, otherwise the return is still a valid soluble quotient, but the internal structure of the section may not reflect the descending series.
The optional parameters described above are also available for these functions. In addition to these parameters there is the parameter Steps, taking a non-negative integral value. It gives an upper bound for the length of the descending series; there is no default bound given. This parameter is useful especially in case of infinite abelian sections, since their existence in the section cannot be exclude a priori, as it is the case for most of the upper functions.
We want to mention some details about these function compared to the functions SplitSection. The functions SplitSection may lead to smaller soluble quotients, since the condition is that the whole extension splits. In these functions this condition is only requested for the first layer of the descending series. So a call to SplitSection followed by a call to NonsplitSection will lead to the same quotient, but the series are still different. Another difference is that the upper functions do not take care of the internal structure of the section. Therefore, these functions may be preferable for small nilpotent sections, especially if no infinite abelian section is expected. The latter functions have better performance for big sections and provide the additional parameter Steps to deal with infinite sections.
> FG<a,b> := FreeGroup(2); > F := quo< FG | > a^3 = Id($), > a^-1 * b * a^-1 * b^-1 * a * b * a * b^-1 = Id($), > b^8 = Id($), > a^-1 * b^-4 * a * b^4 = Id($), > a*b^-2 * a * b^-2 * a^-1 * b^-2 * a^-1 * b^-2 * a * b^2 > * a * b^2 * a^-1 * b^2 * a^-1 * b^2 = Id($), > a^-1 * b^-2 * a^-1 * b^-2 * a^-1 * b^-2 * a^-1 * b^-2 * > a^-1 * b^-2 * a^-1 * b^-2 * a^-1 * b^2 * a^-1 * b^2 * a^-1 > * b^2 * a^-1 * b^2 * a^-1 * b^2 * a^-1 * b^2 = Id($) >;
Initialize a soluble quotient process and find the first set of relevant primes.
> S2 := Initialize(F);
> Primes(S2);
> PrintPrimes(S2);
Soluble Quotient:
Image of order 1
Complete set of relevant primes is { 2, 3 }
> Modules(S2);
[ <2,1>,<3, 1> ]
Modules in characteristics 2 and 3 have been calculated. The lists of them have index 1 each. We can print more module information:
> PrintModules(S2);
Soluble Quotient:
Image of order 1
1 found in characteristic 2
This list is complete.
1 found in characteristic 3
This list is complete.
> SplitExtensionSpace(S2);
[
<2, [ 1 ]>,
<3, [ 1 ]>
]
A one-dimensional solution space has been determined for each module. Again we want to print this information:
> PrintExtensions(S2); Soluble Quotient: Image of order 1 Extensions in characteristic 2 : Modul 1 : 1 Solution spaces with split extensions calculated, multiplicity: [ 1 ] Nonsplit Extension Space unknown Extensions in characteristic 3 : Modul 1 : 1 Solution spaces with split extensions calculated, multiplicity: [ 1 ] Nonsplit Extension Space unknown
Since the soluble group so far is just the trivial group, there cannot be any nonsplit extensions, so we skip their calculation.
> f, S3 := LiftSplitExtension(S2);
> f; 2
Two modules were involved in the construction of the new soluble quotient.
2-modules and 3-modules were calculated. The indices of the lists are 2 in both characteristics. (The first list is the copy of the lists of modules in S2.)
> PrintQuotient(S3); Soluble Quotient of Finitely presented group on 2 generators Relations (... relation of F ) Image is: GrpPC of order 6 = 2 * 3 PC-Relations: $.1^2 = Id($), $.2^3 = Id($)
> Modules(S3); [<2, 2>, <3,2> ]
> SplitExtensionSpace(S3); [ <2, [ -1, -1 ]>, <3, [ -1, 1 ]> ]
In characteristic 2 no split extension will lead to a lift of the quotient. In characteristic 3 there is a split extension of the second module that will lead to a lift of the quotient.
Now since the order of the soluble group is divisible by 2 and 3, there may be nonsplit extensions of modules that lift. We calculate these:
> NonsplitExtensionSpace(S3); [ <2, [ 1, -1 ]>, <3, [ -1, -1 ]> ]
In characteristic 2 a nonsplit extension of the first module will lead to a lift of the quotient. In characteristic 3 no nonsplit extension will lead to a lift of the quotient. We first use the split extension to lift the quotient.
> f, S4 := LiftSplitExtension(S3);
The data about the nonsplit extension has been copied into S4. We can construct the lift of the quotient by this nonsplit extension without new calculations.
> f, S5 := LiftNonsplitExtension(S4);
Now let us check the set of relevant primes again. Since we do not use a specific series in this example, there is no rule that determines when the relevant primes should be calculated. Since the relevant prime calculation is a complex and time-consuming algorithm, a rule of thumb is to check for new primes very carefully in small quotients, maybe by computing different small quotients. However, the soluble quotient process stores data about relevant primes. If one really wants to find the biggest soluble quotient and prove its maximality, the amount of work is always the same, independent of how often this function has been called.
> Primes(S5);
Again we calculate the p-modules for all relevant primes simply by:
So the set of relevant primes is still {2, 3 }. In each characteristic two lists have been copied from S4, so the new lists have index 3 each.
> Modules(S5); [ <2,3>, <3,3> ]
> SplitExtensionSpace(S5); [ <2, [ -1, -1, -1, 1 ]>, <3, [ -1, -1, 1 ]> ]
Split extensions with lifts exist for the fourth 2-module and the third 3-module.
> NonsplitExtensionSpace(S5); [ <2, [ 1, -1, -1, -1 ]>, <3, [ -1, -1, -1 ]> ]
A nonsplit extension with lift exists for the first 2-module only. Before lifting this quotient, we want to have a look at all data related to S5. We use the general print function and choose the highest print level for each section.
> PrintProcess(S5: Quotient:= 2, Primes := 1, Collector := 1, Relat := 1,
> Modules := 3, Extensions := 2); =============== Soluble quotient info ========================= Soluble Quotient of Finitely presented group on 2 generators Relations ( ... relations of F ) Image is: GrpPC of order 36 = 2^2 * 3^2 PC-Relations: $.1^2 = $.4, $.2^3 = Id($), $.3^3 = Id($), $.4^2 = Id($), $.3^$.1 = $.3^2 The Generators are mapped to: [ $.2 * $.3, $.1 ] [] =============== relevant primes =============================== Complete set of relevant primes is { 2, 3 } =============== active Collectors ============================= Collectors for nonsplit extensions active with coefficient ring characteristic: { 0 } Collectors for split extensions active with coefficient ring characteristic: { 0 } =============== related quotients ============================= 1 quotients found that lift to this quotient. 0 quotients found that are lifts of this quotient. =============== irreducible modules =========================== Modules found in characteristic 2 : This list is complete. [* <32884, GModule of dimension 1 over GF(2)>, <27712, GModule of dimension 1 over GF(2^2)>, <154436, GModule of dimension 2 over GF(2)>, <154176, GModule of dimension 2 over GF(2^2)> *] The following sublists have been created: <{}, 0, [**]> <{}, 0, [**]> Modules found in characteristic 3 : This list is complete. [* <33692, GModule of dimension 1 over GF(3)>, <27596, GModule of dimension 1 over GF(3)>, <154472, GModule of dimension 1 over GF(3^2)> *] The following sublists has been created: <{}, 0, [**]> <{}, 0, [**]> =============== extension spaces ============================== Extensions in characteristic 2 : Modul 1 : No split extensions possible Solution spaces with nonsplit extensions: [ <1, 1, [0], [1] [0] [0] [0]>, <3, 3, [0], [0] [0] [1] [0]>, <2, 2, [0], [0] [1] [0] [0]>, <3, 1, [0], [0] [0] [1] [0]>, <4, 4, [1], [0] [0] [0] [0]>, <1, 0, [0], [0] [1] [1] [0]>, <2, 0, [0], [0] [0] [0] [1]> ]
Let G = < g_1, g_2, g_3, g_4| ... > denote the soluble group and its pc generators. For the nonsplit extension the righthand side of the pc relations with lefthand sides g_1^2, g_3^3, g_2^3, g_3^(g_1), g_4^2 may be modified. Also the images of the first and second generators of F might be modified. The solution space is one dimensional, and there exists a four dimensional space of coboundaries, i.e. these elements do not lead to a lift themselves, but can be used to modify a nontrivial element of the solution space.
Modul 2 : No split extensions possible
No nonsplit extensions possible
Modul 3 : No split extensions possible
No nonsplit extensions possible
Modul 4 : Solution spaces with split extensions:
[
<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]>,
<2, 0, [0 0 1 0], [0 0 0 0]
[1 0 1 0]
[0 0 0 1]
[0 0 0 0]
[0 1 0 1]>
]
So this module allows a standard split extension that lifts. The solution space is one dimensional, and there is a five dimensional space of coboundaries to modify the element.
No nonsplit extensions possible
Extensions in characteristic 3 : Modul 1 : No split extensions possible
No nonsplit extensions possible
Modul 2 : No split extensions possible
No nonsplit extensions possible
Modul 3 : Solution spaces with split extensions:
[
<1, 0, [1 0], [0 0]
[0 1]
[0 0]>,
<2, 0, [0 0], [1 0]
[0 0]
[0 1]>
]
No nonsplit extensions possible
===============================================================
> f,S6 := LiftSplitExtension(S5);
Again the information about the possible nonsplit extensions are inherited by S6, so:
> f,S7 := LiftNonsplitExtension(S6);
> SQ_check(S7); true
This check ensures that S7 is a valid soluble quotient, i.e. that the map is indeed a homomorphism, and that it is surjective.
> Modules(S7); [ <2, 4>, <3, 4> ]
> SplitExtensionSpace(S7); [ <2, [ -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1 ]> <3, [ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ]> ]
> NonsplitExtensionSpace(S7); [ <2, [ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ]> <3, [ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ]> ]
> f,S8 := LiftSplitExtension(S7);
Now we want to get the epimorphism and the soluble group:
> G, epi := GetQuotient(S8);
> G; GrpPC : G of order 165888 = 2^11 * 3^4 PC-Relations: G.1^2 = G.4, G.2^3 = Id(G), G.3^3 = Id(G), G.4^2 = G.11, G.5^2 = Id(G), G.6^2 = Id(G), G.7^2 = Id(G), G.8^2 = Id(G), G.9^3 = Id(G), G.10^3 = Id(G), G.11^2 = Id(G), G.12^2 = Id(G), G.13^2 = Id(G), G.14^2 = Id(G), G.15^2 = Id(G), G.3^G.1 = G.3^2, G.5^G.1 = G.7, G.5^G.2 = G.6, G.5^G.3 = G.6, G.6^G.1 = G.8, G.6^G.2 = G.5 * G.6, G.6^G.3 = G.5 * G.6, G.7^G.1 = G.5, G.7^G.2 = G.8, G.7^G.3 = G.7 * G.8, G.8^G.1 = G.6, G.8^G.2 = G.7 * G.8, G.8^G.3 = G.7, G.9^G.1 = G.9 * G.10, G.9^G.4 = G.9^2, G.10^G.1 = G.9 * G.10^2, G.10^G.4 = G.10^2, G.12^G.1 = G.14, G.12^G.10 = G.13, G.13^G.1 = G.14 * G.15, G.13^G.4 = G.12 * G.13, G.13^G.10 = G.12 * G.13, G.14^G.1 = G.12, G.14^G.9 = G.15, G.14^G.10 = G.14 * G.15, G.15^G.1 = G.13, G.15^G.4 = G.14 * G.15, G.15^G.9 = G.14 * G.15, G.15^G.10 = G.14
> T2 := Initialize(F);
> Primes(T2);
> Modules(T2); [ <2, 1>, <3, 1> ]
> SplitExtensionSpace(T2); [ <2, [ 1 ]>, <3, [ 1 ]> ]
> f, T3 := LiftSplitExtension(T2);
Now it is well-known that the first section of a derived series is the biggest abelian quotient. So for the next step we need to require that the lift keeps the conjugation relation unchanged. Hence:
> S := KeepAbelian(T2, T3);
> S; [ [ 2, 1 ] ]
This condition must be required for all primes, so we can use the characteristic 0 collector for T3.
> NonsplitCollector(T3, 0, S);
> NonsplitExtensionSpace(T3); [ <2, [ 1 ]>, <3, [ 0 ]> ]
> f, T4 := LiftNonsplitExtension(T3);
Now we need the condition of being abelian for T4:
> S := KeepAbelian(T2,T4);
Furthermore only a 2-module led to a lift the last time, hence there cannot be a lift of a 3-module now. We can restrict our calculations to the characteristic 2 case. So we can require the Hall-condition for the prime 2:
> S cat:= KeepPrimePower(T4, 2);
> S; [ [ 2, 1 ], [ 3, 1 ], [ 3, 2 ], [ 2, 2 ] ]
Note that the first three items are returned by KeepAbelian, while the last item belongs to KeepPrimePower.
> NonsplitCollector(T4, 0, S);
> NonsplitExtensionSpace(T4, 2); [ 1 ]
> f, T5 := LiftNonsplitExtension(T4);
Since the last step was again successful, we need to repeat it again:
> S := KeepAbelian(T2,T5);
> S cat:= KeepPrimePower(T5, 2);
> NonsplitCollector(T5, 2, S);
> NonsplitExtensionSpace(T5, 2); [ 0 ]
> PrintQuotient(T5); =============== Soluble quotient info ========================= Soluble Quotient of Finitely presented group on 2 generators Relations ( ...) Image is: GrpPC of order 24 = 2^3 * 3 PC-Relations: $.1^2 = $.3, $.2^3 = Id($), $.3^2 = $.4, $.4^2 = Id($) ===============================================================
We see that no further lift to an abelian group exists, hence F/F' is of order 24, and it is isomorphic to C_3 x C_8. Now the theory points out that the calculation of relevant primes considers the derived series in a natural way, i.e. now is the canonical time to calculate the new set of relevant primes.
> Primes(T5);
> Modules(T5); [ <2, 2>, <3, 2> ]
Since only modules in characteristic 2 and 3 have been calculated, we implicitly see that these are still the only relevant primes. Both primes are divisors of the group order 24, hence both split and nonsplit extensions are possible.
> SplitExtensionSpace(T5); [ <2, [ -1, -1 ]>, <3, [ -1, 1, 1, -1, -1 ]> ]
Only split extensions of 3-modules lead to a lift. Now no restriction on a nonsplit extension is necessary. But we used a collector in characteristic 2 for which restrictions were given. We can check it by printing the information about nonsplit collectors:
> PrintCollector(T5: Print := 2); Soluble Quotient: Image of order 24 =============== active Collectors ============================= Active Collectors for nonsplit extensions: Coefficient ring characteristic: 2 [ [ 2, 1 ], [ 3, 1 ], [ 4, 1 ], [ 3, 2 ], [ 4, 2 ], [ 4, 3 ], [ 2, 2 ] ] Active Collectors for split extensions: Coefficient ring characteristic: 0 ===============================================================
We have two possibilities to change this collector:
> DeleteNonsplitCollector(T5, 2);
Now no collector exists, so the standard collector will be created automatically in the next function:
> NonsplitExtensionSpace(T5); [ <2, [ -1, -1 ]>, <3, [ -1, -1, -1, -1, -1 ]> ]
No nonsplit extension leads to a lift.
> f, T6 := LiftSplitExtension(T5);
Now we are interested in finding the next abelian section F' / F", hence we require that further lifts must keep the last section abelian. Furthermore the last section is a 3-power, so only 3-modules need to be considered.
> S := KeepAbelian(T5, T6);
> S cat:= KeepPrimePower(T6, 3);
> S; [ [ 6, 5 ], [ 7, 5 ], [ 7, 6 ], [ 1, 1 ], [ 3, 1 ], [ 4, 1 ], [ 3, 3 ], [ 4, 3 ], [ 4, 4 ] ]
Note that only the first three items are created in KeepAbelian. So the second requirement leads to much smaller equation systems and to remarkable improvements of the efficiency of the calculations, while it does not delete relevant solutions.
> NonsplitCollector(T6, 3, S);
> NonsplitExtensionSpace(T6, 3); [ 0, 0, 0, 0, 0 ]
This means that the calculation of F/F" is complete now. Note that the output entries are zeros and not -1 as before. This indicates that additional conditions have been considered. There might be other extensions that would lead to a lift of the quotient, but they have not been calculated. If we print the quotient of T6, we see that the group order is now 648, hence F' / F" has order 27. We got it in one go, so it is isomorphic to C^3_3. We continue by calculating F / F^((3)). It is a repetition of functions we have used before:
> Primes(T6);
> Modules(T6); [ <2, 3>, <3, 3> ]
> SplitExtensionSpace(T6); [ <2, [ -1, -1, -1, 1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1 ]>, <3, [ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ]> ]
Again a nonsplit collector in characteristic 3 is active, we need to delete it first:
> DeleteNonsplitCollector(T6, 3);
> NonsplitExtensionSpace(T6); [ <2, [ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ]>, <3, [ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ]> ]
So only split extensions of 2-modules lead to lifts.
> f, T7 := LiftSplitExtension(T6, 2);
> S := KeepAbelian(T6, T7);
> S cat:= KeepPrimePower(T7, 2);
> NonsplitCollector(T7, 2, S);
> NonsplitExtensionSpace(T7, 2); [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
No solutions have been found, so the calculation of F/F^((3)) is complete.
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
> G := GetQuotient(T7);
> FactoredOrder(G); [ <2, 11>, <3, 4> ]