Algorithmische Zahlentheorie und Algebra. Since then, maintenance of ANU NQ has been taken over by Max Horn. All credit for creating ANU NQ still goes to Werner Nickel as sole author. However, bug reports and other inquiries should be sent to Max Horn. The following are the original acknowledgements by Werner Nickel. Over the years a number of people have made useful suggestions that found their way into the code: Mike Newman, Michael Vaughan-Lee, Joachim Neubüser, Charles Sims. Thanks to Volkmar Felsch and Joachim Neubüser for their careful examination of the package prior to its release for GAP 4. This documentation was prepared with the
[EN02] Eick, B. and Nickel, W.,
Polycyclic,
Algorithms for working with polycyclic groups
(2002)
(GAP package),
https://gap-packages.github.io/polycyclic/.
[GMP] GNU MP, https://gmplib.org/.
[Hig59] Higman, G., Some remarks on varieties of groups, Quart. J. Math. Oxford, 2 (10) (1959), 165–178.
[LGS90] Leedham-Green, C. R. and Soicher, L. H., Collection from the left and other strategies, J. Symbolic Comput., 9 (5–6) (1990), 665–675.
[Nic96] Nickel, W., Computing Nilpotent Quotients of Finitely Presented Groups, in Geometric and Computational Perspectives on Infinite Groups, Dimacs Series in Discrete Mathematics and Theoretical Computer Science, 25 (1996), 175–191.
[NN94] Newman, M. F. and Nickel, W., Engel elements in groups, J. Pure Appl. Algebra, 96 (1994), 39–45.
[Sim94] Sims, C. C., Computation with Finitely Presented Groups, Cambridge University Press (1994).
[VL90] Vaughan-Lee, M. R., Collection from the Left, J. Symbolic Comput., Academic Press, 9 (1990), 725–733.
generated by GAPDoc2HTML
nq-2.5.11/doc/_entities.xml 000644 000766 000024 00000000045 14550113056 015756 0 ustar 00mhorn staff 000000 000000 nq'> nq-2.5.11/doc/chap0_mj.html 000644 000766 000024 00000026452 14550113063 015630 0 ustar 00mhorn staff 000000 0000002.5.11
12 January 2024
Werner Nickel
Homepage: http://www.mathematik.tu-darmstadt.de/~nickel/
© 1992-2007 Werner Nickel
The nq package is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
The author of ANU NQ is Werner Nickel.
The development of this program was started while the author was supported by an Australian National University PhD scholarship and an Overseas Postgraduate Research Scholarship.
Further development of this program was done with support from the DFG-Schwerpunkt-Projekt "Algorithmische Zahlentheorie und Algebra".
Since then, maintenance of ANU NQ has been taken over by Max Horn. All credit for creating ANU NQ still goes to Werner Nickel as sole author. However, bug reports and other inquiries should be sent to Max Horn.
The following are the original acknowledgements by Werner Nickel.
Over the years a number of people have made useful suggestions that found their way into the code: Mike Newman, Michael Vaughan-Lee, Joachim Neubüser, Charles Sims.
Thanks to Volkmar Felsch and Joachim Neubüser for their careful examination of the package prior to its release for GAP 4.
This documentation was prepared with the GAPDoc package by Frank Lübeck and Max Neunhöffer.
generated by GAPDoc2HTML
nq-2.5.11/doc/chap2.html 000644 000766 000024 00000073252 14550113063 015144 0 ustar 00mhorn staff 000000 000000In this chapter we define notation used throughout this manual and recollect basic facts about nilpotent groups. We also provide some background information about the functionality implemented in this package.
The commutator of two elements h_1 and h_2 of a group G is the element h_1^-1h_2^-1h_1h_2 and is denoted by [h_1,h_2]. It satisfies the equation h_1h_2 = h_2h_1[h_1,h_2] and can be interpreted as the correction term that has to be introduced into a word if two elements of a group are interchanged. Iterated commutators are written in left-normed fashion: [h_1,h_2,...,h_n-1,h_n]=[[h_1,h_2,...,h_n-1],h_n].
The lower central series of G is defined inductively as γ_1(G) = G, γ_i(G) = [γ_i-1(G),G] for i ≥ 2. Each term in the lower central series is a normal (even fully invariant) subgroup of G. The factors of the lower central series are abelian groups. On each factor the induced action of G via conjugation is the trivial action.
The factor γ_k(G)/γ_k+1(G) is generated by the elements [g,h]γ_k+1(G), where g runs through a set of (representatives of) generators for G/γ_2(G) and h runs through a set of (representatives of) generators for γ_k-1(G)/γ_k(G). Therefore, each factor of the lower central series is finitely generated if G is finitely generated.
If one factor of the lower central series is finite, then all subsequent factors are finite. Then the exponent of the k+1-th factor is a divisor of the exponent of the k-th factor of the lower central series. In particular, the exponents of all factors of the lower central series are bounded by the exponent of the first finite factor of the lower central series.
A group G is called nilpotent if there is a positive integer c such that all (c+1)-fold commutators are trivial in G. The smallest integer with this property is called the nilpotency class of G. In terms of the lower central series a group G not= 1 has nilpotency class c if and only if γ_c(G) not= 1 and γ_c+1(G) = 1.
Examples of nilpotent groups are finite p-groups, the group of unitriangular matrices over a ring with one and the factor groups of a free group modulo the terms of its lower central series.
Finiteness of a nilpotent group can be decided by the group's commutator factor group. A nilpotent group is finite if and only if its commutator factor group is finite. A group whose commutator factor group is finite can only have finite nilpotent quotient groups.
By refining the lower central series of a finitely generated nilpotent group one can obtain a (sub)normal series G_1>G_2>...>G_k+1=1 with cyclic (central) factors. Therefore, every finitely generated nilpotent group is polycyclic. Such a polycyclic series gives rise to a polycyclic generating sequence by choosing a generator a_i for each cyclic factor G_i/G_i+1. Let I be the set of indices such that G_i/G_i+1 is finite. A simple induction argument shows that every element of the group can be written uniquely as a normal word a_1^e_1... a_n^e_n with integers e_i and 0≤ e_i<m_i for i∈ I.
From a polycyclic generating sequence one can obtain a polycyclic presentation for the group. The following set of power and commutator relations is a defining set of relations. The power relations express a_i^m_i in terms of the generators a_i+1,...,a_n whenever G_i/G_i+1 is finite with order m_i. The commutator relations are obtained by expressing [a_j,a_i] for j>i as a word in the generators a_i+1,...,a_n. If the polycyclic series is obtained from refining the lower central series, then [a_j,a_i] is even a word in a_j+1,...,a_n. In this case we obtain a nilpotent presentation.
To be more precise, a nilpotent presentation is given on a finite number of generators a_1,...,a_n. Let I be the set of indices such that G_i/G_i+1 is finite. Let m_i be the order of G_i/G_i+1 for i∈ I. Then a nilpotent presentation has the form
\langle a,\ldots,a_n | a_i^{m_i} = w_{ii}(a_{i+1},\ldots,a_n) \mbox{ for } i\in I;\; [a_j,a_i] = w_{ij}(a_{j+1},\ldots,a_n) \mbox{ for } 1\leq i < j\leq n\rangle
Here, w_ij(a_k,...,a_n) denotes a group word in the generators a_k,...,a_n.
In a group given by a polycyclic presentation each element in the group can be written as a normal word a_1^e_1... a_n^e_n with e_i ∈ Z and 0 ≤ e_i < m_i for i ∈ I. A procedure called collection can be used to convert an arbitrary word in the generators into an equivalent normal word. In general, the resulting normal word need not be unique. The result of collecting a word may depend on the steps chosen during the collection procedure. A polycyclic presentation with the property that two different normal words are never equivalent is called consistent. A polycyclic presentation derived from a polycyclic series as above is consistent. The following example shows an inconsistent polycyclic presentation
\langle a,b\mid a^2, b^a = b^2 \rangle
as b = baa = ab^2a = a^2b^4 = b^4 which implies b^3=1. Here we have the equivalent normal words b^3 and the empty word. It can be proved that consistency can be checked by collecting a finite number of words in the given generating set in two essentially different ways and checking if the resulting normal forms are the same in both cases. See Chapter 9 of the book [Sim94] for an introduction to polycyclic groups and polycyclic presentations.
For computations in a polycyclic group one chooses a consistent polycyclic presentation as it offers a simple solution to the word problem: Equality between two words is decided by collecting both words to their respective normal forms and comparing the normal forms. Nilpotent groups and nilpotent presentations are special cases of polycyclic groups and polycyclic presentations. Nilpotent presentations allow specially efficient collection methods. The package Polycyclic provides algorithms to compute with polycyclic groups given by a polycyclic presentation.
However, inconsistent nilpotent presentations arise naturally in the nilpotent quotient algorithm. There is an algorithm based on the test words for consistency mentioned above to modify the arising inconsistent presentations suitably to obtain a consistent one for the same group.
The input for the ANU NQ in its simplest form is a finite presentation ⟨ X|R⟩ for a group G. The first step of the algorithm determines a nilpotent presentation for the commutator quotient of G. This is a presentation of the class-1 quotient of G. Call its generators a_1,...,a_d. It also determines a homomorphism of G onto the commutator quotient and describes it by specifying the image of each generator in X as a word in the a_i.
For the general step assume that the algorithm has computed a nilpotent presentation for the class-c quotient of G and that a_1,...,a_d are the generators introduced in the first step of the algorithm. Furthermore, there is a map from X into the class-c quotient describing the epimorphism from G onto G/γ_c+1(G).
Let b_1,...b_k be the generators from the last step of the algorithm, the computation of γ_c(G)/γ_c+1(G). This means that b_1,...b_k generate γ_c(G)/γ_c+1(G). Then the commutators [b_j,a_i] generate γ_c+1(G)/γ_c+2(G). The algorithm introduces new, central generators c_ij into the presentation, adds the relations [b_j,a_i] = c_ij and modifies the existing relations by appending suitable words in the c_ij, called tails, to the right hand sides of the power and commutator relations. The resulting presentation is a nilpotent presentation for the nilpotent cover of G/γ_c+1(G). The nilpotent cover is the largest central extension of G/γ_c+1(G) generated by d elements. It is is uniquely determined up to isomorphism.
The resulting presentation of the nilpotent cover is in general inconsistent. Consistency is achieved by running the consistency test. This results in relations among the generators c_ij which can be used to eliminate some of those generators or introduce power relations. After this has been done we have a consistent nilpotent presentation for the nilpotent cover of G/γ_c+1(G).
Furthermore, the nilpotent cover need not satisfy the relations of G. In other words, the epimorphism from G onto G/γ_c+1(G) cannot be lifted to an epimorphism onto the nilpotent cover. Applying the epimorphism to each relator of G and collecting the resulting words of the nilpotent cover yields a set of words in the c_ij. This gives further relations between the c_ij which leads to further eliminations or modifications of the power relations for the c_ij.
After this, the inductive step of the ANU NQ is complete and a consistent nilpotent presentation for G/γ_c+2(G) is obtained together with an epimorphism from G onto the class-(c+1) quotient.
Chapter 11 of the book [Sim94] discusses a nilpotent quotient algorithm. A description of the implementation in the ANU NQ is contained in [Nic96]
Let w be a word in free generators x_1,...,x_n. A group G satisfies the relation w=1 identically if each map from x_1,...,x_n into G maps w to the identity element of G. We also say that G satisfies the identical relation w=1 or satisfies the law w=1. In slight abuse of notation, we call the elements x_1,...,x_n identical generators.
Common examples of identical relations are: A group of nilpotency class at most c satisfies the law [x_1,...,x_c+1]=1. A group that satisfies the law [x,y,...,y]=1 where y occurs n-times, is called an n-Engel group. A group that satisfies the law x^d=1 is a group of exponent d.
To describe finitely presented groups that satisfy one or more laws, we extend a common notation for finitely presented groups by specifying the identical generators as part of the generator list, separated from the group generators by a semicolon: For example
\langle a,b,c; x,y | x^5, [x,y,y,y]\rangle
is a group on 3 generators a,b,c of exponent 5 satisfying the 3rd Engel law. The presentation above is equivalent to a presentation on 3 generators with an infinite set of relators, where the set of relators consists of all fifth powers of words in the generators and all commutators [x,y,y,y] where x and y run through all words in the generators a,b,c. The standalone programme accepts the notation introduced above as a description of its input. In GAP 4 finitely presented groups are specified in a different way, see NilpotentQuotient (3.1-1) for a description.
This notation can also be used in words that mix group and identical generators as in the following example:
\langle a,b,c; x | [x,c], [a,x,x,x] \rangle
The first relator specifies a law which says that c commutes with all elements of the group. The second turns a into a third right Engel element.
An element a is called a right n-th Engel element or a right n-Engel element if it satisfies the commutator law [a,x,...,x]=1 where the identical generator x occurs n-times. Likewise, an element b is called an left n-th Engel element or left n-Engel element if it satisfies the commutator law [x,b,b,...b]=1.
Let G be a nilpotent group. Then G satisfies a given law if the law is satisfied by a certain finite set of instances given by Higman's Lemma, see [Hig59]. The ANU NQ uses Higman's Lemma to obtain a finite presentation for groups that satisfy one or several identical relations.
Expressions involving commutators play an important role in the context of nilpotent groups. Expanding an iterated commutator produces a complicated and long expression. For example,
[x,y,z] = y^{-1}x^{-1}yxz^{-1}x^{-1}y^{-1}xyz.
Evaluating a commutator [a,b] is done efficiently by computing the equation (ba)^-1ab. Therefore, for each commutator we need to perform two multiplications and one inversion. Evaluating [x,y,z] needs four multiplications and two inversions. Evaluation of an iterated commutator with n components takes 2n-1 multiplications and n-1 inversions. The expression on the right hand side above needs 9 multiplications and 5 inversions which is clearly much more expensive than evaluating the commutator directly.
Assuming that no cancellations occur, expanding an iterated commutator with n components produces a word with 2^n+1-2^n-1-2 factors half of which are inverses. A similar effect occurs whenever a compact expression is expanded into a word in generators and inverses, for example (ab)^49.
Therefore, it is important not to expand expressions into a word in generators and inverses. For this purpose we provide a mechanism which we call here expression trees. An expression tree preserves the structure of a given expression. It is a (binary) tree in which each node is assigned an operation and whose leaves are generators of a free group or integers. For example, the expression [(xy)^2, z] is stored as a tree whose top node is a commutator node. The right subtree is just a generator node (corresponding to z). The left subtree is a power node whose subtrees are a product node on the left and an integer node on the right. An expression tree can involve products, powers, conjugates and commutators. However, the list of available operations can be extended.
Evaluation of an expression tree is done recursively and requires as many operations as there are nodes in the tree. An expression tree can be evaluated in a specific group by the function EvaluateExpTree (3.2-2).
A presentation specified by expression trees is a record with the components .generators and .relations. See section 3.2 for a description of the functions that produce and manipulate expression trees.
gap> LoadPackage( "nq" ); true gap> gens := ExpressionTrees( 2 ); [ x1, x2 ] gap> r1 := LeftNormedComm( [gens[1],gens[2],gens[2]] ); Comm( x1, x2, x2 ) gap> r2 := LeftNormedComm( [gens[1],gens[2],gens[2],gens[1]] ); Comm( x1, x2, x2, x1 ) gap> pres := rec( generators := gens, relations := [r1,r2] ); rec( generators := [ x1, x2 ], relations := [ Comm( x1, x2, x2 ), Comm( x1, x2, x2, x1 ) ] )
The ANU NQ is written in C, but not in ANSI C. I hope to make one of the next versions ANSI compliable. However, it uses a fairly restricted subset of the language so that it should be easy to compile it in new environments. The code is 64-bit clean. If you have difficulties with porting it to a new environment, let me know and I'll be happy to assist if time permits.
The program has two collectors: a simple collector from the left as described in [LGS90] and a combinatorial from the left collector as described in [VL90]. The combinatorial collector is always faster than the simple collector, therefore, it is the collector used by this package by default. This can be changed by modifying the global variable NqDefaultOptions (3.4-2).
In a polycyclic group with generators that do not have power relations, exponents may become arbitrarily large. Experience shows that this happens rarely in the computations done by the ANU NQ. Exponents are represented by 32-bit integers. The collectors perform an overflow check and abort the computation if an overflow occurred. In a GNU environment the program can be compiled using the `long long' 64-bit integer type. For this uncomment the relevant line in src/Makefile and recompile the program.
As part of the step that enforces consistency and the relations of the group, the ANU NQ performs computations with integer matrices and converts them to Hermite Normal Form. The algorithm used here is a variation of the Kanan-Bachem algorithm based on the GNU multiple precision package GNU MP [GMP]. Experience shows that the integer matrices are usually fairly sparse and Kanan-Bachem seems to be sufficient in this context. However, the implementation might benefit from a more efficient strategy for computing Hermite Normal Forms. This is a topic for further investigations.
As the program does not compute the Smith Normal Form for each factor of the lower central series but the Hermite Normal Form, it does not necessarily obtain a minimal generating set for each factor of the lower central series. The following is a simple example of this behaviour. We take the presentation
\langle x, y | x^2 = y \rangle
The group is clearly isomorphic to the additive group of the integers. Applying the ANU NQ to this presentation gives the following nilpotent presentation:
\langle A,B | A^2 = B, [B,A] \rangle
A nilpotent presentation on a minimal generating set would be the presentation of the free group on one generator:
\langle A | \; \rangle
The input format for finite presentations resembles the way many people write down a presentation on paper. Here are some examples of presentations that the ANU NQ accepts:
< a, b | > # free group of rank 2
< a, b, c; x, y |
[a,b,c], # a left normed commutator
[b,c,c,c]^6, # another one raised to a power
a^2 = c^-3*a^2*c^3, # a relation
a^(b*c) = a, # a conjugate relation
(a*[b,(a*c)])^6, # something that looks complicated
[x,y,y,y,y], # an identical relation
[c,x,x,x,x,x] # c is a fifth right Engel element
>
A presentation starts with '<' followed by a list of generators separated by commas. Generator names are strings that contain only upper and lower case letters, digits, dots and underscores and that do not start with a digit. The list of generator names is separated from the list of relators/relations by the symbol '∣'. The list of generators can be followed by a list of identical generators separated by a semicolon. Relators and relations are separated by commas and can be mixed arbitrarily. Parentheses can be used in order to group subexpressions together. Square brackets can be used in order to form left normed commutators. The symbols '*' and '^' can be used to form products and powers, respectively. The presentation finishes with the symbol '>'. A comment starts with the symbol '#' and finishes at the end of the line. The file src/presentation.c contains a complete grammar for the presentations accepted by the ANU NQ.
Typically, the input for the standalone is put into a file by using a standard text editor. The file can be passed as an argument to the function NilpotentQuotient (3.1-1). It is also possible to put a presentation in the standalone's input format into a string and use the string as argument for NilpotentQuotient (3.1-1).
generated by GAPDoc2HTML
nq-2.5.11/doc/install.xml 000644 000766 000024 00000007230 14550113041 015436 0 ustar 00mhorn staff 000000 000000directory than the standardpkg
directory in your &GAP; 4 installation, then you have to do two things. Firstly during compilation you have to use the optionpkg
PATHis a path to the main &GAP; root directory (if not given the default
is assumed). That is, run../..
directory to &GAP;'s list of directories. This can be done by starting &GAP; with thepkg
command line option followed by the name of the directory and a semicolon. Then your directory is prepended to the list of directories searched. Otherwise the package is not found by &GAP;. Of course, you can add this option to your &GAP; startup script. Another issue that can occur when running-l
PATHis the path where GMP was installed:
‣ NilpotentQuotient( [output-file, ]fp-group[, id-gens][, c] ) | ( function ) |
‣ NilpotentQuotient( [output-file, ]input-file[, c] ) | ( function ) |
The parameter fp-group is either a finitely presented group or a record specifying a presentation by expression trees (see section 2.6). The parameter input-file is a string specifying the name of a file containing a finite presentation in the input format (cf. section 2.8) of the ANU NQ. Such a file can be prepared by a text editor or with the help of the function NqStringFpGroup (3.3-2).
Let G be the group defined by fp-group or the group defined in input-file. The function computes a nilpotent presentation for G/γ_c+1(G) if the optional parameter c is specified. If c is not given, then the function attempts to compute the largest nilpotent quotient of G and it will terminate only if G has a largest nilpotent quotient. See section 3.5 for a possibility to follow the progress of the computation.
The optional argument id-gens is a list of generators of the free group underlying the finitely presented group fp-group. The generators in this list are treated as identical generators. Consequently, all relations of the fp-group involving these generators are treated as identical relations for these generators.
In addition to the arguments explained above, the function accepts the following options as shown in the first example below:
group This option can be used instead of the parameter fp-group.
input\_string This option can be used to specify a finitely presented group by a string in the input format of the standalone program.
input\_file This option specifies a file with input for the standalone program.
output\_file This option specifies a file for the output of the standalone.
idgens This options specifies a list of identical generators.
class This option specifies the nilpotency class up to which the nilpotent quotient will be computed.
The following example computes the class-5 quotient of the free group on two generators.
gap> F := FreeGroup( 2 ); <free group on the generators [ f1, f2 ]> gap> ## Equivalent to: NilpotentQuotient( : group := F, class := 5 ); gap> ## NilpotentQuotient( F : class := 5 ); gap> H := NilpotentQuotient( F, 5 ); Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] gap> lcs := LowerCentralSeries( H );; gap> for i in [1..5] do Print( lcs[i] / lcs[i+1], "\n" ); od; Pcp-group with orders [ 0, 0 ] Pcp-group with orders [ 0 ] Pcp-group with orders [ 0, 0 ] Pcp-group with orders [ 0, 0, 0 ] Pcp-group with orders [ 0, 0, 0, 0, 0, 0 ]
Note that the lower central series in the example is part of the data returned by the standalone program. Therefore, the execution of the function LowerCentralSeries takes no time.
The next example computes the class-4 quotient of the infinite dihedral group. The group is soluble but not nilpotent. The first factor of its lower central series is a Klein four group and all the other factors are cyclic or order 2.
gap> F := FreeGroup( 2 ); <free group on the generators [ f1, f2 ]> gap> G := F / [F.1^2, F.2^2]; <fp group on the generators [ f1, f2 ]> gap> H := NilpotentQuotient( G, 4 ); Pcp-group with orders [ 2, 2, 2, 2, 2 ] gap> lcs := LowerCentralSeries( H );; gap> for i in [1..Length(lcs)-1] do > Print( AbelianInvariants(lcs[i] / lcs[i+1]), "\n" ); > od; [ 2, 2 ] [ 2 ] [ 2 ] [ 2 ] gap>
In the following example identical generators are used in order to express the fact that the group is nilpotent of class 3. A group is nilpotent of class 3 if it satisfies the identical relation [x_1,x_2,x_3,x_4]=1 (cf. Section 2.5). The result is the free nilpotent group of class 3 on two generators.
gap> F := FreeGroup( "a", "b", "w", "x", "y", "z" ); <free group on the generators [ a, b, w, x, y, z ]> gap> G := F / [ LeftNormedComm( [F.3,F.4,F.5,F.6] ) ]; <fp group of size infinity on the generators [ a, b, w, x, y, z ]> gap> ## The following is equivalent to: gap> ## NilpotentQuotient( G : idgens := [F.3,F.4,F.5,F.6] ); gap> H := NilpotentQuotient( G, [F.3,F.4,F.5,F.6] ); Pcp-group with orders [ 0, 0, 0, 0, 0 ] gap> NilpotencyClassOfGroup(H); 3 gap> LowerCentralSeries(H); [ Pcp-group with orders [ 0, 0, 0, 0, 0 ], Pcp-group with orders [ 0, 0, 0 ], Pcp-group with orders [ 0, 0 ], Pcp-group with orders [ ] ]
The following example uses expression trees in order to specify the third Engel law for the free group on 3 generators.
gap> et := ExpressionTrees( 5 ); [ x1, x2, x3, x4, x5 ] gap> comm := LeftNormedComm( [et[1], et[2], et[2], et[2]] ); Comm( x1, x2, x2, x2 ) gap> G := rec( generators := et, relations := [comm] ); rec( generators := [ x1, x2, x3, x4, x5 ], relations := [ Comm( x1, x2, x2, x2 ) ] ) gap> H := NilpotentQuotient( G : idgens := [et[1],et[2]] ); Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 2, 2, 0, 6, 6, 0, 0, 2, 10, 10, 10 ] gap> TorsionSubgroup( H ); Pcp-group with orders [ 2, 2, 2, 2, 2, 2, 2, 10, 10, 10 ] gap> lcs := LowerCentralSeries( H );; gap> NilpotencyClassOfGroup( H ); 5 gap> for i in [1..5] do Print( lcs[i] / lcs[i+1], "\n" ); od; Pcp-group with orders [ 0, 0, 0 ] Pcp-group with orders [ 0, 0, 0 ] Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0 ] Pcp-group with orders [ 2, 4, 2, 2, 0, 6, 6, 0, 0, 2 ] Pcp-group with orders [ 10, 10, 10 ] gap> for i in [1..5] do Print( AbelianInvariants(lcs[i]/lcs[i+1]), "\n" ); od; [ 0, 0, 0 ] [ 0, 0, 0 ] [ 0, 0, 0, 0, 0, 0, 0, 0 ] [ 2, 2, 2, 2, 2, 2, 2, 0, 0, 0 ] [ 10, 10, 10 ]
The example above also shows that the relative orders of an abelian polycyclic group need not be the abelian invariants (elementary divisors) of the group. Each zero corresponds to a generator of infinite order. The number of zeroes is always correct.
‣ NilpotentEngelQuotient( [output-file, ]fp-group, n[, id-gens][, c] ) | ( function ) |
‣ NilpotentEngelQuotient( [output-file, ]input-file, n[, c] ) | ( function ) |
This function is a special version of NilpotentQuotient (3.1-1) which enforces the n-th Engel identity on the nilpotent quotients of the group specified by fp-group or by input-file. It accepts the same options as NilpotentQuotient.
The Engel condition can also be enforced by using identical generators and the Engel law and NilpotentQuotient (3.1-1). See the examples there.
The following example computes the relatively free fifth Engel group on two generators, determines its (normal) torsion subgroup and computes the corresponding quotient group. The quotient modulo the torsion subgroup is torsion-free. Therefore, there is a nilpotent presentation without power relations. The example computes a nilpotent presentation for the torsion free factor group through the upper central series. The factors of the upper central series in a torsion free group are torsion free. In this way one obtains a set of generators of infinite order and the resulting nilpotent presentation has no power relations.
gap> G := NilpotentEngelQuotient( FreeGroup(2), 5 ); Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 10, 0, 0, 30, 0, 3, 3, 10, 2, 0, 6, 0, 0, 30, 2, 0, 9, 3, 5, 2, 6, 2, 10, 5, 5, 2, 0, 3, 3, 3, 3, 3, 5, 5, 3, 3 ] gap> NilpotencyClassOfGroup(G); 9 gap> T := TorsionSubgroup( G ); Pcp-group with orders [ 3, 3, 2, 2, 3, 3, 2, 9, 3, 5, 2, 3, 2, 10, 5, 2, 3, 3, 3, 3, 3, 5, 5, 3, 3 ] gap> IsAbelian( T ); true gap> AbelianInvariants( T ); [ 3, 3, 3, 3, 3, 3, 3, 3, 30, 30, 30, 180, 180 ] gap> H := G / T; Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 10, 0, 0, 30, 0, 5, 0, 2, 0, 0, 10, 0, 2, 5, 0 ] gap> H := PcpGroupBySeries( UpperCentralSeries(H), "snf" ); Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] gap> ucs := UpperCentralSeries( H );; gap> for i in [1..NilpotencyClassOfGroup(H)] do > Print( ucs[i]/ucs[i+1], "\n" ); > od; Pcp-group with orders [ 0, 0 ] Pcp-group with orders [ 0 ] Pcp-group with orders [ 0, 0 ] Pcp-group with orders [ 0, 0, 0 ] Pcp-group with orders [ 0, 0, 0, 0, 0, 0 ] Pcp-group with orders [ 0, 0, 0, 0 ] Pcp-group with orders [ 0, 0 ] Pcp-group with orders [ 0, 0, 0 ]
‣ NqEpimorphismNilpotentQuotient( [output-file, ]fp-group[, id-gens][, c] ) | ( function ) |
This function computes an epimorphism from the group G given by the finite presentation fp-group onto G/γ_c+1(G). If c is not given, then the largest nilpotent quotient of G is computed and an epimorphism from G onto the largest nilpotent quotient of G. If G does not have a largest nilpotent quotient, the function will not terminate if c is not given.
The optional argument id-gens is a list of generators of the free group underlying the finitely presented group fp-group. The generators in this list are treated as identical generators. Consequently, all relations of the fp-group involving these generators are treated as identical relations for these generators.
If identical generators are specified, then the epimorphism returned maps the group generated by the `non-identical' generators onto the nilpotent factor group. See the last example below.
The function understands the same options as the function NilpotentQuotient (3.1-1).
gap> F := FreeGroup(3); <free group on the generators [ f1, f2, f3 ]> gap> phi := NqEpimorphismNilpotentQuotient( F, 5 ); [ f1, f2, f3 ] -> [ g1, g2, g3 ] gap> Image( phi, LeftNormedComm( [F.3, F.2, F.1] ) ); g12 gap> F := FreeGroup( "a", "b" ); <free group on the generators [ a, b ]> gap> G := F / [ F.1^2, F.2^2 ]; <fp group on the generators [ a, b ]> gap> phi := NqEpimorphismNilpotentQuotient( G, 4 ); [ a, b ] -> [ g1, g2 ] gap> Image( phi, Comm(G.1,G.2) ); g3*g4 gap> F := FreeGroup( "a", "b", "u", "v", "x" ); <free group on the generators [ a, b, u, v, x ]> gap> a := F.1;; b := F.2;; u := F.3;; v := F.4;; x := F.5;; gap> G := F / [ x^5, LeftNormedComm( [u,v,v,v] ) ]; <fp group of size infinity on the generators [ a, b, u, v, x ]> gap> phi := NqEpimorphismNilpotentQuotient( G : idgens:=[u,v,x], class:=5 ); [ a, b ] -> [ g1, g2 ] gap> U := Source(phi); Group([ a, b ]) gap> ImageElm( phi, LeftNormedComm( [U.1*U.2, U.2^-1,U.2^-1,U.2^-1,] ) ); id
Note that the last epimorphism is a map from the group generated by a and b onto the nilpotent quotient. The identical generators are used only to formulate the identical relator. They are not generators of the group G. Also note that the left-normed commutator above is mapped to the identity as G satisfies the specified identical law.
‣ LowerCentralFactors( ... ) | ( function ) |
This function accepts the same arguments and options as NilpotentQuotient (3.1-1) and returns a list containing the abelian invariants of the central factors in the lower central series of the specified group.
gap> LowerCentralFactors( FreeGroup(2), 6 ); [ [ 0, 0 ], [ 0 ], [ 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ]
‣ ExpressionTrees( m[, prefix] ) | ( function ) |
‣ ExpressionTrees( str1, str2, str3, ... ) | ( function ) |
The argument m must be a positive integer. The function returns a list with m expression tree symbols named x1, x2,... The optional parameter prefix must be a string and is used instead of x if present.
Alternatively, the function can be executed with a list of strings str1, str2, .... It returns a list of symbols with these strings as names.
The following operations are defined for expression trees: multiplication, inversion, exponentiation, forming commutators, forming conjugates.
gap> t := ExpressionTrees( 3 ); [ x1, x2, x3 ] gap> tree := Comm( t[1], t[2] )^3/LeftNormedComm( [t[1],t[2],t[3],t[1]] ); Comm( x1, x2 )^3/Comm( x1, x2, x3, x1 ) gap> t := ExpressionTrees( "a", "b", "x" ); [ a, b, x ] gap> tree := Comm( t[1], t[2] )^3/LeftNormedComm( [t[1],t[2],t[3],t[1]] ); Comm( a, b )^3/Comm( a, b, x, a )
‣ EvaluateExpTree( tree, symbols, values ) | ( function ) |
The argument tree is an expression tree followed by the list of those symbols symbols from which the expression tree is built up. The argument values is a list containing a constant for each symbol. The function substitutes each value for the corresponding symbol and computes the resulting value for tree.
gap> F := FreeGroup( 3 ); <free group on the generators [ f1, f2, f3 ]> gap> t := ExpressionTrees( "a", "b", "x" ); [ a, b, x ] gap> tree := Comm( t[1], t[2] )^3/LeftNormedComm( [t[1],t[2],t[3],t[1]] ); Comm( a, b )^3/Comm( a, b, x, a ) gap> EvaluateExpTree( tree, t, GeneratorsOfGroup(F) ); f1^-1*f2^-1*f1*f2*f1^-1*f2^-1*f1*f2*f1^-1*f2^-1*f1*f2*f1^-1*f3^-1*f2^-1*f1^ -1*f2*f1*f3*f1^-1*f2^-1*f1*f2*f1*f2^-1*f1^-1*f2*f1*f3^-1*f1^-1*f2^-1*f1*f2*f3
‣ NqReadOutput( stream ) | ( function ) |
The only argument stream is an output stream of the ANU NQ. The function reads the stream and returns a record that has a component for each global variable used in the output of the ANU NQ, see NqGlobalVariables (3.4-3).
‣ NqStringFpGroup( fp-group[, idgens] ) | ( function ) |
The function takes a finitely presented group fp-group and returns a string in the input format of the ANU NQ. If the list idgens is present, then it must contain generators of the free group underlying the finitely presented group FreeGroupOfFpGroup (Reference: FreeGroupOfFpGroup). The generators in idgens are treated as identical generators.
gap> F := FreeGroup(2); <free group on the generators [ f1, f2 ]> gap> G := F / [F.1^2, F.2^2, (F.1*F.2)^4]; <fp group on the generators [ f1, f2 ]> gap> NqStringFpGroup( G ); "< x1, x2 |\n x1^2,\n x2^2,\n x1*x2*x1*x2*x1*x2*x1*x2\n>\n" gap> Print( last ); < x1, x2 | x1^2, x2^2, x1*x2*x1*x2*x1*x2*x1*x2 > gap> PrintTo( "dihedral", last ); gap> ## The following is equivalent to: gap> ## NilpotentQuotient( : input_file := "dihedral" ); gap> NilpotentQuotient( "dihedral" ); Pcp-group with orders [ 2, 2, 2 ] gap> Exec( "rm dihedral" ); gap> F := FreeGroup(3); <free group on the generators [ f1, f2, f3 ]> gap> H := F / [ LeftNormedComm( [F.2,F.1,F.1] ), > LeftNormedComm( [F.2,F.1,F.2] ), F.3^7 ]; <fp group on the generators [ f1, f2, f3 ]> gap> str := NqStringFpGroup( H, [F.3] ); "< x1, x2; x3 |\n x1^-1*x2^-1*x1*x2*x1^-1*x2^-1*x1^-1*x2*x1^2,\n x1^-1*x\ 2^-1*x1*x2^-1*x1^-1*x2*x1*x2,\n x3^7\n>\n" gap> NilpotentQuotient( : input_string := str ); Pcp-group with orders [ 7, 7, 7 ]
‣ NqStringExpTrees( fp-group[, idgens] ) | ( function ) |
The function takes a finitely presented group fp-group given in terms of expression trees and returns a string in the input format of the ANU NQ. If the list idgens is present, then it must contain a sublist of the generators of the presentation. The generators in idgens are treated as identical generators.
gap> x := ExpressionTrees( 2 ); [ x1, x2 ] gap> rels := [x[1]^2, x[2]^2, (x[1]*x[2])^5]; [ x1^2, x2^2, (x1*x2)^5 ] gap> NqStringExpTrees( rec( generators := x, relations := rels ) ); "< x1, x2 |\n x1^2,\n x2^2,\n (x1*x2)^5\n>\n" gap> Print( last ); < x1, x2 | x1^2, x2^2, (x1*x2)^5 > gap> x := ExpressionTrees( 3 ); [ x1, x2, x3 ] gap> rels := [LeftNormedComm( [x[2],x[1],x[1]] ), > LeftNormedComm( [x[2],x[1],x[2]] ), x[3]^7 ]; [ Comm( x2, x1, x1 ), Comm( x2, x1, x2 ), x3^7 ] gap> NqStringExpTrees( rec( generators := x, relations := rels ) ); "< x1, x2, x3 |\n [ x2, x1, x1 ],\n [ x2, x1, x2 ],\n x3^7\n>\n" gap> Print( last ); < x1, x2, x3 | [ x2, x1, x1 ], [ x2, x1, x2 ], x3^7 >
‣ NqElementaryDivisors( int-mat ) | ( function ) |
The function ElementaryDivisorsMat (Reference: ElementaryDivisorsMat) only returns the non-zero elementary divisors of an integer matrix. This function computes the elementary divisors of int-mat and adds the appropriate number of zeroes in order to make it easier to recognize the isomorphism type of the abelian group presented by the integer matrix. At the same time ones are stripped from the list of elementary divisors.
‣ NqRuntime | ( global variable ) |
This variable contains the number of milliseconds of runtime of the last call of ANU NQ.
gap> NilpotentEngelQuotient( FreeGroup(2), 5 ); Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 10, 0, 0, 30, 0, 3, 3, 10, 2, 0, 6, 0, 0, 30, 2, 0, 9, 3, 5, 2, 6, 2, 10, 5, 5, 2, 0, 3, 3, 3, 3, 3, 5, 5, 3, 3 ] gap> NqRuntime; 18200
‣ NqDefaultOptions | ( global variable ) |
This variable contains a list of strings which are the standard command line options passed to the ANU NQ in each call. Modifying this variable can be used to pass additional options to the ANU NQ.
gap> NqDefaultOptions; [ "-g", "-p", "-C", "-s" ]
The option -g causes the ANU NQ to produce output in GAP-format. The option -p prevents the ANU NQ from listing the pc-presentation of the nilpotent quotient at the end of the calculation. The option -C invokes the combinatorial collector. The option -s is effective only in conjunction with options for computing with Engel identities and instructs the ANU NQ to use only semigroup words in the generators as instances of an Engel law.
‣ NqGlobalVariables | ( global variable ) |
This variable contains a list of strings with the names of the global variables that are used in the output stream of the ANU NQ. While the output stream is read, these global variables are assigned new values. To avoid overwriting these variables in case they contain values, their contents is saved before reading the output stream and restored afterwards.
While the standalone program is running it can be asked to display progress information. This is done by setting the info class InfoNQ to 1 via the function SetInfoLevel (Reference: InfoLevel).
gap> NilpotentQuotient(FreeGroup(2),5); Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] gap> SetInfoLevel( InfoNQ, 1 ); gap> NilpotentQuotient(FreeGroup(2),5); #I Class 1: 2 generators with relative orders 0 0 #I Class 2: 1 generators with relative orders: 0 #I Class 3: 2 generators with relative orders: 0 0 #I Class 4: 3 generators with relative orders: 0 0 0 #I Class 5: 6 generators with relative orders: 0 0 0 0 0 0 Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] gap> SetInfoLevel( InfoNQ, 0 );
generated by GAPDoc2HTML
nq-2.5.11/doc/chap1_mj.html 000644 000766 000024 00000011104 14550113063 015615 0 ustar 00mhorn staff 000000 000000This package provides an interface between GAP 4 and the Australian National University Nilpotent Quotient Program (ANU NQ). The ANU NQ was implemented as part of the author's work towards his PhD at the Australian National University, hence the name of the program. The program takes as input a finite presentation of a group and successively computes factor groups modulo the terms of the lower central series of the group. These factor groups are computed in terms of polycyclic presentations.
The ANU NQ is implemented in the programming language C. The implementation has been developed in a Unix environment and Unix is currently the only operating system supported. It runs on a number of different Unix versions, e.g. Solaris and Linux.
For integer matrix computations it relies on the GNU MP [GMP] package and requires this package to be installed on your system.
This package relies on the functionality for polycyclic groups provided by the GAP package polycyclic [EN02] and requires the package polycyclic to be installed as a GAP package on your computer system.
Comments, bug reports and suggestions are very welcome, please submit them via our issue tracker.
This manual contains references to parts of the GAP Reference Manual which are typeset in a slightly idiosyncratic way. The following example shows how such references are printed: 'For further information on creating a free group see FreeGroup (Reference: FreeGroup).' The text in bold face refers to the GAP Reference Manual.
Each item in the list of references at the end of this manual is followed by a list of numbers that specify the pages of the manual where the reference occurs.
generated by GAPDoc2HTML
nq-2.5.11/doc/title.xml 000644 000766 000024 00000004303 14550113056 015115 0 ustar 00mhorn staff 000000 000000Algorithmische Zahlentheorie und Algebra. Since then, maintenance of ANU NQ has been taken over by Max Horn. All credit for creating ANU NQ still goes to Werner Nickel as sole author. However, bug reports and other inquiries should be sent to Max Horn. The following are the original acknowledgements by Werner Nickel. Over the years a number of people have made useful suggestions that found their way into the code: Mike Newman, Michael Vaughan-Lee, Joachim Neubüser, Charles Sims. Thanks to Volkmar Felsch and Joachim Neubüser for their careful examination of the package prior to its release for GAP 4. This documentation was prepared with the
If you start the ANU NQ by typing
nq -X
you will get the following message:
unknown option: -X
usage: nq [-a] [-M] [-d] [-g] [-v] [-s] [-f] [-c] [-m]
[-t <n>] [-l <n>] [-r <n>] [-n <n>] [-e <n>]
[-y] [-o] [-p] [-E] [<presentation>] [<class>]
All parameters in square brackets are optional. The parameter <presentation> has to be the name of a file that contains a finite group presentation for which a nilpotent quotient is to be calculated. This file name must not start with a digit. If it is not present, nq will read the presentation from standard input. The parameter <class> restricts the computation of the nilpotent quotient to at most that (nilpotency) class, i.e. the program calculates the quotient group of the \((c+1)\)-th term of the lower central series. If <class> is omitted, the program computes successively the factor groups of the lower central series of the given group. If there is a largest nilpotent quotient, i.e., if the lower central series becomes constant, the program will eventually terminate with the largest nilpotent quotient. If there is no largest nilpotent quotient, the program will run forever (or more precisely will run out of resources). On termination the program prints a nilpotent presentation for the nilpotent quotient it has computed. The options -l, -r and -e can be used to enforce Engel conditions on the nilpotent quotient to be calculated. All these options have to be followed by a positive integer <n>. Their meaning is the following:
This option forces the first k generators to be left or right Engel element if also the option -l or -r (or both) is present. Otherwise it is ignored.
This forces the first k generators \(g_1,...,g_k\) of the nilpotent quotient Q to be left n-Engel elements, i.e., they satisfy \([x,...,x,g_i] = 1\) (x occurring n-times) for all x in Q and \(1 <= i <= k\). If the option -n is not used, then k = 1.
This forces the first k generators \(g_1,...,g_k\) of the nilpotent quotient Q to be right n-Engel elements,i.e., they satisfy \([g_i,x,..,x] = 1\) (x occurring n-times) for all x in Q and \(1 <= i <= k\). If the option -n is not used, then k = 1.
This enforces the n-th Engel law on Q, i.e., \([x,y,..,y] = 1\) (y occurring n-times) for all x,y in Q.
This option specifies how much CPU time the program is allowed to use. It will terminate after <n> seconds of CPU time. If <n> is followed (without space) by one of the letters m, h or d, <n> specifies the time in minutes, hours or days, respectively.
The other options have the following meaning. Care has to be taken when the options -s or -c are used since the resulting nilpotent quotient need NOT satisfy the required Engel condition. The reason for this is that a smaller set of test words is used if one of these two options are present. Although this smaller set of test words seems to be sufficient to enforce the required Engel condition, this fact has not been proven.
For each factor of the lower central series a file is created in the current directory that contains an integer matrix describing the factor as abelian group. The first number in that file is the number of columns of the matrix. Then the matrix follows in row major order. The matrix for the i-th factor is put into the file <presentation>.abinv.<i>.
toggles printing of the pc presentation for the nilpotent quotient at the end of a calculation.
This option causes the program to check only semigroup words in the generating set of the nilpotent quotient when an Engel condition is enforced. If none of the options -l, -r or -e are present, it is ignored.
This option causes to check semiwords in the generating set of the nilpotent quotient first and then all other words that need to be checked. It is ignored if the option -s is used or none of the options -l, -r or -e are present.
This option stops checking the Engel law at each class if all the checks of a certain weight did not yield any non-trivial instances of the law.
Switch on debug mode and perform checks during the computation. Not yet implemented.
In checking Engel identities, instances are process in the order of increased weight. This flag reverses the order.
Enforce the identities \(x^8\) and \([ [x1,x2,x3], [x4,x5,x6] ]\) on the nilpotent quotient.
Switch on verbose mode.
Produce GAP output. Presently the GAP output consists only of a sequence of integer matrices whose rows are relations of the factors of the lower central series as abelian groups. This will change as soon as GAP can handle infinite polycyclic groups.
the *last* n generators are Engel generators. This works in conjunction with option -n.
output the relation matrix for each factor of the lower central series. The matrices are written to files with the names 'matrix.<cl>' where <cl> is replaced by the number of the factor in the lower central series. Each file contains first the number of columns of the matrix and then the rows of the matrix. The matrix is written as each relation is produced and is not in upper triangular form.
output the relation matrix before and after relations have been enforced. This results in two groups of files with names '<pres>.nilp.<cl>' and '<pres>.mult.<cl>' where <pres> is the name of the input files and <cl> is the class. The matrices are in upper triangular form.
The input format for finite presentations resembles the way many people write down a presentation on paper. Here are some examples of presentations that the ANU NQ accepts:
< a, b | > # free group of rank 2
< a, b, c | [a,b,c], # a left normed commutator
[b,c,c,c]^6, # another one raised to a power
a^2 = c^-3*a^2*c^3, # a relation
a^(b*c) = a, # a conjugate relation
(a*[b,(a*c)])^6 # something that looks complicated
>
A presentation starts with '<' followed be a list of generators separated by commas. Generator names are strings that contain only upper and lower case letters, digits, dots and underscores and that do not start with a digit. The list of generator names is separated from the list of relators/relations by the symbol '|'. Relators and relations are separated by commas and can be mixed arbitrarily. Parentheses can be used in order to group subexpressions together. Square brackets can be used in order to form left normed commutators. The symbols '*' and '^' can be used to form products and powers, respectively. The presentation finishes with the symbol '>'. A comment starts with the symbol '#' and finishes at the end of the line. The file src/presentation.c contains a complete grammar for the presentations accepted by the ANU NQ.
Let G be the free group on two generators x and y. The input file (called free2.fp here) contains the following:
< x, y | >
Computing the class 3 quotient with the ANU NQ by typing
nq free2.fp 3
produces the following output:
#
# The ANU Nilpotent Quotient Program (Version 2.3)
# Calculating a nilpotent quotient
# Input: free2.fp
# Nilpotency class: 3
# Program: nq
# Size of exponents: 8 bytes
#
# Calculating the abelian quotient ...
# The abelian quotient has 2 generators
# with the following exponents: 0 0
#
# Calculating the class 2 quotient ...
## Sizes: 2 3
# Layer 2 of the lower central series has 1 generators
# with the following exponents: 0
#
# Calculating the class 3 quotient ...
## Sizes: 2 3 5
# Layer 3 of the lower central series has 2 generators
# with the following exponents: 0 0
#
# The epimorphism :
# x |---> A
# y |---> B
# The nilpotent quotient :
<A,B,C,D,E
|
B^A =: B*C,
B^(A^-1) = B*C^-1*D,
C^A =: C*D,
C^(A^-1) = C*D^-1,
C^B =: C*E,
C^(B^-1) = C*E^-1 >
# Class : 3
# Nr of generators of each class : 2 1 2
# The definitions:
# C := [ B, A ]
# D := [ B, A, A ]
# E := [ B, A, B ]
# total runtime : 1 msec
## Total time spent on integer matrices: 0
Most of the comments are fairly self-explanatory. One note of caution is necessary: The number of generators for each factor of the lower central series is not the minimal number possible but is the number of generators that the ANU NQ chose to use. This will be improved in one of the future version of the program. The epimorphism from the original group onto the nilpotent quotient is printed in a somewhat confusing way. The generators on the left hand side of the arrows correspond to the generators in the original presentation but are printed with different names. This will be fixed in one of the next version.
The implementation of the algorithm is fairly straight forward. The program uses a weighted nilpotent presentation with definitions to represent a nilpotent group. Calculations in the nilpotent group are done using a collector from the left without combinatorial collection. Generators for the \(c\)-th lower central factor are defined as commutators of the form \([y,x]\), where \(x\) is a generator of weight 1 and \(y\) is a generator of weight \(c-1\). Then the program calculates the necessary changes (tails) for all relations which are not definitions, runs through the consistency check and evaluates the original relations on the polycyclic presentation. This gives a list of words, which have to be made trivial in order to obtain a consistent polycyclic presentation representing a nilpotent quotient of the given finitely presented group. This list is converted into a integer matrix, which is transformed into upper triangular form using the Kannan-Bachem algorithm. The GNU multiple precision package is used for this.
generated by GAPDoc2HTML
nq-2.5.11/doc/manual.js 000644 000766 000024 00000010113 14550113063 015057 0 ustar 00mhorn staff 000000 000000 /* manual.js Frank Lübeck */ /* This file contains a few javascript functions which allow to switch between display styles for GAPDoc HTML manuals. If javascript is switched off in a browser or this file in not available in a manual directory, this is no problem. Users just cannot switch between several styles and don't see the corresponding button. A style with name mystyle can be added by providing two files (or only one of them). mystyle.js: Additional javascript code for the style, it is read in the HTML pages after this current file. The additional code may adjust the preprocessing function jscontent() with is called onload of a file. This is done by appending functions to jscontentfuncs (jscontentfuncs.push(newfunc);). Make sure, that your style is still usable without javascript. mystyle.css: CSS configuration, read after manual.css (so it can just reconfigure a few details, or overwrite everything). Then adjust chooser.html such that users can switch on and off mystyle. A user can change the preferred style permanently by using the [Style] link and choosing one. Or one can append '?GAPDocStyle=mystyle' to the URL when loading any file of the manual (so the style can be configured in the GAP user preferences). */ /* generic helper function */ function deleteCookie(nam) { document.cookie = nam+"=;Path=/;expires=Thu, 01 Jan 1970 00:00:00 GMT"; } /* read a value from a "nam1=val1;nam2=val2;..." string (e.g., the search part of an URL or a cookie */ function valueString(str,nam) { var cs = str.split(";"); for (var i=0; i < cs.length; i++) { var pos = cs[i].search(nam+"="); if (pos > -1) { pos = cs[i].indexOf("="); return cs[i].slice(pos+1); } } return 0; } /* when a non-default style is chosen via URL or a cookie, then the cookie is reset and the styles .js and .css files are read */ function overwriteStyle() { /* style in URL? */ var style = valueString(window.location.search, "GAPDocStyle"); /* otherwise check cookie */ if (style == 0) style = valueString(document.cookie, "GAPDocStyle"); if (style == 0) return; if (style == "default") deleteCookie("GAPDocStyle"); else { /* ok, we set the cookie for path "/" */ var path = "/"; /* or better like this ??? var here = window.location.pathname.split("/"); for (var i=0; i+3 < here.length; i++) path = path+"/"+here[i]; */ document.cookie = "GAPDocStyle="+style+";Path="+path; /* split into names of style files */ var stlist = style.split(","); /* read style's css and js files */ for (var i=0; i < stlist.length; i++) { document.writeln(''); document.writeln(''); } } } /* this adds a "[Style]" link next to the MathJax switcher */ function addStyleLink() { var line = document.getElementById("mathjaxlink"); var el = document.createElement("a"); var oncl = document.createAttribute("href"); var back = window.location.protocol+"//" if (window.location.protocol == "http:" || window.location.protocol == "https:") { back = back+window.location.host; if (window.location.port != "") { back = back+":"+window.location.port; } } back = back+window.location.pathname; oncl.nodeValue = "chooser.html?BACK="+back; el.setAttributeNode(oncl); var cont = document.createTextNode(" [Style]"); el.appendChild(cont); line.appendChild(el); } var jscontentfuncs = new Array(); jscontentfuncs.push(addStyleLink); /* the default jscontent() only adds the [Style] link to the page */ function jscontent () { for (var i=0; i < jscontentfuncs.length; i++) jscontentfuncs[i](); } nq-2.5.11/doc/chapInd.html 000644 000766 000024 00000013403 14550113063 015505 0 ustar 00mhorn staff 000000 000000EvaluateExpTree 3.2-2 ExpressionTrees 3.2-1 LowerCentralFactors 3.1-4 NilpotentEngelQuotient 3.1-2 NilpotentQuotient 3.1-1 NqDefaultOptions 3.4-2 NqElementaryDivisors 3.3-4 NqEpimorphismNilpotentQuotient 3.1-3 NqGlobalVariables 3.4-3 NqReadOutput 3.3-1 NqRuntime 3.4-1 NqStringExpTrees 3.3-3 NqStringFpGroup 3.3-2
generated by GAPDoc2HTML
nq-2.5.11/doc/chap3_mj.html 000644 000766 000024 00000115326 14550113063 015632 0 ustar 00mhorn staff 000000 000000‣ NilpotentQuotient( [output-file, ]fp-group[, id-gens][, c] ) | ( function ) |
‣ NilpotentQuotient( [output-file, ]input-file[, c] ) | ( function ) |
The parameter fp-group is either a finitely presented group or a record specifying a presentation by expression trees (see section 2.6). The parameter input-file is a string specifying the name of a file containing a finite presentation in the input format (cf. section 2.8) of the ANU NQ. Such a file can be prepared by a text editor or with the help of the function NqStringFpGroup (3.3-2).
Let \(G\) be the group defined by fp-group or the group defined in input-file. The function computes a nilpotent presentation for \(G/\gamma_{c+1}(G)\) if the optional parameter c is specified. If c is not given, then the function attempts to compute the largest nilpotent quotient of \(G\) and it will terminate only if \(G\) has a largest nilpotent quotient. See section 3.5 for a possibility to follow the progress of the computation.
The optional argument id-gens is a list of generators of the free group underlying the finitely presented group fp-group. The generators in this list are treated as identical generators. Consequently, all relations of the fp-group involving these generators are treated as identical relations for these generators.
In addition to the arguments explained above, the function accepts the following options as shown in the first example below:
group This option can be used instead of the parameter fp-group.
input\_string This option can be used to specify a finitely presented group by a string in the input format of the standalone program.
input\_file This option specifies a file with input for the standalone program.
output\_file This option specifies a file for the output of the standalone.
idgens This options specifies a list of identical generators.
class This option specifies the nilpotency class up to which the nilpotent quotient will be computed.
The following example computes the class-5 quotient of the free group on two generators.
gap> F := FreeGroup( 2 ); <free group on the generators [ f1, f2 ]> gap> ## Equivalent to: NilpotentQuotient( : group := F, class := 5 ); gap> ## NilpotentQuotient( F : class := 5 ); gap> H := NilpotentQuotient( F, 5 ); Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] gap> lcs := LowerCentralSeries( H );; gap> for i in [1..5] do Print( lcs[i] / lcs[i+1], "\n" ); od; Pcp-group with orders [ 0, 0 ] Pcp-group with orders [ 0 ] Pcp-group with orders [ 0, 0 ] Pcp-group with orders [ 0, 0, 0 ] Pcp-group with orders [ 0, 0, 0, 0, 0, 0 ]
Note that the lower central series in the example is part of the data returned by the standalone program. Therefore, the execution of the function LowerCentralSeries takes no time.
The next example computes the class-4 quotient of the infinite dihedral group. The group is soluble but not nilpotent. The first factor of its lower central series is a Klein four group and all the other factors are cyclic or order \(2\).
gap> F := FreeGroup( 2 ); <free group on the generators [ f1, f2 ]> gap> G := F / [F.1^2, F.2^2]; <fp group on the generators [ f1, f2 ]> gap> H := NilpotentQuotient( G, 4 ); Pcp-group with orders [ 2, 2, 2, 2, 2 ] gap> lcs := LowerCentralSeries( H );; gap> for i in [1..Length(lcs)-1] do > Print( AbelianInvariants(lcs[i] / lcs[i+1]), "\n" ); > od; [ 2, 2 ] [ 2 ] [ 2 ] [ 2 ] gap>
In the following example identical generators are used in order to express the fact that the group is nilpotent of class \(3\). A group is nilpotent of class \(3\) if it satisfies the identical relation \([x_1,x_2,x_3,x_4]=1\) (cf. Section 2.5). The result is the free nilpotent group of class \(3\) on two generators.
gap> F := FreeGroup( "a", "b", "w", "x", "y", "z" ); <free group on the generators [ a, b, w, x, y, z ]> gap> G := F / [ LeftNormedComm( [F.3,F.4,F.5,F.6] ) ]; <fp group of size infinity on the generators [ a, b, w, x, y, z ]> gap> ## The following is equivalent to: gap> ## NilpotentQuotient( G : idgens := [F.3,F.4,F.5,F.6] ); gap> H := NilpotentQuotient( G, [F.3,F.4,F.5,F.6] ); Pcp-group with orders [ 0, 0, 0, 0, 0 ] gap> NilpotencyClassOfGroup(H); 3 gap> LowerCentralSeries(H); [ Pcp-group with orders [ 0, 0, 0, 0, 0 ], Pcp-group with orders [ 0, 0, 0 ], Pcp-group with orders [ 0, 0 ], Pcp-group with orders [ ] ]
The following example uses expression trees in order to specify the third Engel law for the free group on \(3\) generators.
gap> et := ExpressionTrees( 5 ); [ x1, x2, x3, x4, x5 ] gap> comm := LeftNormedComm( [et[1], et[2], et[2], et[2]] ); Comm( x1, x2, x2, x2 ) gap> G := rec( generators := et, relations := [comm] ); rec( generators := [ x1, x2, x3, x4, x5 ], relations := [ Comm( x1, x2, x2, x2 ) ] ) gap> H := NilpotentQuotient( G : idgens := [et[1],et[2]] ); Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 2, 2, 0, 6, 6, 0, 0, 2, 10, 10, 10 ] gap> TorsionSubgroup( H ); Pcp-group with orders [ 2, 2, 2, 2, 2, 2, 2, 10, 10, 10 ] gap> lcs := LowerCentralSeries( H );; gap> NilpotencyClassOfGroup( H ); 5 gap> for i in [1..5] do Print( lcs[i] / lcs[i+1], "\n" ); od; Pcp-group with orders [ 0, 0, 0 ] Pcp-group with orders [ 0, 0, 0 ] Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0 ] Pcp-group with orders [ 2, 4, 2, 2, 0, 6, 6, 0, 0, 2 ] Pcp-group with orders [ 10, 10, 10 ] gap> for i in [1..5] do Print( AbelianInvariants(lcs[i]/lcs[i+1]), "\n" ); od; [ 0, 0, 0 ] [ 0, 0, 0 ] [ 0, 0, 0, 0, 0, 0, 0, 0 ] [ 2, 2, 2, 2, 2, 2, 2, 0, 0, 0 ] [ 10, 10, 10 ]
The example above also shows that the relative orders of an abelian polycyclic group need not be the abelian invariants (elementary divisors) of the group. Each zero corresponds to a generator of infinite order. The number of zeroes is always correct.
‣ NilpotentEngelQuotient( [output-file, ]fp-group, n[, id-gens][, c] ) | ( function ) |
‣ NilpotentEngelQuotient( [output-file, ]input-file, n[, c] ) | ( function ) |
This function is a special version of NilpotentQuotient (3.1-1) which enforces the \(n\)-th Engel identity on the nilpotent quotients of the group specified by fp-group or by input-file. It accepts the same options as NilpotentQuotient.
The Engel condition can also be enforced by using identical generators and the Engel law and NilpotentQuotient (3.1-1). See the examples there.
The following example computes the relatively free fifth Engel group on two generators, determines its (normal) torsion subgroup and computes the corresponding quotient group. The quotient modulo the torsion subgroup is torsion-free. Therefore, there is a nilpotent presentation without power relations. The example computes a nilpotent presentation for the torsion free factor group through the upper central series. The factors of the upper central series in a torsion free group are torsion free. In this way one obtains a set of generators of infinite order and the resulting nilpotent presentation has no power relations.
gap> G := NilpotentEngelQuotient( FreeGroup(2), 5 ); Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 10, 0, 0, 30, 0, 3, 3, 10, 2, 0, 6, 0, 0, 30, 2, 0, 9, 3, 5, 2, 6, 2, 10, 5, 5, 2, 0, 3, 3, 3, 3, 3, 5, 5, 3, 3 ] gap> NilpotencyClassOfGroup(G); 9 gap> T := TorsionSubgroup( G ); Pcp-group with orders [ 3, 3, 2, 2, 3, 3, 2, 9, 3, 5, 2, 3, 2, 10, 5, 2, 3, 3, 3, 3, 3, 5, 5, 3, 3 ] gap> IsAbelian( T ); true gap> AbelianInvariants( T ); [ 3, 3, 3, 3, 3, 3, 3, 3, 30, 30, 30, 180, 180 ] gap> H := G / T; Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 10, 0, 0, 30, 0, 5, 0, 2, 0, 0, 10, 0, 2, 5, 0 ] gap> H := PcpGroupBySeries( UpperCentralSeries(H), "snf" ); Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] gap> ucs := UpperCentralSeries( H );; gap> for i in [1..NilpotencyClassOfGroup(H)] do > Print( ucs[i]/ucs[i+1], "\n" ); > od; Pcp-group with orders [ 0, 0 ] Pcp-group with orders [ 0 ] Pcp-group with orders [ 0, 0 ] Pcp-group with orders [ 0, 0, 0 ] Pcp-group with orders [ 0, 0, 0, 0, 0, 0 ] Pcp-group with orders [ 0, 0, 0, 0 ] Pcp-group with orders [ 0, 0 ] Pcp-group with orders [ 0, 0, 0 ]
‣ NqEpimorphismNilpotentQuotient( [output-file, ]fp-group[, id-gens][, c] ) | ( function ) |
This function computes an epimorphism from the group \(G\) given by the finite presentation fp-group onto \(G/\gamma_{c+1}(G).\) If c is not given, then the largest nilpotent quotient of \(G\) is computed and an epimorphism from \(G\) onto the largest nilpotent quotient of \(G\). If \(G\) does not have a largest nilpotent quotient, the function will not terminate if \(c\) is not given.
The optional argument id-gens is a list of generators of the free group underlying the finitely presented group fp-group. The generators in this list are treated as identical generators. Consequently, all relations of the fp-group involving these generators are treated as identical relations for these generators.
If identical generators are specified, then the epimorphism returned maps the group generated by the `non-identical' generators onto the nilpotent factor group. See the last example below.
The function understands the same options as the function NilpotentQuotient (3.1-1).
gap> F := FreeGroup(3); <free group on the generators [ f1, f2, f3 ]> gap> phi := NqEpimorphismNilpotentQuotient( F, 5 ); [ f1, f2, f3 ] -> [ g1, g2, g3 ] gap> Image( phi, LeftNormedComm( [F.3, F.2, F.1] ) ); g12 gap> F := FreeGroup( "a", "b" ); <free group on the generators [ a, b ]> gap> G := F / [ F.1^2, F.2^2 ]; <fp group on the generators [ a, b ]> gap> phi := NqEpimorphismNilpotentQuotient( G, 4 ); [ a, b ] -> [ g1, g2 ] gap> Image( phi, Comm(G.1,G.2) ); g3*g4 gap> F := FreeGroup( "a", "b", "u", "v", "x" ); <free group on the generators [ a, b, u, v, x ]> gap> a := F.1;; b := F.2;; u := F.3;; v := F.4;; x := F.5;; gap> G := F / [ x^5, LeftNormedComm( [u,v,v,v] ) ]; <fp group of size infinity on the generators [ a, b, u, v, x ]> gap> phi := NqEpimorphismNilpotentQuotient( G : idgens:=[u,v,x], class:=5 ); [ a, b ] -> [ g1, g2 ] gap> U := Source(phi); Group([ a, b ]) gap> ImageElm( phi, LeftNormedComm( [U.1*U.2, U.2^-1,U.2^-1,U.2^-1,] ) ); id
Note that the last epimorphism is a map from the group generated by \(a\) and \(b\) onto the nilpotent quotient. The identical generators are used only to formulate the identical relator. They are not generators of the group \(G\). Also note that the left-normed commutator above is mapped to the identity as \(G\) satisfies the specified identical law.
‣ LowerCentralFactors( ... ) | ( function ) |
This function accepts the same arguments and options as NilpotentQuotient (3.1-1) and returns a list containing the abelian invariants of the central factors in the lower central series of the specified group.
gap> LowerCentralFactors( FreeGroup(2), 6 ); [ [ 0, 0 ], [ 0 ], [ 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ]
‣ ExpressionTrees( m[, prefix] ) | ( function ) |
‣ ExpressionTrees( str1, str2, str3, ... ) | ( function ) |
The argument m must be a positive integer. The function returns a list with m expression tree symbols named x1, x2,... The optional parameter prefix must be a string and is used instead of x if present.
Alternatively, the function can be executed with a list of strings str1, str2, .... It returns a list of symbols with these strings as names.
The following operations are defined for expression trees: multiplication, inversion, exponentiation, forming commutators, forming conjugates.
gap> t := ExpressionTrees( 3 ); [ x1, x2, x3 ] gap> tree := Comm( t[1], t[2] )^3/LeftNormedComm( [t[1],t[2],t[3],t[1]] ); Comm( x1, x2 )^3/Comm( x1, x2, x3, x1 ) gap> t := ExpressionTrees( "a", "b", "x" ); [ a, b, x ] gap> tree := Comm( t[1], t[2] )^3/LeftNormedComm( [t[1],t[2],t[3],t[1]] ); Comm( a, b )^3/Comm( a, b, x, a )
‣ EvaluateExpTree( tree, symbols, values ) | ( function ) |
The argument tree is an expression tree followed by the list of those symbols symbols from which the expression tree is built up. The argument values is a list containing a constant for each symbol. The function substitutes each value for the corresponding symbol and computes the resulting value for tree.
gap> F := FreeGroup( 3 ); <free group on the generators [ f1, f2, f3 ]> gap> t := ExpressionTrees( "a", "b", "x" ); [ a, b, x ] gap> tree := Comm( t[1], t[2] )^3/LeftNormedComm( [t[1],t[2],t[3],t[1]] ); Comm( a, b )^3/Comm( a, b, x, a ) gap> EvaluateExpTree( tree, t, GeneratorsOfGroup(F) ); f1^-1*f2^-1*f1*f2*f1^-1*f2^-1*f1*f2*f1^-1*f2^-1*f1*f2*f1^-1*f3^-1*f2^-1*f1^ -1*f2*f1*f3*f1^-1*f2^-1*f1*f2*f1*f2^-1*f1^-1*f2*f1*f3^-1*f1^-1*f2^-1*f1*f2*f3
‣ NqReadOutput( stream ) | ( function ) |
The only argument stream is an output stream of the ANU NQ. The function reads the stream and returns a record that has a component for each global variable used in the output of the ANU NQ, see NqGlobalVariables (3.4-3).
‣ NqStringFpGroup( fp-group[, idgens] ) | ( function ) |
The function takes a finitely presented group fp-group and returns a string in the input format of the ANU NQ. If the list idgens is present, then it must contain generators of the free group underlying the finitely presented group FreeGroupOfFpGroup (Reference: FreeGroupOfFpGroup). The generators in idgens are treated as identical generators.
gap> F := FreeGroup(2); <free group on the generators [ f1, f2 ]> gap> G := F / [F.1^2, F.2^2, (F.1*F.2)^4]; <fp group on the generators [ f1, f2 ]> gap> NqStringFpGroup( G ); "< x1, x2 |\n x1^2,\n x2^2,\n x1*x2*x1*x2*x1*x2*x1*x2\n>\n" gap> Print( last ); < x1, x2 | x1^2, x2^2, x1*x2*x1*x2*x1*x2*x1*x2 > gap> PrintTo( "dihedral", last ); gap> ## The following is equivalent to: gap> ## NilpotentQuotient( : input_file := "dihedral" ); gap> NilpotentQuotient( "dihedral" ); Pcp-group with orders [ 2, 2, 2 ] gap> Exec( "rm dihedral" ); gap> F := FreeGroup(3); <free group on the generators [ f1, f2, f3 ]> gap> H := F / [ LeftNormedComm( [F.2,F.1,F.1] ), > LeftNormedComm( [F.2,F.1,F.2] ), F.3^7 ]; <fp group on the generators [ f1, f2, f3 ]> gap> str := NqStringFpGroup( H, [F.3] ); "< x1, x2; x3 |\n x1^-1*x2^-1*x1*x2*x1^-1*x2^-1*x1^-1*x2*x1^2,\n x1^-1*x\ 2^-1*x1*x2^-1*x1^-1*x2*x1*x2,\n x3^7\n>\n" gap> NilpotentQuotient( : input_string := str ); Pcp-group with orders [ 7, 7, 7 ]
‣ NqStringExpTrees( fp-group[, idgens] ) | ( function ) |
The function takes a finitely presented group fp-group given in terms of expression trees and returns a string in the input format of the ANU NQ. If the list idgens is present, then it must contain a sublist of the generators of the presentation. The generators in idgens are treated as identical generators.
gap> x := ExpressionTrees( 2 ); [ x1, x2 ] gap> rels := [x[1]^2, x[2]^2, (x[1]*x[2])^5]; [ x1^2, x2^2, (x1*x2)^5 ] gap> NqStringExpTrees( rec( generators := x, relations := rels ) ); "< x1, x2 |\n x1^2,\n x2^2,\n (x1*x2)^5\n>\n" gap> Print( last ); < x1, x2 | x1^2, x2^2, (x1*x2)^5 > gap> x := ExpressionTrees( 3 ); [ x1, x2, x3 ] gap> rels := [LeftNormedComm( [x[2],x[1],x[1]] ), > LeftNormedComm( [x[2],x[1],x[2]] ), x[3]^7 ]; [ Comm( x2, x1, x1 ), Comm( x2, x1, x2 ), x3^7 ] gap> NqStringExpTrees( rec( generators := x, relations := rels ) ); "< x1, x2, x3 |\n [ x2, x1, x1 ],\n [ x2, x1, x2 ],\n x3^7\n>\n" gap> Print( last ); < x1, x2, x3 | [ x2, x1, x1 ], [ x2, x1, x2 ], x3^7 >
‣ NqElementaryDivisors( int-mat ) | ( function ) |
The function ElementaryDivisorsMat (Reference: ElementaryDivisorsMat) only returns the non-zero elementary divisors of an integer matrix. This function computes the elementary divisors of int-mat and adds the appropriate number of zeroes in order to make it easier to recognize the isomorphism type of the abelian group presented by the integer matrix. At the same time ones are stripped from the list of elementary divisors.
‣ NqRuntime | ( global variable ) |
This variable contains the number of milliseconds of runtime of the last call of ANU NQ.
gap> NilpotentEngelQuotient( FreeGroup(2), 5 ); Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 10, 0, 0, 30, 0, 3, 3, 10, 2, 0, 6, 0, 0, 30, 2, 0, 9, 3, 5, 2, 6, 2, 10, 5, 5, 2, 0, 3, 3, 3, 3, 3, 5, 5, 3, 3 ] gap> NqRuntime; 18200
‣ NqDefaultOptions | ( global variable ) |
This variable contains a list of strings which are the standard command line options passed to the ANU NQ in each call. Modifying this variable can be used to pass additional options to the ANU NQ.
gap> NqDefaultOptions; [ "-g", "-p", "-C", "-s" ]
The option -g causes the ANU NQ to produce output in GAP-format. The option -p prevents the ANU NQ from listing the pc-presentation of the nilpotent quotient at the end of the calculation. The option -C invokes the combinatorial collector. The option -s is effective only in conjunction with options for computing with Engel identities and instructs the ANU NQ to use only semigroup words in the generators as instances of an Engel law.
‣ NqGlobalVariables | ( global variable ) |
This variable contains a list of strings with the names of the global variables that are used in the output stream of the ANU NQ. While the output stream is read, these global variables are assigned new values. To avoid overwriting these variables in case they contain values, their contents is saved before reading the output stream and restored afterwards.
While the standalone program is running it can be asked to display progress information. This is done by setting the info class InfoNQ to \(1\) via the function SetInfoLevel (Reference: InfoLevel).
gap> NilpotentQuotient(FreeGroup(2),5); Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] gap> SetInfoLevel( InfoNQ, 1 ); gap> NilpotentQuotient(FreeGroup(2),5); #I Class 1: 2 generators with relative orders 0 0 #I Class 2: 1 generators with relative orders: 0 #I Class 3: 2 generators with relative orders: 0 0 #I Class 4: 3 generators with relative orders: 0 0 0 #I Class 5: 6 generators with relative orders: 0 0 0 0 0 0 Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] gap> SetInfoLevel( InfoNQ, 0 );
generated by GAPDoc2HTML
nq-2.5.11/doc/chapInd.txt 000644 000766 000024 00000002511 14550113056 015360 0 ustar 00mhorn staff 000000 000000 [1XIndex[101X class 2.2 commutator 2.1 commutator relation 2.3 consistent 2.3 [2XEvaluateExpTree[102X 3.2-2 expression trees 2.6 [2XExpressionTrees[102X 3.2-1 for a list of names 3.2-1 identical generator 2.5 identical relation 2.5 law 2.5 left Engel element 2.5 left-normed commutator 2.1 License .-1 lower central series 2.1 [2XLowerCentralFactors[102X 3.1-4 nilpotency class 2.2 nilpotent 2.2 nilpotent presentation 2.3 Nilpotent Quotient Package 3. [2XNilpotentEngelQuotient[102X 3.1-2 for input from a file 3.1-2 [2XNilpotentQuotient[102X 3.1-1 for input from a file 3.1-1 [5Xnq[105X .-3 [2XNqDefaultOptions[102X 3.4-2 [2XNqElementaryDivisors[102X 3.3-4 [2XNqEpimorphismNilpotentQuotient[102X 3.1-3 [2XNqGlobalVariables[102X 3.4-3 [2XNqReadOutput[102X 3.3-1 [2XNqRuntime[102X 3.4-1 [2XNqStringExpTrees[102X 3.3-3 [2XNqStringFpGroup[102X 3.3-2 options 3.1-1 class 3.1-1 group 3.1-1 idgens 3.1-1 input\_file 3.1-1 input\_string 3.1-1 output\_file 3.1-1 polycyclic 2.2 polycyclic generating sequence 2.2 polycyclic presentation 2.3 power relation 2.3 right Engel element 2.5 ------------------------------------------------------- nq-2.5.11/doc/chap4.html 000644 000766 000024 00000021461 14550113063 015141 0 ustar 00mhorn staff 000000 000000An old problem in the context of Engel elements is the question: Is a right n-Engel element left n-Engel? It is known that the answer is no. For details about the history of the problem, see [NN94]. In this paper the authors show that for n>4 there are nilpotent groups with right n-Engel elements no power of which is a left n-Engel element. The insight was based on computations with the ANU NQ which we reproduce here. We also show the cases 5>n.
gap> LoadPackage( "nq" ); true gap> ## SetInfoLevel( InfoNQ, 1 ); gap> ## gap> ## setup calculation gap> ## gap> et := ExpressionTrees( "a", "b", "x" ); [ a, b, x ] gap> a := et[1];; b := et[2];; x := et[3];; gap> gap> ## gap> ## define the group for n = 2,3,4,5 gap> ## gap> gap> rengel := LeftNormedComm( [a,x,x] ); Comm( a, x, x ) gap> G := rec( generators := et, relations := [rengel] ); rec( generators := [ a, b, x ], relations := [ Comm( a, x, x ) ] ) gap> ## The following is equivalent to: gap> ## NilpotentQuotient( : input_string := NqStringExpTrees( G, [x] ) ) gap> H := NilpotentQuotient( G, [x] ); Pcp-group with orders [ 0, 0, 0 ] gap> LeftNormedComm( [ H.2,H.1,H.1 ] ); id gap> LeftNormedComm( [ H.1,H.2,H.2 ] ); id
This shows that each right 2-Engel element in a finitely generated nilpotent group is a left 2-Engel element. Note that the group above is the largest nilpotent group generated by two elements, one of which is right 2-Engel. Every nilpotent group generated by an arbitrary element and a right 2-Engel element is a homomorphic image of the group H.
gap> rengel := LeftNormedComm( [a,x,x,x] ); Comm( a, x, x, x ) gap> G := rec( generators := et, relations := [rengel] ); rec( generators := [ a, b, x ], relations := [ Comm( a, x, x, x ) ] ) gap> H := NilpotentQuotient( G, [x] ); Pcp-group with orders [ 0, 0, 0, 0, 0, 4, 2, 2 ] gap> LeftNormedComm( [ H.1,H.2,H.2,H.2 ] ); id gap> h := LeftNormedComm( [ H.2,H.1,H.1,H.1 ] ); g6^2*g7*g8 gap> Order( h ); 4
The element h has order 4. In a nilpotent group without 2-torsion a right 3-Engel element is left 3-Engel.
gap> rengel := LeftNormedComm( [a,x,x,x,x] ); Comm( a, x, x, x, x ) gap> G := rec( generators := et, relations := [rengel] ); rec( generators := [ a, b, x ], relations := [ Comm( a, x, x, x, x ) ] ) gap> H := NilpotentQuotient( G, [x] ); Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 12, 0, 5, 10, 2, 0, 30, 5, 2, 5, 5, 5, 5 ] gap> LeftNormedComm( [ H.1,H.2,H.2,H.2,H.2 ] ); id gap> h := LeftNormedComm( [ H.2,H.1,H.1,H.1,H.1 ] ); g9*g10^2*g11^10*g12^5*g13^2*g14^8*g15*g16^6*g17^10*g18*g20^4*g21^4*g22^2*g23^2 gap> Order( h ); 60
The previous calculation shows that in a nilpotent group without 2,3,5-torsion a right 4-Engel element is left 4-Engel.
gap> rengel := LeftNormedComm( [a,x,x,x,x,x] ); Comm( a, x, x, x, x, x ) gap> G := rec( generators := et, relations := [rengel] ); rec( generators := [ a, b, x ], relations := [ Comm( a, x, x, x, x, x ) ] ) gap> H := NilpotentQuotient( G, [x], 9 ); Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 30, 0, 0, 30, 0, 3, 6, 0, 0, 10, 30, 0, 0, 0, 0, 30, 30, 0, 0, 3, 6, 5, 2, 0, 2, 408, 2, 0, 0, 0, 10, 10, 30, 10, 0, 0, 0, 3, 3, 3, 2, 204, 6, 6, 0, 10, 10, 10, 2, 2, 2, 0, 300, 0, 0, 18 ] gap> LeftNormedComm( [ H.1,H.2,H.2,H.2,H.2,H.2 ] ); id gap> h := LeftNormedComm( [ H.2,H.1,H.1,H.1,H.1,H.1 ] );; gap> Order( h ); infinity
Finally, we see that in a torsion-free group a right 5-Engel element need not be a left 5-Engel element.
generated by GAPDoc2HTML
nq-2.5.11/doc/nocolorprompt.css 000644 000766 000024 00000000313 14550113063 016674 0 ustar 00mhorn staff 000000 000000 /* colors for ColorPrompt like examples */ span.GAPprompt { color: #000000; font-weight: normal; } span.GAPbrkprompt { color: #000000; font-weight: normal; } span.GAPinput { color: #000000; } nq-2.5.11/doc/lefttoc.css 000644 000766 000024 00000000474 14550113063 015427 0 ustar 00mhorn staff 000000 000000 /* leftmenu.css Frank Lübeck */ /* Change default CSS to show section menu on left side */ body { padding-left: 28%; } body.chap0 { padding-left: 2%; } div.ChapSects div.ContSect:hover div.ContSSBlock { left: 15%; } div.ChapSects { left: 1%; width: 25%; } nq-2.5.11/doc/intro.xml 000644 000766 000024 00000003674 14550113041 015133 0 ustar 00mhorn staff 000000 000000In this chapter we define notation used throughout this manual and recollect basic facts about nilpotent groups. We also provide some background information about the functionality implemented in this package.
The commutator of two elements \(h_1\) and \(h_2\) of a group \(G\) is the element \(h_1^{-1}h_2^{-1}h_1h_2\) and is denoted by \([h_1,h_2]\). It satisfies the equation \(h_1h_2 = h_2h_1[h_1,h_2]\) and can be interpreted as the correction term that has to be introduced into a word if two elements of a group are interchanged. Iterated commutators are written in left-normed fashion: \([h_1,h_2,\ldots,h_{n-1},h_n]=[[h_1,h_2,\ldots,h_{n-1}],h_n]\).
The lower central series of \(G\) is defined inductively as \(\gamma_1(G) = G, \gamma_i(G) = [\gamma_{i-1}(G),G]\) for \(i \ge 2\). Each term in the lower central series is a normal (even fully invariant) subgroup of \(G\). The factors of the lower central series are abelian groups. On each factor the induced action of \(G\) via conjugation is the trivial action.
The factor \(\gamma_k(G)/\gamma_{k+1}(G)\) is generated by the elements \([g,h]\gamma_{k+1}(G),\) where \(g\) runs through a set of (representatives of) generators for \(G/\gamma_2(G)\) and \(h\) runs through a set of (representatives of) generators for \(\gamma_{k-1}(G)/\gamma_k(G).\) Therefore, each factor of the lower central series is finitely generated if \(G\) is finitely generated.
If one factor of the lower central series is finite, then all subsequent factors are finite. Then the exponent of the \(k+1\)-th factor is a divisor of the exponent of the \(k\)-th factor of the lower central series. In particular, the exponents of all factors of the lower central series are bounded by the exponent of the first finite factor of the lower central series.
A group \(G\) is called nilpotent if there is a positive integer \(c\) such that all \((c+1)\)-fold commutators are trivial in \(G.\) The smallest integer with this property is called the nilpotency class of \(G\). In terms of the lower central series a group \(G \not= 1\) has nilpotency class \(c\) if and only if \(\gamma_{c}(G) \not= 1\) and \(\gamma_{c+1}(G) = 1\).
Examples of nilpotent groups are finite \(p\)-groups, the group of unitriangular matrices over a ring with one and the factor groups of a free group modulo the terms of its lower central series.
Finiteness of a nilpotent group can be decided by the group's commutator factor group. A nilpotent group is finite if and only if its commutator factor group is finite. A group whose commutator factor group is finite can only have finite nilpotent quotient groups.
By refining the lower central series of a finitely generated nilpotent group one can obtain a (sub)normal series \(G_1>G_2>...>G_{k+1}=1\) with cyclic (central) factors. Therefore, every finitely generated nilpotent group is polycyclic. Such a polycyclic series gives rise to a polycyclic generating sequence by choosing a generator \(a_i\) for each cyclic factor \(G_i/G_{i+1}\). Let \(I\) be the set of indices such that \(G_i/G_{i+1}\) is finite. A simple induction argument shows that every element of the group can be written uniquely as a normal word \(a_1^{e_1}\ldots a_n^{e_n}\) with integers \(e_i\) and \(0\leq e_i<m_i\) for \(i\in I\).
From a polycyclic generating sequence one can obtain a polycyclic presentation for the group. The following set of power and commutator relations is a defining set of relations. The power relations express \(a_i^{m_i}\) in terms of the generators \(a_{i+1},\ldots,a_n\) whenever \(G_i/G_{i+1}\) is finite with order \(m_i\). The commutator relations are obtained by expressing \([a_j,a_i]\) for \(j>i\) as a word in the generators \(a_{i+1},\ldots,a_n\). If the polycyclic series is obtained from refining the lower central series, then \([a_j,a_i]\) is even a word in \(a_{j+1},\ldots,a_n\). In this case we obtain a nilpotent presentation.
To be more precise, a nilpotent presentation is given on a finite number of generators \(a_1,\ldots,a_n\). Let \(I\) be the set of indices such that \(G_i/G_{i+1}\) is finite. Let \(m_i\) be the order of \(G_i/G_{i+1}\) for \(i\in I\). Then a nilpotent presentation has the form
\[ \langle a,\ldots,a_n | a_i^{m_i} = w_{ii}(a_{i+1},\ldots,a_n) \mbox{ for } i\in I;\; [a_j,a_i] = w_{ij}(a_{j+1},\ldots,a_n) \mbox{ for } 1\leq i < j\leq n\rangle \]
Here, \(w_{ij}(a_k,\ldots,a_n)\) denotes a group word in the generators \(a_k,\ldots,a_n\).
In a group given by a polycyclic presentation each element in the group can be written as a normal word \(a_1^{e_1}\ldots a_n^{e_n}\) with \(e_i \in \mathbb{Z}\) and \(0 \leq e_i < m_i\) for \(i \in I\). A procedure called collection can be used to convert an arbitrary word in the generators into an equivalent normal word. In general, the resulting normal word need not be unique. The result of collecting a word may depend on the steps chosen during the collection procedure. A polycyclic presentation with the property that two different normal words are never equivalent is called consistent. A polycyclic presentation derived from a polycyclic series as above is consistent. The following example shows an inconsistent polycyclic presentation
\[\langle a,b\mid a^2, b^a = b^2 \rangle \]
as \(b = baa = ab^2a = a^2b^4 = b^4\) which implies \(b^3=1\). Here we have the equivalent normal words \(b^3\) and the empty word. It can be proved that consistency can be checked by collecting a finite number of words in the given generating set in two essentially different ways and checking if the resulting normal forms are the same in both cases. See Chapter 9 of the book [Sim94] for an introduction to polycyclic groups and polycyclic presentations.
For computations in a polycyclic group one chooses a consistent polycyclic presentation as it offers a simple solution to the word problem: Equality between two words is decided by collecting both words to their respective normal forms and comparing the normal forms. Nilpotent groups and nilpotent presentations are special cases of polycyclic groups and polycyclic presentations. Nilpotent presentations allow specially efficient collection methods. The package Polycyclic provides algorithms to compute with polycyclic groups given by a polycyclic presentation.
However, inconsistent nilpotent presentations arise naturally in the nilpotent quotient algorithm. There is an algorithm based on the test words for consistency mentioned above to modify the arising inconsistent presentations suitably to obtain a consistent one for the same group.
The input for the ANU NQ in its simplest form is a finite presentation \(\langle X|R\rangle\) for a group \(G\). The first step of the algorithm determines a nilpotent presentation for the commutator quotient of \(G\). This is a presentation of the class-\(1\) quotient of \(G\). Call its generators \(a_1,...,a_d\). It also determines a homomorphism of \(G\) onto the commutator quotient and describes it by specifying the image of each generator in \(X\) as a word in the \(a_i\).
For the general step assume that the algorithm has computed a nilpotent presentation for the class-\(c\) quotient of \(G\) and that \(a_1,...,a_d\) are the generators introduced in the first step of the algorithm. Furthermore, there is a map from X into the class-\(c\) quotient describing the epimorphism from \(G\) onto \(G/\gamma_{c+1}(G)\).
Let \(b_1,...b_k\) be the generators from the last step of the algorithm, the computation of \(\gamma_c(G)/\gamma_{c+1}(G)\). This means that \(b_1,...b_k\) generate \(\gamma_c(G)/\gamma_{c+1}(G)\). Then the commutators \([b_j,a_i]\) generate \(\gamma_{c+1}(G)/\gamma_{c+2}(G)\). The algorithm introduces new, central generators \(c_{ij}\) into the presentation, adds the relations \([b_j,a_i] = c_{ij}\) and modifies the existing relations by appending suitable words in the \(c_{ij}\), called tails, to the right hand sides of the power and commutator relations. The resulting presentation is a nilpotent presentation for the nilpotent cover of \(G/\gamma_{c+1}(G)\). The nilpotent cover is the largest central extension of \(G/\gamma_{c+1}(G)\) generated by \(d\) elements. It is is uniquely determined up to isomorphism.
The resulting presentation of the nilpotent cover is in general inconsistent. Consistency is achieved by running the consistency test. This results in relations among the generators \(c_{ij}\) which can be used to eliminate some of those generators or introduce power relations. After this has been done we have a consistent nilpotent presentation for the nilpotent cover of \(G/\gamma_{c+1}(G)\).
Furthermore, the nilpotent cover need not satisfy the relations of \(G\). In other words, the epimorphism from \(G\) onto \(G/\gamma_{c+1}(G)\) cannot be lifted to an epimorphism onto the nilpotent cover. Applying the epimorphism to each relator of \(G\) and collecting the resulting words of the nilpotent cover yields a set of words in the \(c_{ij}\). This gives further relations between the \(c_{ij}\) which leads to further eliminations or modifications of the power relations for the \(c_{ij}\).
After this, the inductive step of the ANU NQ is complete and a consistent nilpotent presentation for \(G/\gamma_{c+2}(G)\) is obtained together with an epimorphism from \(G\) onto the class-\((c+1)\) quotient.
Chapter 11 of the book [Sim94] discusses a nilpotent quotient algorithm. A description of the implementation in the ANU NQ is contained in [Nic96]
Let \(w\) be a word in free generators \(x_1,\ldots,x_n\). A group \(G\) satisfies the relation \(w=1\) identically if each map from \(x_1,\ldots,x_n\) into \(G\) maps \(w\) to the identity element of \(G\). We also say that \(G\) satisfies the identical relation \(w=1\) or satisfies the law \(w=1\). In slight abuse of notation, we call the elements \(x_1,\ldots,x_n\) identical generators.
Common examples of identical relations are: A group of nilpotency class at most \(c\) satisfies the law \([x_1,\ldots,x_{c+1}]=1\). A group that satisfies the law \([x,y,\ldots,y]=1\) where \(y\) occurs \(n\)-times, is called an \(n\)-Engel group. A group that satisfies the law \(x^d=1\) is a group of exponent \(d\).
To describe finitely presented groups that satisfy one or more laws, we extend a common notation for finitely presented groups by specifying the identical generators as part of the generator list, separated from the group generators by a semicolon: For example
\[ \langle a,b,c; x,y | x^5, [x,y,y,y]\rangle \]
is a group on 3 generators \(a,b,c\) of exponent \(5\) satisfying the 3rd Engel law. The presentation above is equivalent to a presentation on 3 generators with an infinite set of relators, where the set of relators consists of all fifth powers of words in the generators and all commutators \([x,y,y,y]\) where \(x\) and \(y\) run through all words in the generators \(a,b,c\). The standalone programme accepts the notation introduced above as a description of its input. In GAP 4 finitely presented groups are specified in a different way, see NilpotentQuotient (3.1-1) for a description.
This notation can also be used in words that mix group and identical generators as in the following example:
\[ \langle a,b,c; x | [x,c], [a,x,x,x] \rangle \]
The first relator specifies a law which says that \(c\) commutes with all elements of the group. The second turns \(a\) into a third right Engel element.
An element \(a\) is called a right \(n\)-th Engel element or a right \(n\)-Engel element if it satisfies the commutator law \([a,x,...,x]=1\) where the identical generator \(x\) occurs \(n\)-times. Likewise, an element \(b\) is called an left \(n\)-th Engel element or left \(n\)-Engel element if it satisfies the commutator law \([x,b,b,...b]=1\).
Let \(G\) be a nilpotent group. Then \(G\) satisfies a given law if the law is satisfied by a certain finite set of instances given by Higman's Lemma, see [Hig59]. The ANU NQ uses Higman's Lemma to obtain a finite presentation for groups that satisfy one or several identical relations.
Expressions involving commutators play an important role in the context of nilpotent groups. Expanding an iterated commutator produces a complicated and long expression. For example,
\[ [x,y,z] = y^{-1}x^{-1}yxz^{-1}x^{-1}y^{-1}xyz. \]
Evaluating a commutator \([a,b]\) is done efficiently by computing the equation \((ba)^{-1}ab\). Therefore, for each commutator we need to perform two multiplications and one inversion. Evaluating \([x,y,z]\) needs four multiplications and two inversions. Evaluation of an iterated commutator with \(n\) components takes \(2n-1\) multiplications and \(n-1\) inversions. The expression on the right hand side above needs \(9\) multiplications and \(5\) inversions which is clearly much more expensive than evaluating the commutator directly.
Assuming that no cancellations occur, expanding an iterated commutator with n components produces a word with \(2^{n+1}-2^{n-1}-2\) factors half of which are inverses. A similar effect occurs whenever a compact expression is expanded into a word in generators and inverses, for example \((ab)^{49}\).
Therefore, it is important not to expand expressions into a word in generators and inverses. For this purpose we provide a mechanism which we call here expression trees. An expression tree preserves the structure of a given expression. It is a (binary) tree in which each node is assigned an operation and whose leaves are generators of a free group or integers. For example, the expression \([(xy)^2, z]\) is stored as a tree whose top node is a commutator node. The right subtree is just a generator node (corresponding to \(z\)). The left subtree is a power node whose subtrees are a product node on the left and an integer node on the right. An expression tree can involve products, powers, conjugates and commutators. However, the list of available operations can be extended.
Evaluation of an expression tree is done recursively and requires as many operations as there are nodes in the tree. An expression tree can be evaluated in a specific group by the function EvaluateExpTree (3.2-2).
A presentation specified by expression trees is a record with the components .generators and .relations. See section 3.2 for a description of the functions that produce and manipulate expression trees.
gap> LoadPackage( "nq" ); true gap> gens := ExpressionTrees( 2 ); [ x1, x2 ] gap> r1 := LeftNormedComm( [gens[1],gens[2],gens[2]] ); Comm( x1, x2, x2 ) gap> r2 := LeftNormedComm( [gens[1],gens[2],gens[2],gens[1]] ); Comm( x1, x2, x2, x1 ) gap> pres := rec( generators := gens, relations := [r1,r2] ); rec( generators := [ x1, x2 ], relations := [ Comm( x1, x2, x2 ), Comm( x1, x2, x2, x1 ) ] )
The ANU NQ is written in C, but not in ANSI C. I hope to make one of the next versions ANSI compliable. However, it uses a fairly restricted subset of the language so that it should be easy to compile it in new environments. The code is 64-bit clean. If you have difficulties with porting it to a new environment, let me know and I'll be happy to assist if time permits.
The program has two collectors: a simple collector from the left as described in [LGS90] and a combinatorial from the left collector as described in [VL90]. The combinatorial collector is always faster than the simple collector, therefore, it is the collector used by this package by default. This can be changed by modifying the global variable NqDefaultOptions (3.4-2).
In a polycyclic group with generators that do not have power relations, exponents may become arbitrarily large. Experience shows that this happens rarely in the computations done by the ANU NQ. Exponents are represented by 32-bit integers. The collectors perform an overflow check and abort the computation if an overflow occurred. In a GNU environment the program can be compiled using the `long long' 64-bit integer type. For this uncomment the relevant line in src/Makefile and recompile the program.
As part of the step that enforces consistency and the relations of the group, the ANU NQ performs computations with integer matrices and converts them to Hermite Normal Form. The algorithm used here is a variation of the Kanan-Bachem algorithm based on the GNU multiple precision package GNU MP [GMP]. Experience shows that the integer matrices are usually fairly sparse and Kanan-Bachem seems to be sufficient in this context. However, the implementation might benefit from a more efficient strategy for computing Hermite Normal Forms. This is a topic for further investigations.
As the program does not compute the Smith Normal Form for each factor of the lower central series but the Hermite Normal Form, it does not necessarily obtain a minimal generating set for each factor of the lower central series. The following is a simple example of this behaviour. We take the presentation
\[ \langle x, y | x^2 = y \rangle \]
The group is clearly isomorphic to the additive group of the integers. Applying the ANU NQ to this presentation gives the following nilpotent presentation:
\[ \langle A,B | A^2 = B, [B,A] \rangle \]
A nilpotent presentation on a minimal generating set would be the presentation of the free group on one generator:
\[ \langle A | \; \rangle \]
The input format for finite presentations resembles the way many people write down a presentation on paper. Here are some examples of presentations that the ANU NQ accepts:
< a, b | > # free group of rank 2
< a, b, c; x, y |
[a,b,c], # a left normed commutator
[b,c,c,c]^6, # another one raised to a power
a^2 = c^-3*a^2*c^3, # a relation
a^(b*c) = a, # a conjugate relation
(a*[b,(a*c)])^6, # something that looks complicated
[x,y,y,y,y], # an identical relation
[c,x,x,x,x,x] # c is a fifth right Engel element
>
A presentation starts with '<' followed by a list of generators separated by commas. Generator names are strings that contain only upper and lower case letters, digits, dots and underscores and that do not start with a digit. The list of generator names is separated from the list of relators/relations by the symbol '\(\mid\)'. The list of generators can be followed by a list of identical generators separated by a semicolon. Relators and relations are separated by commas and can be mixed arbitrarily. Parentheses can be used in order to group subexpressions together. Square brackets can be used in order to form left normed commutators. The symbols '*' and '^' can be used to form products and powers, respectively. The presentation finishes with the symbol '>'. A comment starts with the symbol '#' and finishes at the end of the line. The file src/presentation.c contains a complete grammar for the presentations accepted by the ANU NQ.
Typically, the input for the standalone is put into a file by using a standard text editor. The file can be passed as an argument to the function NilpotentQuotient (3.1-1). It is also possible to put a presentation in the standalone's input format into a string and use the string as argument for NilpotentQuotient (3.1-1).
generated by GAPDoc2HTML
nq-2.5.11/doc/chap5.html 000644 000766 000024 00000016733 14550113063 015150 0 ustar 00mhorn staff 000000 000000Installation of the ANU NQ is done in two steps.
First the configure script is run:
./configure
If you installed the package in another "pkg" directory than the standard "pkg" directory in your GAP 4 installation, then you have to do two things. Firstly during compilation you have to use the option --with-gaproot=PATH of the configure script where "PATH" is a path to the main GAP root directory (if not given the default "../.." is assumed). That is, run
./configure --with-gaproot=PATH
Secondly you have to specify the path to the directory containing your "pkg" directory to GAP's list of directories. This can be done by starting GAP with the "-l" command line option followed by the name of the directory and a semicolon. Then your directory is prepended to the list of directories searched. Otherwise the package is not found by GAP. Of course, you can add this option to your GAP startup script.
Another issue that can occur when running configure is that it may fail to locate the the GNU multiple precision library (GMP [GMP]) which ANU NQ requires to work. This library is also used by GAP and hence normally should be available on your system anyway. But if this is not the case for some reason, it has to be installed first. A copy of GMP can be obtained from https://gmplib.org/.
In order for the configure script to find your copy of GMP, you may have tell it where to find it via --with-gmp=PATH, where "PATH" is the path where GMP was installed:
./configure --with-gmp=PATH
If necessary, you may combine --with-gmp and --with-gaproot.
If configure reports no problems, the next step is to start the compilation:
make
A compiled version of the program named nq is then placed into the directory bin/<complicated name>. The <complicated name> component encodes the operating system and the compiler used. This allows you to compile NQ on several architectures sharing the same files system.
If there are any warnings or even fatal error messages during the compilation process, please submit a bug report about that following the instructions in Section 5.4
After the compilation is finished you can check if the ANU NQ is running properly on your system. Simply type
make test
This runs some computations and compares their output with the output files in the directory examples. If any errors are reported, please follow the instructions below.
If you encounter problems with any of the above steps, please do not hesitate to contact us about this. You can either use the nq issue tracker or contact the GAP support group via support@gap-system.org. Please make sure to include information about the specific issue you encountered (e.g. steps to reproduce it, the specific error message), your operating system, the compiler you used and also the versions of GAP and this package that were involved.
generated by GAPDoc2HTML
nq-2.5.11/doc/examples.xml 000644 000766 000024 00000007346 14550113041 015616 0 ustar 00mhorn staff 000000 000000If you start the ANU NQ by typing
nq -X
you will get the following message:
unknown option: -X
usage: nq [-a] [-M] [-d] [-g] [-v] [-s] [-f] [-c] [-m]
[-t <n>] [-l <n>] [-r <n>] [-n <n>] [-e <n>]
[-y] [-o] [-p] [-E] [<presentation>] [<class>]
All parameters in square brackets are optional. The parameter <presentation> has to be the name of a file that contains a finite group presentation for which a nilpotent quotient is to be calculated. This file name must not start with a digit. If it is not present, nq will read the presentation from standard input. The parameter <class> restricts the computation of the nilpotent quotient to at most that (nilpotency) class, i.e. the program calculates the quotient group of the (c+1)-th term of the lower central series. If <class> is omitted, the program computes successively the factor groups of the lower central series of the given group. If there is a largest nilpotent quotient, i.e., if the lower central series becomes constant, the program will eventually terminate with the largest nilpotent quotient. If there is no largest nilpotent quotient, the program will run forever (or more precisely will run out of resources). On termination the program prints a nilpotent presentation for the nilpotent quotient it has computed. The options -l, -r and -e can be used to enforce Engel conditions on the nilpotent quotient to be calculated. All these options have to be followed by a positive integer <n>. Their meaning is the following:
This option forces the first k generators to be left or right Engel element if also the option -l or -r (or both) is present. Otherwise it is ignored.
This forces the first k generators g_1,...,g_k of the nilpotent quotient Q to be left n-Engel elements, i.e., they satisfy [x,...,x,g_i] = 1 (x occurring n-times) for all x in Q and 1 <= i <= k. If the option -n is not used, then k = 1.
This forces the first k generators g_1,...,g_k of the nilpotent quotient Q to be right n-Engel elements,i.e., they satisfy [g_i,x,..,x] = 1 (x occurring n-times) for all x in Q and 1 <= i <= k. If the option -n is not used, then k = 1.
This enforces the n-th Engel law on Q, i.e., [x,y,..,y] = 1 (y occurring n-times) for all x,y in Q.
This option specifies how much CPU time the program is allowed to use. It will terminate after <n> seconds of CPU time. If <n> is followed (without space) by one of the letters m, h or d, <n> specifies the time in minutes, hours or days, respectively.
The other options have the following meaning. Care has to be taken when the options -s or -c are used since the resulting nilpotent quotient need NOT satisfy the required Engel condition. The reason for this is that a smaller set of test words is used if one of these two options are present. Although this smaller set of test words seems to be sufficient to enforce the required Engel condition, this fact has not been proven.
For each factor of the lower central series a file is created in the current directory that contains an integer matrix describing the factor as abelian group. The first number in that file is the number of columns of the matrix. Then the matrix follows in row major order. The matrix for the i-th factor is put into the file <presentation>.abinv.<i>.
toggles printing of the pc presentation for the nilpotent quotient at the end of a calculation.
This option causes the program to check only semigroup words in the generating set of the nilpotent quotient when an Engel condition is enforced. If none of the options -l, -r or -e are present, it is ignored.
This option causes to check semiwords in the generating set of the nilpotent quotient first and then all other words that need to be checked. It is ignored if the option -s is used or none of the options -l, -r or -e are present.
This option stops checking the Engel law at each class if all the checks of a certain weight did not yield any non-trivial instances of the law.
Switch on debug mode and perform checks during the computation. Not yet implemented.
In checking Engel identities, instances are process in the order of increased weight. This flag reverses the order.
Enforce the identities x^8 and [ [x1,x2,x3], [x4,x5,x6] ] on the nilpotent quotient.
Switch on verbose mode.
Produce GAP output. Presently the GAP output consists only of a sequence of integer matrices whose rows are relations of the factors of the lower central series as abelian groups. This will change as soon as GAP can handle infinite polycyclic groups.
the *last* n generators are Engel generators. This works in conjunction with option -n.
output the relation matrix for each factor of the lower central series. The matrices are written to files with the names 'matrix.<cl>' where <cl> is replaced by the number of the factor in the lower central series. Each file contains first the number of columns of the matrix and then the rows of the matrix. The matrix is written as each relation is produced and is not in upper triangular form.
output the relation matrix before and after relations have been enforced. This results in two groups of files with names '<pres>.nilp.<cl>' and '<pres>.mult.<cl>' where <pres> is the name of the input files and <cl> is the class. The matrices are in upper triangular form.
The input format for finite presentations resembles the way many people write down a presentation on paper. Here are some examples of presentations that the ANU NQ accepts:
< a, b | > # free group of rank 2
< a, b, c | [a,b,c], # a left normed commutator
[b,c,c,c]^6, # another one raised to a power
a^2 = c^-3*a^2*c^3, # a relation
a^(b*c) = a, # a conjugate relation
(a*[b,(a*c)])^6 # something that looks complicated
>
A presentation starts with '<' followed be a list of generators separated by commas. Generator names are strings that contain only upper and lower case letters, digits, dots and underscores and that do not start with a digit. The list of generator names is separated from the list of relators/relations by the symbol '|'. Relators and relations are separated by commas and can be mixed arbitrarily. Parentheses can be used in order to group subexpressions together. Square brackets can be used in order to form left normed commutators. The symbols '*' and '^' can be used to form products and powers, respectively. The presentation finishes with the symbol '>'. A comment starts with the symbol '#' and finishes at the end of the line. The file src/presentation.c contains a complete grammar for the presentations accepted by the ANU NQ.
Let G be the free group on two generators x and y. The input file (called free2.fp here) contains the following:
< x, y | >
Computing the class 3 quotient with the ANU NQ by typing
nq free2.fp 3
produces the following output:
#
# The ANU Nilpotent Quotient Program (Version 2.3)
# Calculating a nilpotent quotient
# Input: free2.fp
# Nilpotency class: 3
# Program: nq
# Size of exponents: 8 bytes
#
# Calculating the abelian quotient ...
# The abelian quotient has 2 generators
# with the following exponents: 0 0
#
# Calculating the class 2 quotient ...
## Sizes: 2 3
# Layer 2 of the lower central series has 1 generators
# with the following exponents: 0
#
# Calculating the class 3 quotient ...
## Sizes: 2 3 5
# Layer 3 of the lower central series has 2 generators
# with the following exponents: 0 0
#
# The epimorphism :
# x |---> A
# y |---> B
# The nilpotent quotient :
<A,B,C,D,E
|
B^A =: B*C,
B^(A^-1) = B*C^-1*D,
C^A =: C*D,
C^(A^-1) = C*D^-1,
C^B =: C*E,
C^(B^-1) = C*E^-1 >
# Class : 3
# Nr of generators of each class : 2 1 2
# The definitions:
# C := [ B, A ]
# D := [ B, A, A ]
# E := [ B, A, B ]
# total runtime : 1 msec
## Total time spent on integer matrices: 0
Most of the comments are fairly self-explanatory. One note of caution is necessary: The number of generators for each factor of the lower central series is not the minimal number possible but is the number of generators that the ANU NQ chose to use. This will be improved in one of the future version of the program. The epimorphism from the original group onto the nilpotent quotient is printed in a somewhat confusing way. The generators on the left hand side of the arrows correspond to the generators in the original presentation but are printed with different names. This will be fixed in one of the next version.
The implementation of the algorithm is fairly straight forward. The program uses a weighted nilpotent presentation with definitions to represent a nilpotent group. Calculations in the nilpotent group are done using a collector from the left without combinatorial collection. Generators for the c-th lower central factor are defined as commutators of the form [y,x], where x is a generator of weight 1 and y is a generator of weight c-1. Then the program calculates the necessary changes (tails) for all relations which are not definitions, runs through the consistency check and evaluates the original relations on the polycyclic presentation. This gives a list of words, which have to be made trivial in order to obtain a consistent polycyclic presentation representing a nilpotent quotient of the given finitely presented group. This list is converted into a integer matrix, which is transformed into upper triangular form using the Kannan-Bachem algorithm. The GNU multiple precision package is used for this.
generated by GAPDoc2HTML
nq-2.5.11/doc/rainbow.js 000644 000766 000024 00000005336 14550113063 015256 0 ustar 00mhorn staff 000000 000000 function randchar(str) { var i = Math.floor(Math.random() * str.length); while (i == str.length) i = Math.floor(Math.random() * str.length); return str[i]; } hexdigits = "0123456789abcdef"; function randlight() { return randchar("cdef")+randchar(hexdigits)+ randchar("cdef")+randchar(hexdigits)+ randchar("cdef")+randchar(hexdigits) } function randdark() { return randchar("012345789")+randchar(hexdigits)+ randchar("012345789")+randchar(hexdigits)+ randchar("102345789")+randchar(hexdigits) } document.write('\n'); nq-2.5.11/doc/nqbib.xml 000644 000766 000024 00000006167 14550113041 015073 0 ustar 00mhorn staff 000000 000000TOQ q)㠴Pbh'˘&%!ڢL IWЮU}T|N>WT_uUNTYh _%kSG*rQtzWZȲᇒgKʪ;xѤ.)ҙOY8i3{*ySS^vPjtmzO^d]4<7=GBsIYzƥ4 YѺJ{D g(8 ٣ ^:
o Pf
B!ix=q 90w 8k_[ V%M j Bպ3hpem[b]L8LJf{9Eg kAAE_ZGY;d
ȹ8 ;,=<b/Rr5amX ƶ :LCCh/[ÓclYYS{NȴD
Y u'Aǖ&瓹daMf/V[fB2~;Ո}η/.,W&WU3t֦ya[Fskƨ}&Vc@ 5>/L c8P M e{4ycQKJS\3\ T?'m#R.|ƈqqsjY+JF y ?%u;y6?nn1 ~y6WP}TOb
p T;)5H4O>I ?*!8}KdԋhK
BDF82Z8 ݂(P V C/]5삸,5t0pȐ8nMf@Ls-u52OB.ĩ!]YX뤓|1U`^D(J¼ {4U%hmkGI8~$:{CfC^͂ 'nq?qyk|a jp6lr w+K1^EQ .s2IDçMLAB"NBHnߡe?jwƊ E.,ZN/GuX S('<@}Qr&3|v$sP/698YwJ t"#܊j2ɐui*uJ*xIݝmhCb6GE{-RԞ'侢uUhz9|XH[@A
7VB,4h?h7T DMM|xw=lY^Ywy&6g0,9c3hlLM}\jG$GpB#Ў!5%칛S]|{fm9uP1psl\} A
e5F` 5 8IUI+gi{V"}d+|[w!mxLZK `}<nkj=4/*5hk⾟:0Hg5\4?Uq&
'Zpbz%7 a[
zW.QP ~zD>3 {&އPmSJ:Jegh/0sBЙ*p_7jqB+mAs
ԱXl^Hs;a}f`ϻEq/"2N 2 NXjKy6Р||f\L4Pda#K)l#69#`fknB۟6Sm}U:V-n|+I
uRHȆR~YU*`Q|HmC8
=T~ޅ橷W`|ZJ:¤[
Gʭ5"f Oap]U9A639)w {a&ℳ[k+t3S`GD\D1:TV&4=5p#6kӊ ZY`Z[=rմM/ uS7 <?AeCpI1+E
O2$2PI>ۓ8"s!hS]hyk*YZ-=mf7N b:W1%cЋ( ģ-*}ZO'Y̒X.l+_ONF"<2LHd)l"c lBb A= 겜f&[V&~3!F 'r3%.6YCㇵ$ R$@Mp (
5JzH#5-G7$ aTHORET kز)0Wzk#iv+U J,U晧 iH=G²$R_g(l寍 w
IӰ(E {
-n p99PY۶-l]w~L3|S=Fu]d%(o!HNwKCGwр5M7#?5dҒPȂIT!eGk~^V08> FtOBS/fC\!#cԱzYgAn"DҸ&H`L.,CX|vNPT /e::Bo 6?a# =}Rgyc<y8CګPc9
,8X" >Ĉ#"i1}@(3fm x/䎒?G7̆46[, i
k<j,CcX%s 4Tڐ1)8J9iZ{@%@n1Sxij7{:hI٥xI ,B0XۮY:U(
4>~w)'X y\yB RD
:Ƨ9_ ī.zR;B1x;-¼t r.Z]X'> 2znN5+
mكy]5m ݎ5 =\3 d٩ +wN˳))pGakǬ͗%7hm. >DyE_Y;^wK|Dnf gdzjY{<)jmpѓv ? /N1\omr ~vU5O.
:Cu>jTsтWGiɅHPɒQʉU Rτ^߷>bЙ63띾k$펻/ +nĩk#
ܝp$ S6Yp)8+eOskE[MSLiRغu1SoIR%IͱY6R Xuh^YgSg{7=qaͭ\{^c`]96%"qϤo^xgZ5 2HSkG/s[N_| {kw]>QUc 1M ?cWX
endstream
endobj
493 0 obj
<<
/Length1 1626
/Length2 14143
/Length3 0
/Length 14994
/Filter /FlateDecode
>>
stream
xڭeP%4P;5P[7.ӸCn;k&Νg"j\+x(IUE-@f@)+#+ @E
dU`TZ >@SW+
H ll V^^^J8@MKO_B f^bc 9 \?!Ձ@5`ic+*Ih4@ @ `ctp,A Zsau\ 6i@Os?.#?`l9W vKп9:>#?}`* WsgGWgU t6uͧ ҿ|0^WS+Zf@gO0Ggpsq/ g W{SGG;e8ظ ,X>k~ֶq@`gWd ,A V- 3$L-@v^ %$Ne>$oEF%{ZNs > S;P иRLm3Zob ;ɺ~DS&m\l<*6 KSyˮ`tq ~YYXçamc 8:X'OEYVK[GG+Ps \5 ?VA`d`{xX%_gESWgOg,d 0 Fs ]v #.m2]kqr'${Y!C K4
z·y+M^kBۼO F{{R~}hT ߙJhG\.(lAqh LMu;]>bR<8bu~iC- G_2>...>G_k+1=1[122X with cyclic
(central) factors. Therefore, every finitely generated nilpotent group is
[13Xpolycyclic[113X. Such a [13Xpolycyclic series[113X gives rise to a polycyclic generating
sequence by choosing a generator [22Xa_i[122X for each cyclic factor [22XG_i/G_i+1[122X. Let [22XI[122X
be the set of indices such that [22XG_i/G_i+1[122X is finite. A simple induction
argument shows that every element of the group can be written uniquely as a
[13Xnormal word[113X [22Xa_1^e_1... a_n^e_n[122X with integers [22Xe_i[122X and [22X0≤ e_i
[EN02] Eick, B. and Nickel, W.,
Polycyclic,
Algorithms for working with polycyclic groups
(2002)
[GMP]
GNU MP,
https://gmplib.org/.
[Hig59] Higman, G.,
Some remarks on varieties of groups,
Quart. J. Math. Oxford,
2 (10)
(1959),
165–178.
[LGS90] Leedham-Green, C. R. and Soicher, L. H.,
Collection from the left and other strategies,
J. Symbolic Comput.,
9 (5–6)
(1990),
665–675.
[Nic96] Nickel, W.,
Computing Nilpotent Quotients of Finitely Presented Groups,
in Geometric and Computational Perspectives on Infinite
Groups,
Dimacs Series in Discrete Mathematics and Theoretical Computer
Science,
25
(1996),
175–191.
[NN94] Newman, M. F. and Nickel, W.,
Engel elements in groups,
J. Pure Appl. Algebra,
96
(1994),
39–45.
[Sim94] Sims, C. C.,
Computation with Finitely Presented Groups,
Cambridge University Press
(1994).
[VL90] Vaughan-Lee, M. R.,
Collection from the Left,
J. Symbolic Comput.,
Academic Press,
9
(1990),
725–733.
generated by GAPDoc2HTML
2.5.11
12 January 2024
Werner Nickel
© 1992-2007 Werner Nickel The nq package is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The author of ANU NQ is Werner Nickel. The development of this program was started while the author was supported by an Australian National University PhD scholarship and an Overseas Postgraduate Research Scholarship. Further development of this program was done with support from the DFG-Schwerpunkt-Projekt "Algorithmische Zahlentheorie und Algebra". Since then, maintenance of ANU NQ has been taken over by Max Horn. All credit for creating ANU NQ still goes to Werner Nickel as sole author. However, bug reports and other inquiries should be sent to Max Horn. The following are the original acknowledgements by Werner Nickel. Over the years a number of people have made useful suggestions that found their way into the code: Mike Newman, Michael Vaughan-Lee, Joachim Neubüser, Charles Sims. Thanks to Volkmar Felsch and Joachim Neubüser for their careful examination of the package prior to its release for GAP 4. This documentation was prepared with the GAPDoc package by Frank Lübeck and Max Neunhöffer. generated by GAPDoc2HTML An old problem in the context of Engel elements is the question: Is a right \(n\)-Engel element left \(n\)-Engel? It is known that the answer is no. For details about the history of the problem, see [NN94]. In this paper the authors show that for \(n>4\) there are nilpotent groups with right \(n\)-Engel elements no power of which is a left \(n\)-Engel element. The insight was based on computations with the ANU NQ which we reproduce here. We also show the cases \(5>n\). This shows that each right 2-Engel element in a finitely generated nilpotent group is a left 2-Engel element. Note that the group above is the largest nilpotent group generated by two elements, one of which is right 2-Engel. Every nilpotent group generated by an arbitrary element and a right 2-Engel element is a homomorphic image of the group \(H\). The element \(h\) has order \(4\). In a nilpotent group without \(2\)-torsion a right 3-Engel element is left 3-Engel. The previous calculation shows that in a nilpotent group without \(2,3,5\)-torsion a right 4-Engel element is left 4-Engel. Finally, we see that in a torsion-free group a right 5-Engel element need not be a left 5-Engel element. generated by GAPDoc2HTML This package provides an interface between GAP 4 and the Australian National University Nilpotent Quotient Program (ANU NQ). The ANU NQ was implemented as part of the author's work towards his PhD at the Australian National University, hence the name of the program. The program takes as input a finite presentation of a group and successively computes factor groups modulo the terms of the lower central series of the group. These factor groups are computed in terms of polycyclic presentations. The ANU NQ is implemented in the programming language C. The implementation has been developed in a Unix environment and Unix is currently the only operating system supported. It runs on a number of different Unix versions, e.g. Solaris and Linux. For integer matrix computations it relies on the GNU MP [GMP] package and requires this package to be installed on your system. This package relies on the functionality for polycyclic groups provided by the GAP package polycyclic [EN02] and requires the package polycyclic to be installed as a GAP package on your computer system. Comments, bug reports and suggestions are very welcome, please submit them via our issue tracker. This manual contains references to parts of the GAP Reference Manual which are typeset in a slightly idiosyncratic way. The following example shows how such references are printed: 'For further information on creating a free group see Each item in the list of references at the end of this manual is followed by a list of numbers that specify the pages of the manual where the reference occurs. generated by GAPDoc2HTML Installation of the ANU NQ is done in two steps. First the configure script is run: If you installed the package in another " Secondly you have to specify the path to the directory containing your " Another issue that can occur when running In order for the If necessary, you may combine If A compiled version of the program named If there are any warnings or even fatal error messages during the compilation process, please submit a bug report about that following the instructions in Section 5.4 After the compilation is finished you can check if the ANU NQ is running properly on your system. Simply type This runs some computations and compares their output with the output files in the directory If you encounter problems with any of the above steps, please do not hesitate to contact us about this. You can either use the nq issue tracker or contact the GAP support group via support@gap-system.org. Please make sure to include information about the specific issue you encountered (e.g. steps to reproduce it, the specific error message), your operating system, the compiler you used and also the versions of GAP and this package that were involved. generated by GAPDoc2HTML generated by GAPDoc2HTMLReferences
(GAP package),
https://gap-packages.github.io/polycyclic/.
nq
Nilpotent Quotients of Finitely Presented Groups
Homepage: http://www.mathematik.tu-darmstadt.de/~nickel/
Copyright
Acknowledgements
Contents
3 The Functions of the Package
4 Examples
4.1 Right Engel elements
gap> LoadPackage( "nq" );
true
gap> ## SetInfoLevel( InfoNQ, 1 );
gap> ##
gap> ## setup calculation
gap> ##
gap> et := ExpressionTrees( "a", "b", "x" );
[ a, b, x ]
gap> a := et[1];; b := et[2];; x := et[3];;
gap>
gap> ##
gap> ## define the group for n = 2,3,4,5
gap> ##
gap>
gap> rengel := LeftNormedComm( [a,x,x] );
Comm( a, x, x )
gap> G := rec( generators := et, relations := [rengel] );
rec( generators := [ a, b, x ], relations := [ Comm( a, x, x ) ] )
gap> ## The following is equivalent to:
gap> ## NilpotentQuotient( : input_string := NqStringExpTrees( G, [x] ) )
gap> H := NilpotentQuotient( G, [x] );
Pcp-group with orders [ 0, 0, 0 ]
gap> LeftNormedComm( [ H.2,H.1,H.1 ] );
id
gap> LeftNormedComm( [ H.1,H.2,H.2 ] );
id
gap> rengel := LeftNormedComm( [a,x,x,x] );
Comm( a, x, x, x )
gap> G := rec( generators := et, relations := [rengel] );
rec( generators := [ a, b, x ], relations := [ Comm( a, x, x, x ) ] )
gap> H := NilpotentQuotient( G, [x] );
Pcp-group with orders [ 0, 0, 0, 0, 0, 4, 2, 2 ]
gap> LeftNormedComm( [ H.1,H.2,H.2,H.2 ] );
id
gap> h := LeftNormedComm( [ H.2,H.1,H.1,H.1 ] );
g6^2*g7*g8
gap> Order( h );
4
gap> rengel := LeftNormedComm( [a,x,x,x,x] );
Comm( a, x, x, x, x )
gap> G := rec( generators := et, relations := [rengel] );
rec( generators := [ a, b, x ], relations := [ Comm( a, x, x, x, x ) ] )
gap> H := NilpotentQuotient( G, [x] );
Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 12, 0, 5, 10, 2, 0, 30,
5, 2, 5, 5, 5, 5 ]
gap> LeftNormedComm( [ H.1,H.2,H.2,H.2,H.2 ] );
id
gap> h := LeftNormedComm( [ H.2,H.1,H.1,H.1,H.1 ] );
g9*g10^2*g11^10*g12^5*g13^2*g14^8*g15*g16^6*g17^10*g18*g20^4*g21^4*g22^2*g23^2
gap> Order( h );
60
gap> rengel := LeftNormedComm( [a,x,x,x,x,x] );
Comm( a, x, x, x, x, x )
gap> G := rec( generators := et, relations := [rengel] );
rec( generators := [ a, b, x ], relations := [ Comm( a, x, x, x, x, x ) ] )
gap> H := NilpotentQuotient( G, [x], 9 );
Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 30,
0, 0, 30, 0, 3, 6, 0, 0, 10, 30, 0, 0, 0, 0, 30, 30, 0, 0, 3, 6, 5, 2, 0,
2, 408, 2, 0, 0, 0, 10, 10, 30, 10, 0, 0, 0, 3, 3, 3, 2, 204, 6, 6, 0, 10,
10, 10, 2, 2, 2, 0, 300, 0, 0, 18 ]
gap> LeftNormedComm( [ H.1,H.2,H.2,H.2,H.2,H.2 ] );
id
gap> h := LeftNormedComm( [ H.2,H.1,H.1,H.1,H.1,H.1 ] );;
gap> Order( h );
infinity
1 Introduction
FreeGroup (Reference: FreeGroup).' The text in bold face refers to the GAP Reference Manual.
5 Installation of the Package
5.1 Configuring for compilation
./configure
pkg" directory than the standard "pkg" directory in your GAP 4 installation, then you have to do two things. Firstly during compilation you have to use the option --with-gaproot=PATH of the configure script where "PATH" is a path to the main GAP root directory (if not given the default "../.." is assumed). That is, run ./configure --with-gaproot=PATH
pkg" directory to GAP's list of directories. This can be done by starting GAP with the "-l" command line option followed by the name of the directory and a semicolon. Then your directory is prepended to the list of directories searched. Otherwise the package is not found by GAP. Of course, you can add this option to your GAP startup script.configure is that it may fail to locate the the GNU multiple precision library (GMP [GMP]) which ANU NQ requires to work. This library is also used by GAP and hence normally should be available on your system anyway. But if this is not the case for some reason, it has to be installed first. A copy of GMP can be obtained from https://gmplib.org/.configure script to find your copy of GMP, you may have tell it where to find it via --with-gmp=PATH, where "PATH" is the path where GMP was installed: ./configure --with-gmp=PATH
--with-gmp and --with-gaproot.5.2 Compiling the nq binary
configure reports no problems, the next step is to start the compilation: make
nq is then placed into the directory bin/<complicated name>. The <complicated name> component encodes the operating system and the compiler used. This allows you to compile NQ on several architectures sharing the same files system.5.3 Testing
make test
examples. If any errors are reported, please follow the instructions below.5.4 Feedback
Index
nq .-3
class 2.2
commutator 2.1
commutator relation 2.3
consistent 2.3
EvaluateExpTree 3.2-2
expression trees 2.6
ExpressionTrees 3.2-1
for a list of names 3.2-1
identical generator 2.5
identical relation 2.5
law 2.5
left Engel element 2.5
left-normed commutator 2.1
License .-1
lower central series 2.1
LowerCentralFactors 3.1-4
nilpotency class 2.2
nilpotent 2.2
nilpotent presentation 2.3
Nilpotent Quotient Package 3.
NilpotentEngelQuotient 3.1-2
for input from a file 3.1-2
NilpotentQuotient 3.1-1
for input from a file 3.1-1
NqDefaultOptions 3.4-2
NqElementaryDivisors 3.3-4
NqEpimorphismNilpotentQuotient 3.1-3
NqGlobalVariables 3.4-3
NqReadOutput 3.3-1
NqRuntime 3.4-1
NqStringExpTrees 3.3-3
NqStringFpGroup 3.3-2
options 3.1-1
class 3.1-1
group 3.1-1
idgens 3.1-1
input\_file 3.1-1
input\_string 3.1-1
output\_file 3.1-1
polycyclic 2.2
polycyclic generating sequence 2.2
polycyclic presentation 2.3
power relation 2.3
right Engel element 2.5
Setting preferences for GAPDoc manuals
nq-2.5.11/m4/find_gap.m4 000644 000766 000024 00000005573 14550113041 015042 0 ustar 00mhorn staff 000000 000000 # Find the location of GAP
# Sets GAPROOT, GAPARCH and GAP_CPPFLAGS appropriately
# Can be configured using --with-gaproot=...
#######################################################################
AC_DEFUN([FIND_GAP],
[
AC_LANG_PUSH([C])
# Make sure CDPATH is portably set to a sensible value
CDPATH=${ZSH_VERSION+.}:
GAP_CPPFLAGS=""
######################################
# Find the GAP root directory by
# checking for the sysinfo.gap file
AC_MSG_CHECKING([for GAP root directory])
GAPROOT="../.."
# Allow the user to specify the location of GAP
AC_ARG_WITH(gaproot,
[AS_HELP_STRING([--with-gaproot=