This chapter lists the documentation about functions which have been developed for the current package but are of more general interest (see Section 4.1) and functions which are referenced by the package documentation, whose code is available in the main GAP library, but which are currently undocumented (see ReductionToFiniteField (4.2-4)).
Generalized straight line programs (in the following abbreviated as gslps) are a generalization of the straight line programs that are introduced in Section Reference: Straight Line Programs. Like the latter objects, gslps describe an efficient way for evaluating an abstract word at concrete generators. The difference is that gslps can be built from existing (generalized) straight line programs. So the advantages of using gslps are
that available objects are reused,
that the internal structure is retained, and
that intermediate results of an evaluation are not kept longer than until the relevant straight line program inside is evaluated.
A gslp in GAP is represented by an object in the category IsGeneralizedStraightLineProgram (4.1-1). This object has exactly one of the following forms.
It is a straight line program, that is, it lies in the category IsStraightLineProgram (Reference: IsStraightLineProgram), and evaluation at some group elements is defined by ResultOfStraightLineProgram (Reference: ResultOfStraightLineProgram).
It is of "union" kind, that is, the defining data are a nonempty list of gslps, and evaluation at some group elements means to evaluate these defining programs at these group elements, and to return the concatenation of the results.
It is of "compose" kind, that is, the defining data are a nonempty list of gslps, and evaluation at some group elements means to evaluate the first of them at these elements, then to evaluate the second of them at the result of the first evaluations, and so on, and to return the last result.
Gslps can be constructed using GeneralizedStraightLineProgram (4.1-2).
Defining attributes for gslps are NrInputsOfGeneralizedStraightLineProgram (4.1-4) and DataOfGeneralizedStraightLineProgram (4.1-3). The probably most interesting operation for gslps is ResultOfGeneralizedStraightLineProgram (4.1-6).
Special methods applicable to gslps are installed for the operations IsInternallyConsistent (Reference: IsInternallyConsistent), ViewString (Reference: ViewString), and String (Reference: String).
Here are typical situations where gslps arise:
Suppose that a list \(l\) of standard generators for a group \(G\) is given, and that we know a straight line program for computing generators \(l'\) of a maximal subgroup \(M\) of \(G\) from \(l\). For example, these data may be taken from the ATLAS of Group Representations [WWT+]. If \(M\) is also a group for which the ATLAS of Group Representations contains generators and straight line programs, we may be interested in computing standard generators \(l''\) for \(M\) from \(l'\). For that, a second straight line program can be needed, and it makes sense to encode the computation of \(l''\) from \(l\) via a gslp of "compose" kind.
Now suppose that we are in fact interested in a downward extension \(H\) of \(G\), and that \(\pi\) is the natural epimorphism from \(H\) to \(G\), which maps a list \(L\), say, of standard generators of \(H\) to \(l\). Then the above gslp can be applied to \(L\), but the result \(L'\) may generate a proper subgroup of \(\pi^{-1}(M)\) because some part of the kernel of \(\pi\) is missing. A list \(K\) of generators of the kernel of \(\pi\) can be described by a straight line program that takes \(L\) as its input, and it makes sense to encode the computation of the concatenation of \(L'\) and \(K\) from \(L\) via a gslp of "union" kind.
A remark on the name "generalized straight line program": We could have taken the viewpoint that these objects are the ones that one wants to deal with, and that they should therefore be called "straight line program", whereas GAP's straight line programs could be called "special straight line programs", However, several functions are applicable to GAP's straight line programs (such as IntermediateResultOfSLP (Reference: IntermediateResultOfSLP)) for which we do not intend to provide methods applicable to our generalized straight line programs.
‣ IsGeneralizedStraightLineProgram( obj ) | ( category ) |
Each generalized straight line program in GAP lies in the category IsGeneralizedStraightLineProgram. Examples are straight line programs, that is, objects in the category IsStraightLineProgram (Reference: IsStraightLineProgram).
gap> gslp:= GeneralizedStraightLineProgram( "union", > [ [ [[[1,2]]], 1 ], [ [[[1,3]]], 1 ] ] ); <generalized straight line program> gap> IsGeneralizedStraightLineProgram( gslp ); true gap> slp:= StraightLineProgram( [[[1,2]]], 1 ); <straight line program> gap> IsGeneralizedStraightLineProgram( slp ); true gap> IsGeneralizedStraightLineProgram( [ slp, slp ] ); false
‣ GeneralizedStraightLineProgram( lines[, nrgens] ) | ( function ) |
‣ GeneralizedStraightLineProgram( kind, list ) | ( function ) |
In the first form, lines must be a list of lists that defines a unique straight line program (see IsStraightLineProgram (Reference: IsStraightLineProgram)); in this case GeneralizedStraightLineProgram delegates to StraightLineProgram (Reference: StraightLineProgram for a list of lines (and the number of generators)).
In the second form, kind must be one of the strings "union" or "compose", and list must be a nonempty list such that each of its entries is either a gslp or a list \(l\), say, such that CallFuncList (Reference: CallFuncList) applied to GeneralizedStraightLineProgram and l returns a gslp.
gap> GeneralizedStraightLineProgram( [[[1,2]]], 1 ); <straight line program> gap> GeneralizedStraightLineProgram( "union", > [ [ [[[1,2]]], 1 ], [ [[[1,3]]], 1 ] ] ); <generalized straight line program> gap> GeneralizedStraightLineProgram( "compose", > [ [ [[[1,2]]], 1 ], [ [[[1,3]]], 1 ] ] ); <generalized straight line program>
‣ DataOfGeneralizedStraightLineProgram( gslp ) | ( attribute ) |
For a generalized straight line program gslp that is not a straight line program, DataOfGeneralizedStraightLineProgram returns a list of length two, the first entry being either "union" or "compose" and the second being the list of defining generalized straight line programs.
If gslp is a straight line program then this attribute is not set in gslp. There is no default method to compute the value if it is not stored.
gap> gslp:= GeneralizedStraightLineProgram( "union", > [ [ [[[1,2]]], 1 ], [ [[[1,3]]], 1 ] ] ); <generalized straight line program> gap> DataOfGeneralizedStraightLineProgram( gslp ); [ "union", [ <straight line program>, <straight line program> ] ]
‣ NrInputsOfGeneralizedStraightLineProgram( gslp ) | ( attribute ) |
For a generalized straight line program gslp, this function returns the number of generators that are needed as input.
If gslp is a straight line program then it may be necessary that the value is set in the construction of gslp, see NrInputsOfStraightLineProgram (Reference: NrInputsOfStraightLineProgram). If gslp is not a straight line program then the value is determined by the (generalized) straight line programs from which gslp is constructed.
gap> NrInputsOfGeneralizedStraightLineProgram( > GeneralizedStraightLineProgram( "union", > [ [ [[[1,2]]], 1 ], [ [[[1,3]]], 1 ] ] ) ); 1
In order to avoid the introduction of unnecessary filters, we define NrInputsOfGeneralizedStraightLineProgram just as a synonym of NrInputsOfStraightLineProgram (Reference: NrInputsOfStraightLineProgram).
‣ NrOutputsOfGeneralizedStraightLineProgram( gslp ) | ( attribute ) |
For a generalized straight line program gslp, this function returns the number of elements returned by ResultOfGeneralizedStraightLineProgram (4.1-6) when gslp is evaluated.
gap> NrOutputsOfGeneralizedStraightLineProgram( > GeneralizedStraightLineProgram( "union", > [ [ [[[1,2]]], 1 ], [ [[[1,3]]], 1 ] ] ) ); 2 gap> NrOutputsOfGeneralizedStraightLineProgram( > GeneralizedStraightLineProgram( "compose", > [ [ [[[1,2]]], 1 ], [ [[[1,3]]], 1 ] ] ) ); 1
‣ ResultOfGeneralizedStraightLineProgram( gslp, gens ) | ( operation ) |
ResultOfGeneralizedStraightLineProgram evaluates the generalized straight line program (see IsGeneralizedStraightLineProgram (4.1-1)) gslp at the group elements in the list gens, as follows.
If gslp is a straight line program then the value of ResultOfStraightLineProgram (Reference: ResultOfStraightLineProgram) is returned.
If gslp is of "union" kind then ResultOfGeneralizedStraightLineProgram is applied to each of the involved generalized straight line programs, with second argument gens, and the concatenation of the results is returned.
If gslp is of "compose" kind then ResultOfGeneralizedStraightLineProgram is first called with the first involved generalized straight line program and gens, then the operation is called with the second involved generalized straight line program and the result of this call, and so on; the last such result is returned.
gap> gens:= [ (1,2,3,4,5,6) ];; gap> gslp:= GeneralizedStraightLineProgram( "union", > [ [ [[[1,2]]], 1 ], [ [[[1,3]]], 1 ] ] ); <generalized straight line program> gap> ResultOfGeneralizedStraightLineProgram( gslp, gens ); [ (1,3,5)(2,4,6), (1,4)(2,5)(3,6) ] gap> gslp:= GeneralizedStraightLineProgram( "compose", > [ [ [[[1,2]]], 1 ], [ [[[1,3]]], 1 ] ] ); <generalized straight line program> gap> ResultOfGeneralizedStraightLineProgram( gslp, gens ); [ () ]
In order to avoid the introduction of unnecessary operations, we define ResultOfGeneralizedStraightLineProgram just as a synonym of ResultOfStraightLineProgram (Reference: ResultOfStraightLineProgram).
‣ EquivalentStraightLineProgram( gslp ) | ( attribute ) |
For a generalized straight line program gslp, EquivalentStraightLineProgram returns a straight line program such that evaluating gslp and this straight line program with ResultOfGeneralizedStraightLineProgram (4.1-6) yields the same output, for any list of input elements.
gap> gslp:= GeneralizedStraightLineProgram( "union", > [ [ [[[1,2]]], 1 ], [ [[[1,3]]], 1 ] ] ); <generalized straight line program> gap> slp:= EquivalentStraightLineProgram( gslp ); <straight line program> gap> Display( slp ); # input: r:= [ g1 ]; # program: # return values: [ r[1]^2, r[1]^3 ] gap> gslp:= GeneralizedStraightLineProgram( "compose", > [ [ [[[1,2]]], 1 ], [ [[[1,3]]], 1 ] ] ); <generalized straight line program> gap> slp:= EquivalentStraightLineProgram( gslp ); <straight line program> gap> Display( slp ); # input: r:= [ g1 ]; # program: r[2]:= r[1]^2; r[1]:= r[2]; # return values: [ r[1]^3 ]
‣ PRegularTable( tbl, p ) | ( function ) |
‣ ComputedPRegularTables( tbl ) | ( attribute ) |
For an ordinary character table tbl and a prime integer p, PRegularTable returns the same as CharacterTableRegular (Reference: CharacterTableRegular). The only difference is that the results of PRegularTable are cached in tbl, via the attribute ComputedPRegularTables.
The purpose of this attribute is to store \(p\)-regular character tables (see CharacterTableRegular (Reference: CharacterTableRegular) for those primes \(p\) for which the irreducible characters of the \(p\)-modular character table are not available. It may still be possible to provide the irreducibles of certain blocks, and for that, it is necessary to assign these characters to a suitable modular character table.
The cached tables are used for example by IBr (3.3-6).
‣ PrintOverviewOfDefectOneNormalizers( tbl ) | ( function ) |
Let tbl be the ordinary character table of a finite group \(G\), say. For each prime integer \(p\) that divides the order of \(G\) exactly once, PrintOverviewOfDefectOneNormalizers prints one or two lines of information about the normalizers of Sylow \(p\)-subgroups in \(G\).
If such a Sylow \(p\)-normalizer is maximal in \(G\) and if the attribute Maxes (CTblLib: Maxes) is set in tbl then one line is printed for \(p\), saying that the normalizer is maximal, and showing the name of the character table.
Otherwise, if the character table of the Sylow \(p\)-normalizer is known then the availability of the character table and its name are mentioned, and if not then an approximation of the structure is shown. If the attribute Maxes (CTblLib: Maxes) is set in tbl then also the list of maximal subgroups is shown that contain a Sylow \(p\)-normalizer.
gap> PrintOverviewOfDefectOneNormalizers( CharacterTable( "A5" ) ); 3: max. subgroup S3 5: max. subgroup D10 gap> PrintOverviewOfDefectOneNormalizers( CharacterTable( "A6" ) ); 5: char. table available as D10, contained in max. subgroups A5, A6M2 gap> PrintOverviewOfDefectOneNormalizers( CharacterTable( "S10" ) ); 7: structure (7x[6]).6, contained in max. subgroups S7xS3
‣ FrobeniusCharacterValueExt( value, p ) | ( function ) |
The GAP library function FrobeniusCharacterValue (Reference: FrobeniusCharacterValue) works only for those cyclotomics value whose conductor is coprime to p. In order to implement the ring homomorphism from all cyclotomics whose coefficients are coprime to p, we use the fact that this ring homomorphism is defined via the Conway polynomials on the \(m\)-th roots of unity, for \(m\) coprime to p, and is defined by mapping all p^\(k\)-th roots of unity to the identity element of the finite field.
This means that for \(q =\) p\(^k\) and \(n = m q\), with \(m\) coprime to p, the image of \(\zeta_n^i\) is equal to the image of \(\zeta_m^j\), where \(i \equiv j q \bmod m\) holds.
gap> FrobeniusCharacterValue( E(4), 2 ); fail gap> FrobeniusCharacterValueExt( E(4), 2 ); Z(2)^0
‣ ReductionToFiniteField( value, p ) | ( function ) |
Let value be a cyclotomic whose coefficients over the rationals are in the ring \(ℤ_{\textit{p}}\) of p-local numbers, where p is a prime integer.
ReductionToFiniteField returns either fail or a pair \([ f, m ]\), where \(f\) is a polynomial over the field with p elements and \(m\) is a positive integer.
In the latter case, the meaning is as follows. Let \(F\) be the finite field with \(\textit{p}^m\) elements, given as a set of residue classes modulo the ideal \(I\) that is spanned by the Conway polynomial (see ConwayPolynomial (Reference: ConwayPolynomial)) of degree \(m\) in characteristic \(p\). The coset \(f + I\) represents the image of value under the ring homomorphism \(*\) defined in Section 3.2, and \(F\) is the minimal field that contains this image.
fail is returned if the conductor of value is divisible by p, if the denominator of some coefficient of value is divisible by p. or if the Conway polynomial of the degree in question is not known and would be hard to compute, in the sense of IsCheapConwayPolynomial (Reference: IsCheapConwayPolynomial).
gap> ReductionToFiniteField( E(5), 2 ); [ x_1^3, 4 ] gap> ReductionToFiniteField( Sqrt(5), 2 ); [ Z(2)^0, 1 ] gap> ReductionToFiniteField( E(7), 2 ); [ x_1, 3 ] gap> ReductionToFiniteField( Sqrt(-7), 2 ); [ Z(2)^0, 1 ] gap> ReductionToFiniteField( Sqrt(7), 2 ); # conductor is 28 fail
‣ InfoBlocks | ( info class ) |
Currently only the info levels \(0\), \(1\), and \(2\) are supported. If the level is \(1\) then info messages about fail results are printed. If the level is \(2\) then additionally info messages about the progress of computations are printed. The default info level of InfoBlocks is zero.
generated by GAPDoc2HTML