3 Further functions

A short remark is probably in order on the three global variables the package is using: `HeLP_CT`

, `HeLP_sol`

and `HeLP_settings`

. The first one stores the character table for which the last calculations were performed, the second one containing at the `k`

's spot the already calculated admissible partial augmentations of elements of order \(k\) (and its powers \(u^d\) for \(d \not= k\) a divisor of \(k\)). If a function of the HeLP-package is called with a character table different from the one saved in `HeLP_CT`

then the package tries to check if the character tables belong to the same group. This can be done in particular for tables from the ATLAS. If this check is successful the solutions already written in `HeLP_sol`

are kept, otherwise this variable is reset. For a more detailed account see Sections 4.2, 5.2 and `HeLP_ChangeCharKeepSols`

(3.4-1). In most situations, the user does not have to worry about this, the program will take care of it as far as possible. `HeLP_settings`

is a varaible which is used to store some settings of the program.

`‣ HeLP_WithGivenOrder` ( CharacterTable|ListOfClassFunctions, ord ) | ( function ) |

Returns: List of admissible partial augmentations

Calculates the admissible partial augmentations for elements of order `ord` using only the data given in the first argument. The first argument can be an ordinary character table, a Brauer table, or a list of class functions, all having the same underlying character table. This function only uses the constraints of the HeLP method (from the class functions given), but does not apply the Wagner test 5.4. If the constraints allow only a finite number of solutions, these lists will be written in `HeLP_sol[ord]`

. If for divisors \(d\) of `ord` solutions are already calculated and stored in `HeLP_sol[d]`

, these will be used, otherwise the function `HeLP_WithGivenOrder`

will first be applied to this order and the data given in the first argument.

`‣ HeLP_WithGivenOrderAndPA` ( CharacterTable|ListOfClassFunctions, ord, partaugs ) | ( function ) |

Returns: List of admissible partial augmentations

Calculates the admissible partial augmentations for elements of order `ord` using only the data given in the first argument. The first argument can be an ordinary character table, a Brauer table, or a list of class functions, all having the same underlying character table. The function uses the partial augmentations for the powers \(u^d\) with \(d\) divisors of \(k\) different from \(1\) and \(k\) given in `partaugs`. Here, the \(d\)'s have to be in a descending order (i.e. the orders of the \(u^d\)'s are ascending). This function only uses the constraints of the HeLP method, but does not apply the Wagner test 5.4. Note that this function will not affect `HeLP_sol`

.

`‣ HeLP_WithGivenOrderAllTables` ( CharacterTable, ord ) | ( function ) |

Returns: List of admissible partial augmentations

Calculates the admissible partial augmentations for elements of order `ord` using the given character table `CharacterTable` and all Brauer tables that can be obtained from it. `CharacterTable` can be an ordinary or a Brauer table. In any case, then given table will be used first to obtain a finite number of solutions (if the characteristic does not divide `ord`, otherwise the ordinary table will be used), with the other tables only checks will be performed to restrict the number of possible partial augmentations as much as possible. If certain Brauer tables are not avaialble, this will be printed if HeLP_Info is at least 1. This function only uses the constraints of the HeLP method, but does not apply the Wagner test 5.4. If the constraints allow only a finite number of solutions, these lists will be written in `HeLP_sol[ord]`

. If for divisors \(d\) of `ord` solutions are already calculated and stored in `HeLP_sol[d]`

, these will be used, otherwise the function `HeLP_WithGivenOrder`

will first be applied to this order and the data given in the first argument.

`‣ HeLP_WithGivenOrderAndPAAllTables` ( CharacterTable, ord, partaugs ) | ( function ) |

Returns: List of admissible partial augmentations

Calculates the admissible partial augmentations for elements of order `ord` using the given character table `CharacterTable` and all other tables that can be obtained from it. `CharacterTable` can be an ordinary or a Brauer table. In any case, then given table will be used first to obtain a finite number of solutions (if the characteristic does not divide `ord`, otherwise the ordinary table will be used), with the other tables only checks will be performed to restrict the number of possible partial augmentations as much as possible. If certain Brauer tables are not avaialble, this will be printed if HeLP_Info is at least 1. The function uses the partial augmentations for the powers \(u^d\) with \(d\) divisors of \(k\) different from \(1\) and \(k\) given in `partaugs`. Here, the \(d\)'s have to be in a descending order (i.e. the orders of the \(u^d\)'s are ascending). This function only uses the constraints of the HeLP method, but does not apply the Wagner test 5.4. Note that this function will not affect `HeLP_sol`

.

`‣ HeLP_WithGivenOrderAndPAAndSpecificSystem` ( list, ord, partaugs[, b] ) | ( function ) |

Returns: List of admissible partial augmentations

Calculates the admissible partial augmentations for elements of order `ord` using only the data given in the first argument. The first argument is a list, which can contains as entries characters or pairs with first entry a character and second entrie an integer or a mixture of these. The first argument is understood as follows: If a character \(\chi\) is not given in a pair all inequalities obtainable by this character are used. If it is given in a pair with the integer \(m\) the inequalities obtainable from the multiplicity of `E(ord)`

taken to the power \(m\) as an eigenvalue of a representation affording \(\chi\) are used. The function uses the partial augmentations for the powers \(u^d\) with \(d\) divisors of \(k\) different from \(1\) and \(k\) given in `partaugs`. Here, the \(d\)'s have to be in a descending order (i.e. the orders of the \(u^d\)'s are ascending). This function only uses the constraints of the HeLP method, but does not apply the Wagner test 5.4. Note that this function will not affect `HeLP_sol`

.

When considering elements of order \(st\) (in absence of elements of this order in the group ; in particular when trying to prove (PQ)) and there are several conjugacy classes of elements of order \(s\), it might be useful to consider \(s\)-constant characters (cf. Section 5.5) to reduce the computational complexity.

`‣ HeLP_WithGivenOrderSConstant` ( CharacterTable|ListOfClassFunctions, s, t ) | ( function ) |

Returns: List of admissible "partial augmentations" or `"infinite"`

Calculates the admissible partial augmentations for elements \(u\) of order \(s*t\) using only the \(s\)-constant class functions that are contained in the first argument. The first argument can be an ordinary character table, a Brauer table, or a list of class functions, all having the same underlying character table. `s` and `t` have to be different prime numbers, such that there are elements of order `s` and `t` in the group, but no elements of order \(s*t\).

The function filters which class functions given in the first argument are constant on all conjugacy classes of elements of order `s`. For the element \(u^s\) of order `t` the partial augmentations given in `HeLP_sol[t]`

are used. If they are not yet calculated, the function calculates them first, using the data given in the first argument and stores them in `HeLP_sol[t]`

. This function only uses the constraints of the HeLP method, but does not apply the Wagner test 5.4. If these calculations allow an infinite number of solutions of elements of order \(st\) the function returns `"infinite"`

, otherwiese it returns the finite list of solutions for elements of order \(s*t\). The first entry of every solution is a list of the partial augmentations of \(u^s\) and the second entry is a list of the "partial augmentations" for \(u\): the first entry of this list is the sum of the partial augmentations on all classes of elements of order `s` and the other entries are the partial augmentations on the classes of order `t`. Only in the case that the existence of units of order \(s*t\) can be excluded by this function the variable `HeLP_sol[s*t]`

will be affected and `HeLP_sol[s*t]`

will be set to `[ ]`

.

`‣ HeLP_AddGaloisCharacterSums` ( CT ) | ( function ) |

Returns: List of characters

Given an ordinary character table `CT` the function calculates the orbits under the action of the Galois group and returns a list of characters containing the ones contained in `CT` and the ones obtained by summing up the Galois-orbits.

`‣ HeLP_AllOrders` ( CharacterTable|Group ) | ( function ) |

Returns: `true`

if (ZC) can be solved using the given data, `false`

otherwise

This function does almost the same as `HeLP_ZC`

(2.1-1). It checks whether the Zassenhaus Conjecture can be verified for a group, but does not compute the partial augmentations of elements of order \(k\), if `HeLP_sol[k]`

already exists. It does however verify the solutions given in `HeLP_sol`

using all available tables for the group, see `HeLP_VerifySolution`

(3.6-1). Thus some precalculations using e.g. `HeLP_WithGivenOrder`

(3.1-1) are respected. In contrast to `HeLP_ZC`

(2.1-1) this function also does not check whether the group is nilpotent to use the Weiss-result to have an immediate positive solution for (ZC).

This function is interesting if one wants to save time or possesses some information, which was not obtained using this package and was entered manually into `HeLP_sol`

.

`‣ HeLP_AllOrdersPQ` ( CharacterTable|Group ) | ( function ) |

Returns: `true`

if (PQ) can be solved using the given data, `false`

otherwise

This function does almost the same as `HeLP_PQ`

(2.2-1). It checks whether the Prime Graph Question can be verified for a group, but does not compute the partial augmentations of elements of order \(k\), if `HeLP_sol[k]`

already exists. Thus some precalculations using e.g. `HeLP_WithGivenOrder`

(3.1-1) are respected. In contrast to `HeLP_PQ`

(2.2-1) this function also does not check whether the group is solvable to use the Kimmerle-result to have an immediate positive solution for (ZC).

This function is interesting if one wants to save time or possesses some information, which was not obtained using this package and was entered manually into `HeLP_sol`

.

`‣ HeLP_ChangeCharKeepSols` ( CT ) | ( function ) |

Returns: nothing

This function changes the used character table to the character table `CT` and keeps all the solutions calculated so far. It is in this case the responsibility of the user that the tables belong to the same group and the ordering of the conjugacy classes in `CT` is consistent with the one in the previously used table. This function can be used to change from one table of the group to another, e.g. from a Brauer table to the ordinary table if the calculations will involve \(p\)-singular elements. (In case the involved character tables come from the ATLAS and their InfoText begins with "origin: ATLAS of finite groups", this is done automatically by the program.) A user may also use characters, which are normally not accessible in GAP.

`‣ HeLP_Reset` ( ) | ( function ) |

Returns: nothing

This function delets all the values calculated so far and resets the global variables `HeLP_CT`

and `HeLP_CT`

to their initial value `[ [ [1] ] ]`

and `CharacterTable(SmallGroup(1,1))`

respectively.

HeLP uses currently three external programs (i.e. programs that are not part of the GAP-system): zsolve from 4ti2 and/or normaliz to solve the systems of linear inequalities and redund from lrslib to simplify the inequlities before handing them over to the solver (HeLP can also be used without lrslib installed. In general it is recommanded to have lrslib installed, if 4ti2 is used as the solver). The following functions can be used to influence the behaviour of these external programms.

`‣ HeLP_Solver` ( [string] ) | ( function ) |

Returns: nothing

This function can be used to change the solver used for the HeLP-system between 4ti2 and normaliz. If the function is called without an argument it prints which solver is currently used. If the argument it is called with is one of the stings "4ti2" or "normaliz", then the solver used for future calculations is changed to the one given as argument in case this solver is found by the HeLP-package. If both solvers are found when the package is loaded normaliz is taken as default.

`‣ HeLP_UseRedund` ( bool ) | ( function ) |

Returns: nothing

This function determines whether HeLP uses 'redund' from the lrslib-package to remove redundant equations from the HeLP system. If `bool` is `true`

'redund' will be used in all calculation that follow, if it is `false`

, 'redund' will not be used (which might take significantly longer). If 'redund' was not found by GAP a warning will be printed and the calculations will be performed without 'redund'. As default 'redund' will be used in all calculations, if 4ti2 is the chosen solver, and 'redund' will not be used, if normaliz is used.

`‣ HeLP_Change4ti2Precision` ( string ) | ( function ) |

Returns: nothing

This function changes the maximum precision of the calculations of 4ti2 to solve the occurring systems of linear inequalities. The possible arguments are `"32"`

, `"64"`

and `"gmp"`

. After calling the function the new precision will be used until this function is used again. The default value is `"32"`

. A higher precision causes slower calculations. But this function might be used to increase the precision of 4ti2, when one gets an error message like "Error, 4ti2 Error: Results were near maximum precision (32bit). Please restart with higher precision!" stating that the results were close to the maximum 4ti2-precision. normaliz does automatically change its precision, when it reaches an overflow.

Sometimes it is desirable to perform calculations without redund (even if it is installed and in many cases improves the performance of the package) or with a higher precision. For example, determining the partial augmentations for units of order \(14\) for `SmallGroup(392, 30)`

involves very long calculations (when called with redund and precision 32) or cause errors (when called without redund and precision 32). However, the following works in a reasonable time.

gap> C := CharacterTable(SmallGroup(392,30)); CharacterTable( <pc group of size 392 with 5 generators> ) gap> HeLP_Solver("4ti2"); '4ti2' will be used from now on. gap> HeLP_UseRedund(false); The calculations will be performed without using 'redund' from now on. gap> HeLP_ZC(C); Error, 4ti2 Error: Results were near maximum precision (32bit). Please restart with higher precision! If you continue, your results might be wrong called from 4ti2Interface_zsolve_equalities_and_inequalities( [ ListWithIdenticalEntries( Size( T[1] ), 1 ) ], [ 1 ], temp[1], - temp[2] ) called from HeLP_TestSystemINTERNAL( W[1], W[2], k, arg[3] ) called from HeLP_WithGivenOrderAndPAINTERNAL( C, k, pa ) called from HeLP_WithGivenOrderINTERNAL( Irr( T ), k ) called from <function "HeLP_ZC">( <arguments> ) called from read-eval loop at line 19 of *stdin* you can 'quit;' to quit to outer loop, or you can 'return;' to continue gap> brk> quit; #I Options stack has been reset gap> HeLP_Change4ti2Precision("64"); The calculations of 4ti2 will be performed with precision 64 from now on. gap> HeLP_ZC(C); true

`‣ HeLP_Vertices` ( string ) | ( function ) |

Returns: nothing

If normlaiz is used as the solver of the HeLP-system this function influences, whether the "VerticesOfPolyhedron" are computed by normaliz. By default these are only computed, if the system has a trivial solution. The function takes "vertices", "novertices" and "default" as arguments. If you do not understand what this means, don't worry.

`‣ HeLP_VerifySolution` ( CharacterTable|ListOfClassFunctions, k[, list_paraugs] ) | ( function ) |

Returns: List of admissible partial augmentations

This function checks which of the partial augmentations for elements of order `k`

given in `HeLP_sol[k]`

or the optional third argument `list_paraugs`

fulfill the HeLP equations obtained from the characters in the first argument. This function does not solve any inequalities, but only checks, if the given partial augmentations fulfill them. It is for this reason often faster then e.g. `HeLP_WithGivenOrder`

(3.1-1).

If there is no third argument given, i.e. the augmentations from `HeLP_sol[k]`

are used, the result overwrites `HeLP_sol[k]`

.

`‣ HeLP_FindAndVerifySolution` ( CharacterTable|ListOfClassFunctions, k ) | ( function ) |

Returns: List of admissible partial augmentations or "infinite"

This function provides the same functionality as `HeLP_WithGivenOrder`

(3.1-1) but instead of constructiong the corresponding system with all characters from the first argument `CharacterTable|ListOfClassFunctions` it does it consecutively with larger sets of characters from the argument until a finite list of solutions is found and then applies `HeLP_VerifySolution`

(3.6-1) to these solutions with the entirety of the class functions in the first argument.

This function is sometimes faster than `HeLP_WithGivenOrder`

(3.1-1), but the output is the same, thus the examples from `HeLP_WithGivenOrder`

(3.1-1) also apply here.

`‣ HeLP_PossiblePartialAugmentationsOfPowers` ( n ) | ( function ) |

Returns: List of partial augmentations of powers.

This function provides the possible partial augmentations of the powers of units of a given order \(n,\) if the partial augmentations if units of order \(n/p\) have been already computed for all primes \(p\) dividing \(n.\) The possibilities are sorted in the same way as, if the order \(n\) is checked with any other function like e.g. `HeLP_WithGivenOrder`

(3.1-1) or `HeLP_ZC`

(2.1-1). Thus, if the InfoLevel is high enough and one obtains that the computation of some possibility is taking too long, one can check it using `HeLP_WithGivenOrderAndPA`

(3.1-2).

`‣ HeLP_WriteTrivialSolution` ( C, k ) | ( function ) |

Returns: Trivial solutions.

Given a character table `C` and an order `k`, the function calculates the partial augmentations of units of order \(k\) that are rationally conjugate to group elements (note that they just coincide with the partial augmentations of group elements) and stores them in `HeLP_sol[k]`

. If solutions of order \(k\) were already calculated, they are overwritten by this function, so this function can be used in particular if elements of order \(k\) are known to be rationally conjugate to group elements by theoretical results.

`‣ HeLP_WagnerTest` ( k[, list_paraugs, OrdinaryCharacterTable] ) | ( function ) |

Returns: List of admissible partial augmentations

This function applies the Wagner test (cf. Section 5.4) to the given data. If only the order `k` is given as argument, the Wagner test will be applied to the solutions stored in `HeLP_sol[k]`

. If the arguments are the order `k`, a list of possible solutions `list_paraugs` and an ordinary character table `OrdinaryCharacterTable` it applies the test to the solutions given in `list_paraugs` and using the number of conjugacy classes for elements a divisor of `k`, which will be extracted from the head of `OrdinaryCharacterTable`.

`‣ HeLP_AutomorphismOrbits` ( C, k[, list_paraug] ) | ( function ) |

Returns: List of admissible partial augmentations

For a list of possible partial augmentations, this function calculates representatives of each orbit of the action of the automorphism group of \(G\) on them. The first two mandatory arguments are an ordinary character table `C` (with an underlying group or ) and the order `k` for which the partial augmentations should be filtered with respect to the action of the automorphism group of \(G\). If as third argument a lisrt of partial augmentations is given, then these will be used, otherwise the partial augmentations that are stored in `HeLP_sol[k]`

are used.

`‣ HeLP_PrintSolution` ( [k] ) | ( function ) |

Returns: nothing

This function prints the possible solutions in a pretty way. If a positive integer `k` as argument is given, then it prints the admissible partial augmentations of units of order `k`, if they are already calculated. If no argument is given, the function prints information on all orders for which there are already informations.

`‣ HeLP_MultiplicitiesOfEigenvalues` ( chi, k, paraugs ) | ( function ) |

Returns: a list of multiplicities of eigenvalues

The returned list contains at the \(l\)-th spot the multiplicity of `E(k)^(l-1)`

as eigenvalue of a unit \(u\) of order `k` under the representation corresponding to `chi` having the partial augmentations `paraugs` for the elements \(u^d\) for divisors \(d\) different from `k`.

`‣ HeLP_CharacterValue` ( chi, k, paraug ) | ( function ) |

Returns: the character value \(chi(u)\)

The function returns the character value \(chi(u)\) of an element \(u\) of order \(k\) having the partial augmentations `paraug`.

`‣ HeLP_IsZCKnown` ( G ) | ( function ) |

Returns: `true`

if (ZC) can be derived from theoretical results, `false`

otherwise

For the given group `G` this function applies five checks, namely it checks

if \(G\) is nilpotent

if \(G\) has a normal Sylow subgroup with abelian complement,

if \(G\) is cyclic-by-abelian

if it is of the form \(X \rtimes A\), where \(X\) and \(A\) are abelian and \(A\) is of prime order \(p\) such that \(p\) is smaller then any prime divisor of the order of \(X\)

or if the order of \(G\) is smaller than \(144\).

In all these cases the Zassenhaus Conjecture is known. See 5.6 for references. This function is designed for solvable groups.

generated by GAPDoc2HTML