TC^0 circuits for algorithmic problems in nilpotent groups
Alexei Myasnikov, Armin Wei{\ss}

TL;DR
This paper demonstrates that key algorithmic problems in finitely generated nilpotent groups are complete for the circuit class TC^0, extending previous Logspace results and showing their computational efficiency within this class.
Contribution
The paper proves that multiple algorithmic problems in nilpotent groups are TC^0-complete, and establishes the TC^0 complexity of the unary extended gcd problem, broadening understanding of their computational complexity.
Findings
Problems are TC^0-complete for finitely generated nilpotent groups.
Unary extended gcd problem is in TC^0.
Word problem and normal form computations are in uniform TC^0 with binary inputs.
Abstract
Recently, Macdonald et. al. showed that many algorithmic problems for finitely generated nilpotent groups including computation of normal forms, the subgroup membership problem, the conjugacy problem, and computation of subgroup presentations can be done in Logspace. Here we follow their approach and show that all these problems are complete for the uniform circuit class TC^0 - uniformly for all r-generated nilpotent groups of class at most c for fixed r and c. In order to solve these problems in TC^0, we show that the unary version of the extended gcd problem (compute greatest common divisors and express them as linear combinations) is in TC^0. Moreover, if we allow a certain binary representation of the inputs, then the word problem and computation of normal forms is still in uniform TC^0, while all the other problems we examine are shown to be TC^0-Turing reducible to the binary…
Click any figure to enlarge with its caption.
Figure 1
Figure 2Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Taxonomy
Topicssemigroups and automata theory · Finite Group Theory Research · Coding theory and cryptography
\Copyright
Alexei Myasnikov, Armin Weiß
circuits for algorithmic problems in nilpotent groups
Alexei Myasnikov
Stevens Institute of Technology, Hoboken, NJ, USA
Armin Weiß
Universität Stuttgart, Germany
Abstract
Recently, Macdonald et. al. showed that many algorithmic problems for finitely generated nilpotent groups including computation of normal forms, the subgroup membership problem, the conjugacy problem, and computation of subgroup presentations can be done in . Here we follow their approach and show that all these problems are complete for the uniform circuit class – uniformly for all -generated nilpotent groups of class at most for fixed and .
In order to solve these problems in , we show that the unary version of the extended gcd problem (compute greatest common divisors and express them as linear combinations) is in .
Moreover, if we allow a certain binary representation of the inputs, then the word problem and computation of normal forms is still in uniform , while all the other problems we examine are shown to be -Turing reducible to the binary extended gcd problem.
keywords:
nilpotent groups, , abelian groups, word problem, conjugacy problem, subgroup membership problem, greatest common divisors
Contents
1 Introduction
The word problem (given a word over the generators, does it represent the identity?) is one of the fundamental algorithmic problems in group theory introduced by Dehn in 1911 [3]. While for general finitely presented groups all these problems are undecidable [23, 2], for many particular classes of groups decidability results have been established – not just for the word problem but also for a wide range of other problems. Finitely generated nilpotent groups are a class where many algorithmic problems are (efficiently) decidable (with some exceptions like the problem of solving equations – see e. g. [6]).
In 1958, Mal’cev [18] established decidability of the word and subgroup membership problem by investigating finite approximations of nilpotent groups. In 1965, Blackburn [1] showed decidability of the conjugacy problem. However, these methods did not allow any efficient (e. g. polynomial time) algorithms. Nevertheless, in 1966 Mostowski provided “practical” algorithms for the word problem and several other problems [20]. In terms of complexity, a major step was the result by Lipton and Zalcstein [15] that the word problem of linear groups is in . Together with the fact that finitely generated nilpotent groups are linear (see e. g. [7, 10]) this gives a solution to the word problem of nilpotent groups, which was later improved to uniform by Robinson [24].
A typical algorithmic approach to nilpotent groups is using so-called Mal’cev (or Hall–Mal’cev) bases (see e. g. [7, 10]), which allow to carry out group operations by evaluating polynomials (see Lemma 2.3). This approach was systematically used in [11] and [20] or – in the more general setting of polycyclic presentations – in [25] for solving (among others) the subgroup membership and conjugacy problem of polycyclic groups. Recently in [21, 22] polynomial time bounds for the equalizer and subgroup membership problems in nilpotent groups have been given. Finally, in [16] the following problems were shown to be in using the Mal’cev basis approach. Here, denotes the class of nilpotent groups of nilpotency class at most generated by at most elements.
- •
The word problem: given and , is in ?
- •
Given and , compute the (Mal’cev) normal form of .
- •
The subgroup membership problem: Given and , decide whether and, if so, express as a word over the subgroup generators (in [16] only the decision version was shown to be in – for expressing as a word over the original subgroup generators a polynomial time bound was given).
- •
Given and , together with a homomorphism specified by , and some , compute a generating set for and find such that .
- •
Given and , compute a presentation for .
- •
Given and , compute a generating set for the centralizer of .
- •
The conjugacy problem: Given and , decide whether or not there exists such that and, if so, find such an element .
These problems are not only of interest in themselves, but also might serve as building blocks for solving the same problems in polycyclic groups – which are of particular interest because of their possible application in non-commutative cryptography [4]. In this work we follow [16] and extend these results in several ways:
- •
We give a complexity bound of uniform for all the above problems.
- •
In order to derive this bound, we show that the extended gcd problem (given , compute with ) with input and output in unary is in uniform .
- •
Our description of circuits is for the uniform setting where is part of the input (in [16] the uniform setting is also considered; however, only in some short remarks).
- •
Since nilpotent groups have polynomial growth, it is natural to allow compressed inputs: we give a uniform solution for the word problem allowing words with binary exponents as input – this contrasts with the situation with straight-line programs (i. e., context-free grammars which produces precisely one word – another method of exponential compression) as input: then the word problem is hard for [12]. Thus, the difficulty of the word problem with straight-line programs is not due to their compression but rather due to the difficulty of evaluating a straight-line program.
- •
We show that the other of the above problems are uniform--Turing-reducible to the (binary) extended gcd problem when the inputs (both the ambient group and the subgroup etc.) are given as words with binary exponents.
- •
We show how to solve the power problem in nilpotent groups. This allows us to apply a result from [19] in order to show that iterated wreath products of nilpotent groups have conjugacy problem in uniform .
Thus, in the unary case we settle the complexity of the above problems completely. Moreover, it also seems rather difficult to solve the subgroup membership problem without computing gcds – in this case our results on binary inputs would be also optimal. Altogether, our results mean that many algorithmic problems are no more complicated in nilpotent groups than in abelian groups. Notice that while in [16] explicit length bounds on the outputs for all these problems are proven, we obtain polynomial length bounds simply by the fact that everything can be computed in uniform (for which in the following we only write ).
Throughout the paper we follow the outline of [16]. For a concise presentation, we copy many definitions from [16]. Most of our theorems involve two statements: one for unary encoded inputs and one for binary encoded inputs. In order to have a concise presentation, we always put them in one result. We only consider finitely generated nilpotent groups without mentioning that further.
Outline.
We start with basic definitions on complexity as well as on nilpotent groups. In Section 3 we describe how subgroups of nilpotent groups can be represented and develop a “nice” presentation for all groups in . Section 4 deals with the word problem and computation of normal forms. After that we solve the unary extended gcd problem in and introduce the so-called matrix reduction in order to solve the subgroup membership problem. In Section 7 we present our result for the remaining of the above problems, in Section 8 we explain how to compute “nice” presentations, and in Section 9 we apply the results of [19] in order to show that the conjugacy problem of iterated wreath products of nilpotent groups is in . Finally, we conclude with some open questions.
2 Preliminaries
2.1 Complexity
For a finite alphabet , the set of words over is denoted by . Computation or decision problems are given by functions for some finite alphabets and . A decision problem ( formal language) is identified with its characteristic function with if, and only if, . (In particular, the word and conjugacy problems can be seen as functions .) We use circuit complexity as described in [26].
Circuit Classes.
The class is defined as the class of functions computed by families of circuits of constant depth and polynomial size with unbounded fan-in Boolean gates (and, or, not) and majority gates. A majority gate (denoted by ) returns if the number of s in its input is greater or equal to the number of [math]s. In the following we always assume that the alphabets and are encoded over the binary alphabet such that each letter uses the same number of bits. We say a function is -computable if .
In the following, we only consider -uniform circuit families and we simply write as shorthand for -uniform . -uniform means that there is a deterministic Turing machine which decides in time on input of two gate numbers (given in binary) and the string whether there is a wire between the two gates in the -input circuit and also computes of which type some gates is. Note that the binary encoding of the gate numbers requires only bits – thus, the Turing machine is allowed to use time linear in the length of the encodings of the gates. For more details on these definitions we refer to [26].
We have the following inclusions (note that even is not known to be strict):
[TABLE]
Reductions.
A function is -Turing-reducible to a function if there is a -uniform family of circuits computing which, in addition to the Boolean and majority gates, also may use oracle gates for (i. e., gates which on input output ). This is expressed by . Note that if are in , then .
In particular, if and are -computable functions, then also the composition is -computable. We will extensively make use of this observation – which will also guarantee the polynomial size bound on the outputs of our circuits without additional calculations.
We will also use another fact frequently without giving further reference: on input of two alphabets and (coded over the binary alphabet), a list of pairs with and such that each occurs in precisely one pair, and a word , the image under the homomorphism defined by can be computed in [13].
Encoding numbers: unary vs. binary.
There are essentially two ways of representing integer numbers: the usual way as a binary number where a string with represents , and as a unary number where is represented by (respectively by if is the number of input bits).
We will state most results in this paper with both representations. The unary representation corresponds to group elements given as words over the generators, whereas the binary encoding will be used if inputs are given in a compressed form.
Example 2.1*.*
The following problem is in : given a bit-string of length and a number (we assume that it is given in unary as ), decide whether the number of ones in is exactly . We have if, and only if, . Thus,
[TABLE]
In particular, the word problem of when is encoded as and as [math], which is simply the question whether and even, is in .
Arithmetic in .
Iterated Addition (resp. Iterated Multiplication) are the following computation problems: On input of binary integers each having bits (i. e., the input length is ), compute the binary representation of the sum (resp. product ). For Integer Division the input are two binary -bit integers ; the binary representation of the integer has to be computed. The first statement of Theorem 2.2 is a standard fact, see [26]; the other statements are due to Hesse, [8, 9].
Theorem 2.2* ([8, 9, 26]).*
The problems Iterated Addition, Iterated Multiplication, Integer Division are all in no matter whether inputs are given in unary or binary.
Note that if the numbers and are encoded in unary (as strings and ), division can be seen to be in very easily: just try for all whether .
Representing groups for algorithmic problems.
We consider finitely generated groups together with finite generating sets . Group elements are represented as words over the generators and their inverses (i. e., as elements of ). We make no distinction between words and the group elements they represent. Whenever it might be unclear whether we mean equality of words or of group elements, we write “ in ” for equality in .
Words over the generators of correspond to unary representation of integers. As a generalization of binary encoded integers, we introduce the following notion: a word with binary exponents is a sequence where the are from a fixed generating set of the group together with a sequence of exponents where the are encoded in binary. The word with binary exponents represents the word (or group element) . Note that in a fixed nilpotent group every word of length can be rewritten as a word with binary exponents using bits (this fact is well-known and also a consequence of Theorem 4.1 below); thus, words with binary exponents are a natural way of representing inputs for algorithmic problems in nilpotent groups.
2.2 Nilpotent groups and Mal’cev coordinates
Let be a group. For we write ( conjugated by ) and (commutator of and ). For subgroups , we have . A group is called nilpotent if it has central series, i.e.
[TABLE]
such that for all . If is finitely generated, so are the abelian quotients , . Let be a basis of , i.e. a generating set such that has a presentation , where (here stands for torsion) and (be aware that we explicitly allow , which is necessary for our definition of quotient presentations in Section 3). Formally put for . Note that
[TABLE]
is a so-called polycyclic generating sequence for , and we call a Mal’cev basis associated to the central series (1). Sometimes we use interchangeably also for the set .
For convenience, we will also use a simplified notation, in which the generators and exponents are renumbered by replacing each subscript with , so the generating sequence can be written as . We allow the expression to stand for in other notations as well. We also denote
[TABLE]
By the choice of , every element may be written uniquely in the form
[TABLE]
where and whenever . The -tuple is called the coordinate vector or Mal’cev coordinates of and is denoted , and the expression is called the (Mal’cev) normal form of . We also denote .
To a Mal’cev basis we associate a presentation of as follows. For each , let be such that . If , then , hence a relation
[TABLE]
holds in for and such that . Let . Since the series (1) is central, relations of the form
[TABLE]
hold in for and such that . Now, is the group with generators subject to the relation of the the form (2)–(4).
A presentation with relations of the form (2)–(4) for all resp. and is called a nilpotent presentation. Indeed, any presentation of this form will define a nilpotent group. It is called consistent if the order of modulo is precisely for all . While presentations of this form need not, in general, be consistent, those derived from a central series of a group as above are consistent.
Given a consistent nilpotent presentation, there is an easy way to solve the word problem: simply apply the rules of the form (3) and (4) to move all occurrences of in the input word to the left, then apply the power relations (2) to reduce their number modulo ; finally, continue with and so on.
Multiplication functions.
An crucial feature of the coordinate vectors for nilpotent groups is that the coordinates of a product may be computed as a “nice” function (polynomial if ) of the integers .
Lemma 2.3* ([7, 10]).*
Let be a nilpotent group with Mal’cev basis and . There exist and such that for with and and we have
- (i)
, 2. (ii)
, 3. (iii)
and .
Notice that an explicit algorithm to construct the polynomials is given in [14]. For further background on nilpotent groups we refer to [7, 10].
3 Presentation of subgroups
Before we start with algorithmic problems, we introduce a canonical way how to represent subgroups of nilpotent groups. This is important for two reasons: first, of course we need it to solve the subgroup membership problem, and, second, for the uniform setting it allows us to represent nilpotent groups as free nilpotent group modulo a kernel which is represented as a subgroup. Let be elements of given in normal form by , for , and let . We associate the matrix of coordinates
[TABLE]
to the tuple and conversely, to any integer matrix, we associate an -tuple of elements of , whose Mal’cev coordinates are given as the rows of the matrix, and the subgroup generated by the tuple. For each where row is non-zero, let be the column of the first non-zero entry (‘pivot’) in row . The sequence is said to be in standard form if the matrix of coordinates is in row-echelon form and its pivot columns are maximally reduced (similar to the Hermite normal form), more specifically, if satisfies the following properties:
- (i)
all rows of are non-zero (i.e. no is trivial), 2. (ii)
(where is the number of pivots), 3. (iii)
, for all , 4. (iv)
, for all 5. (v)
if , then divides , for .
The sequence (resp. matrix) is called full if in addition
- (vi)
is generated by , for all .
Note that consists of those elements having 0 in their first coordinates. It is an easy exercise (see also [16]) to show that (vi) holds for a given if, and only if,
- •
for all with , and are elements of , and
- •
for all with and , .
We will use full sequences and the associated matrices in full form interchangeably without mentioning it explicitly. For simplicity we assume that the inputs of algorithms are given as matrices. The importance of full sequences is described in the following lemma – a proof can be found in [25] Propositions 9.5.2 and 9.5.3.
Lemma 3.1* ([16, Lem. 3.1]).*
Let . There is a unique full sequence that generates . We have and H=\{h_{1}^{\beta_{1}}\cdots h_{s}^{\beta_{s}}\,|\,\beta_{i}\in\mathbb{Z}\mbox{ and 0\leq\beta_{i}<e_{\pi_{{i}}}\pi_{{i}}\in\mathcal{T}}\}.
Thus, computing a full sequence will be the essential tool for solving the subgroup membership problem. Before we focus on subgroup membership, we will first solve the word problem and introduce how the nilpotent group can be part of the input.
3.1 Quotient presentations
Let be fixed. The free nilpotent group of class and rank is defined as where , i. e., is the -generated group only subject to the relations that weight commutators are trivial. Throughout, we fix a Mal’cev basis (which we call the standard Mal’cev basis) associated to the lower central series of such that the associated nilpotent presentation consists only of relations of the form (3) and (4) (i. e., – such a presentation exists since is torsion-free), generates , and all other Mal’cev generators are iterated commutators of .
Denote by the set of -generated nilpotent groups of class at most . Every group is a quotient of the free nilpotent group , i. e., for some normal subgroup . Assume that is a full sequence generating . Adding to the set of relators of the free nilpotent group yields a new nilpotent presentation. This presentation will be called quotient presentation of . For inputs of algorithms, we assume that a quotient presentation is always given as its matrix of coordinates in full form. Depending whether the entries of the matrix are encoded in unary or binary, we call the quotient presentation be given in unary or binary.
Lemma 3.2* ([16, Prop. 5.1]).*
Let and be fixed integers and let be the standard Mal’cev basis of . Moreover, denote by the set of relators of with respect to . Let with and let be the full-form sequence for the subgroup of . Then, is a consistent nilpotent presentation of .
Proof 3.3*.*
Clearly, we have . Since is a nilpotent presentation and the elements of add relators of the form (2), the presentation is nilpotent. To prove that it is consistent, suppose some has order modulo in . Since the order is infinite in , there must be element of the form in . But then, by Lemma 3.1, must contain an element where divides . Hence cannot be smaller than and so the presentation is consistent.
For the following we always assume that a quotient presentation is part of the input, but and are fixed. Later, we will show how to compute quotient presentations from an arbitrary presentation.
Remark 3.4*.*
Lemma 3.2 ensures that each group element has a unique normal form with respect to the quotient presentation; thus, it guarantees that all our manipulations of Mal’cev coordinates are well-defined.
4 Word problem and computation of Mal’cev coordinates
In this section we deal with the word problem of nilpotent groups, which is well-known to be in [24]. Here, we generalize this result by allowing words with binary exponents (recall that word with binary exponents is a sequence where and the ). By using words with binary exponents the input can be compressed exponentially – making the word problem, a priori, harder to solve. Nevertheless, it turns out that the word problem still can be solved in when allowing the input to be given as a word with binary exponents. Note that this contrasts with the situation where the input is given as straight-line program (which like words with binary exponents allow an exponential compression) – then the word problem is complete for the counting class [12].
Theorem 4.1*.*
Let be fixed and let be the standard Mal’cev basis of . The following problem is -complete: on input of
- •
given as a binary encoded quotient presentation and
- •
a word with binary exponents ,
compute integers (in binary) such that in and for . Moreover, if the input is given in unary (both and ), then the output is in unary.
Note that the statement for unary inputs is essentially the one of [24]. Be aware that in the formulation of the theorem, and for depend on the input group . These parameters can be read from the full matrix of coordinates representing (recall that denotes the column index of the -th pivot and here is the number of rows of the matrix):
[TABLE]
(all columns which have a pivot) and if . As an immediate consequence of Theorem 4.1, we obtain:
Corollary 4.2*.*
Let be fixed. The uniform, binary version of the word problem for groups in is -complete (where the input is given as in Theorem 4.1).
The proof of Theorem 4.1 follows the outline given in Section 2.2; however, we cannot apply the rules (2)–(4) one by one. Instead we make only two steps for each generator: first apply all possible rules (3) and (4) in one step and then apply the rules (2) in one step.
Proof 4.3* (Proof of Theorem 4.1).*
The hardness part is clear since already the word problem of is -complete. For describing a circuit, we proceed by induction along the standard Mal’cev basis of the free nilpotent group . If does not contain any letter , we have and we can compute for by induction.
Otherwise, we rewrite as (with if ) such that and are words with binary exponents not containing any s. Once this is completed, can be rewritten as by induction. For computing , and , we proceed in two steps:
First, we rewrite as with (this is possible by Lemma 2.3 (iii)). The exponent can be computed by iterated addition, which by Theorem 2.2 is in (in the unary case can be written down in unary). Now, consists of what remains from after has been “eliminated”: for every position in with , we compute using iterated addition. Let . By Lemma 2.3 (i) there are fixed polynomials such that in the free nilpotent group holds
[TABLE]
Hence, in order to obtain , it remains to replace every with by the empty word and every with by , which is a word with binary exponents (resp. as a word of polynomial length in the unary case), for . The exponents can be computed in by Theorem 2.2. Since the are bounded by polynomials, in the unary case, can be written as a word without exponents.
The second step is only applied if (as explained above, this can be decided and can be read directly from the quotient presentation by checking whether there is a pivot in the first column) – otherwise and is the empty word. We rewrite to with and a word with binary exponents not containing any . Again can be computed in by Theorem 2.2. Let be the power relation for (which can be read from the quotient presentation – it is just the row where the pivot is in the first column) and write . Now, should be equal to in . We use the fixed polynomials from Lemma 2.3 (ii) for yielding
[TABLE]
(which, in the binary setting, is a word with binary exponents, and in the unary setting a word without exponents of polynomial length). Now, we have in as desired.
5 The extended gcd problem
Computing greatest common divisors and expressing them as a linear combination is an essential step for solving the subgroup membership problem. Indeed, consider the nilpotent group and let . Then if, and only if, .
Binary gcds.
The (binary) extended gcd problem (ExtGCD) is as follows: on input of binary encoded numbers , compute such that
[TABLE]
Clearly this can be done in using the Euclidean algorithm, but it is not known whether it is actually in . Since we need to compute greatest common divisors, we will reduce the subgroup membership problem to the computation of gcds.
Unary gcds.
Computing the of numbers encoded in unary is straightforward in by an exhaustive search; yet, it is not obvious how to express as in . By [17] such with can be computed in . However, that algorithm uses a logarithmic number of rounds each depending on the outcome of the previous one – so it does not work in . Note that for the problem is easy:
Example 5.1*.*
Let . Then, there are with such that . This is easy to see: assume (the other cases are similar) and we are given with and , then we can replace with and with . This does not change the sum and by iterating this step, we can assure that . Then we have ; hence, .
If and are given in unary, the coefficients can be computed in by simply checking all (polynomially many) values for and with .
However, if we want to express the of unboundedly many numbers as a linear combination, we cannot check all possible values for in because there are (i. e., exponentially) many. Expressing the gcd as a linear combination can be viewed as a linear equation with integral coefficients. Recently, in [5, Thm. 3.14] it has been shown that, if all the coefficients are given in unary, it can be decided in whether such an equation or a system of a fixed number of equations has a solution. Since from the proof of [5, Thm. 3.14] it is not obvious how to find an actual solution, we prove the following result:
Theorem 5.2*.*
The following problem is in : Given integers as unary numbers, compute (either in unary or binary) such that
[TABLE]
with .
Proof 5.3*.*
Let , which clearly can be computed in . W. l. o. g. we assume that all the are positive. We assume that all numbers which appear as intermediate results are encoded in binary (indeed, these numbers will grow too fast to encode them in unary).
First observe that can be computed in for all . The reason is simply that there are only linearly many numbers less than each . In fact, for computing , the circuit just checks for all whether for every there is some with . If for some there are such for all , we have found a common divisor. The is simply the largest one.
Thus, it remains to compute the coefficients . Since we can compute in , we can divide all numbers by the and henceforth assume that (note that this does not change the coefficients ).
The first step for computing the s, is to compute for and (note that by our assumption, ). We have
[TABLE]
Using this observation, the next step computes for each integers and such that . For all this can be done in parallel in by simply trying all possible values with as in Example 5.1. We set
[TABLE]
These can be computed in using iterated multiplication [8] – see Theorem 2.2. Moreover, an easy induction shows that
[TABLE]
There is only one problem with the numbers : in general, they do not meet the bounds . So, the next step will be to modify these in such a way that they meet the desired bound. The idea is to apply a sequence of operations as in Example 5.1 to make the coefficients small. The difficulty here is to find out where exactly to add/subtract a multiple of which .
Let and . Note that and w. l. o. g. we can assume that . For all , we set
[TABLE]
Obviously, we have for and for . The non-zero correspond to those indices which have a too large positive and the non-zero to those indices which have a too small negative (this is because we assumed the to be positive). Moreover, should be decreased (resp. increased) by (resp. ) in order to make it reasonably small. We will not be able to reach this aim completely, but with a sufficiently small error.
Next, we set and . All the , , , and and can be computed in using iterated addition and division – see Theorem 2.2.
Lemma 5.4*.*
[TABLE]
Proof 5.5*.*
For , we have by definition of . Likewise, we have for . Since and , we obtain
[TABLE]
meaning that . The same argument yields , and thus .
Let . For , we set
[TABLE]
and and for . Because of Lemma 5.4, we have . Clearly, the can be computed in and from now on we will work with these numbers. Also, as an immediate consequence of (6) and (7), we have
[TABLE]
Now, for and , we define
[TABLE]
Note that the cases overlap. However, then the different definitions of agree. For and , we set and for or we set .
Lemma 5.6*.*
We have and .
Proof 5.7*.*
We only show ; the other statement follows by symmetry. First, assume that for some . Then for all ; hence, the lemma holds. Now, let for any . We define
[TABLE]
In particular, we have for or . Notice that and exist for all (since ). Also because implies and ; thus, . Moreover, we have and and for . Since
[TABLE]
[TABLE]
we obtain
[TABLE]
We set for . Notice that, since , this means that
[TABLE]
Finally, we define our new coefficients as follows:
[TABLE]
It remains to show the following:
- (i)
the numbers can be computed in , 2. (ii)
, 3. (iii)
for all .
The first point is straightforward: we already remarked that the , , , and and can be computed in . Hence, also the can be computed in (as simple Boolean combination resp. addition of the previous numbers). Now, the can be computed using division [8]. Finally, the computation of the is simply another application of iterated addition.
For the second point observe that
[TABLE]
The last equality is due to the fact that for all and that if and are both in or both in .
For the third point, let . Then,
[TABLE]
The case is completely symmetric. This concludes the proof of Theorem 5.2.
Notice that it is straightforward to improve the bounds of Theorem 5.2 further (e. g. getting rid of the factor ). However, since there is no need for that in order to perform the matrix reduction, we do not do this additional effort. Also we could not find a circuit which yields the bound (which is achievable in by [17]).
6 Matrix reduction and subgroup membership problem
In [16], the so-called matrix reduction procedure converts an arbitrary matrix of coordinates into its full form and, thus, is an essential step for solving the subgroup membership problem and several other problems. It was first described in [25] – however, without a precise complexity estimate. In this section, we repeat the presentation from [16] and show that for fixed and , it can be actually computed uniformly for groups in in – in the case that the inputs are given in unary (as words). If the inputs are represented as words with binary exponents, then we still can show that it is -Turing-reducible to ExtGCD. In Section 3, we defined the matrix representation of subgroups of nilpotent groups. We adopt all notation from Section 3.
As before, let be fixed and let be the standard Mal’cev basis of . Let be given as quotient presentation, i. e., as a matrix in full form (either with unary or binary coefficients). We define the following operations on tuples (our subgroup generators) of elements of and the corresponding operations on the associated matrix, with the goal of converting to a sequence in full form generating the same subgroup :
- (1)
Swap with . This corresponds to swapping row with row . 2. (2)
Replace by (). This corresponds to replacing row by . 3. (3)
Add or remove a trivial element from the tuple. This corresponds to adding or removing a row of zeros; or (3’) a row of the form , where and . 4. (4)
Replace with . This corresponds to replacing row by . 5. (5)
Append an arbitrary product with and to the tuple: add a new row with .
Clearly, all these operations preserve .
Lemma 6.1*.*
On input of a quotient presentation of in unary (resp. binary) and a matrix of coordinates given in unary (resp. binary), operations (1)–(5) can be done in . The output matrix will be also encoded in unary (resp. binary). For operations (2) and (5), we require that the exponents , are given in unary (resp. binary).
Moreover, as long as the rows in the matrix which are changed are pairwise distinct, a polynomial number of such steps can be done in parallel in .
Proof 6.2*.*
Operations (1) and (3), clearly can be done in . Notice that operation (3’) means simply that a row of the quotient presentation of is appended to the matrix.
In the unary case, it follows directly from Theorem 4.1 that operations (2), (4), and (5) are in because, since , are given in unary, the respective group elements can be written down as words.
In the case of binary inputs, (5) works as follows ((2) and (4) analogously): by Lemma 2.3 (ii), there are functions such that for every with anda , we have in . These functions can be used to compute for . After that, can be written down as word with binary exponents and Theorem 4.1 can be applied.
Using the row operations defined above, in [16] it is shown how to reduce any coordinate matrix to its unique full form. Let us repeat these steps:
Let be a matrix of coordinates, as in (5) in Section 3. Recall that denotes the column index of the -th pivot (of the full form of ). We produce matrices , where is the number of pivots in the full form of , such that for every the first columns of form a matrix satisfying conditions (ii)-(v) of being a full sequence, condition (vi) is satisfied for all , and is the full form of . Here we formally denote . Set and assume that has been constructed for some . In the steps below we construct . We let and denote the number of rows and columns, respectively, of . At all times during the computation, denotes the group element corresponding to row of and denotes the -entry of , which is . These may change after every operation.
Step 1.
Locate the column of the next pivot, which is the minimum integer such that for at least one . If no such integer exists, then and is already constructed. Otherwise, set to be a copy of and denote . Compute a linear expression of
[TABLE]
Let and note that has coordinates of the form
[TABLE]
with occurring in position . Perform operation 5 to append as row of .
Step 2.
For each , perform operation 2 to replace row by and for each , use 2 to replace row by . After that, swap row with row using 1. At this point, properties (ii)-(iv) hold on the first columns of .
Step 3.
If , we additionally ensure condition (v) as follows. Perform row operation (3’), with respect to , to append a trivial element with to . Let and compute the linear expression , with . Let and append this row to , as row . Note that , with in position . Replace row by and row by , producing zeros in column in these rows. Swap row with row . At this point, (ii), (iii), and (v) hold (for the first columns) but (iv) need not, since the pivot entry is now instead of . For each , replace row by , ensuring (iv).
Step 4.
Identify the next pivot (like in Step 1). If is the last pivot, we set . We now ensure condition (vi) for . Observe that Steps 1-3 preserve for all . Hence (vi) holds in for since it holds in for the same range. Now consider in the range . It suffices to establish (vi.i) for all and (vi.ii) for only. To obtain (vi.i), notice that if, and only if, . Further, note that the subgroup generated by
[TABLE]
where appears times in the last commutator, is closed under commutation with since if appears more than times then the commutator is trivial. An inductive argument shows that the subgroup coincides with . Similar observations can be made for conjugation by . Therefore, appending via operation 5 rows for all and all delivers (vi.i) for all . Note that (vi.i) remains true for .
To obtain (vi.ii), in the case , we add row . Note that this element commutes with and therefore (vi.i) is preserved.
Step 5.
Using operation 3, eliminate all zero rows. The matrix is now constructed.
We have to show that each step can be performed in given that all Mal’cev coordinates are encoded in unary (resp. in if Mal’cev coordinates are encoded in binary). Since the total number of steps is constant (only depending on the nilpotency class and number of generators), this gives a (resp. ) circuit for computing the full form of a given subgroup.
Step 1.
The next pivot can be found in since it is simply the next column in the matrix with a non-zero entry, which can be found as a simple Boolean combination of test whether the entries are zero. In the unary case, by Theorem 5.2, can computed in together with encoded in unary such that . Now, by Lemma 6.1, Step 1 can be done in .
In the binary case, and can be computed using ExtGCD. Hence, by Lemma 6.1, Step 1 can be done in .
Step 2.
The numbers (either in unary or binary) can be computed in for all in parallel by Theorem 2.2. After that one operation (2) is applied to each row of the matrix. By Lemma 6.1, this can be done in parallel for all rows in . Finally, swapping rows and can be done in .
Step 3.
As explained in Section 4, and for can be read directly from the quotient presentation. Thus, it can be decided in whether Step 3 has to be executed. Appending a new row is in . Computing is in by Example 5.1 (in the unary case) and in in the binary case. After that one operation (5) is followed by two operations (2), one operation (1), and, finally, times operation (2), which all can be done in again by Lemma 6.1.
Step 4.
The next pivot can be found in as outlined in Step 1. After that, Step 4 consists of an application of a constant number (only depending on the nilpotency class and number of generators) of operations (5) and thus, by Lemma 6.1, is in .
Step 5.
Clearly that is in .
Thus, we have completed the proof of our main result:
Theorem 6.3*.*
Let be fixed. The following problem is in : given a unary encoded quotient presentation of and , compute the full form of the associated matrix of coordinates encoded in unary and hence the unique full-form sequence generating . Moreover, if the and are given in binary, then the full-form sequence with binary coefficients can be computed in .
6.1 Subgroup membership problem
We can now apply the matrix reduction algorithm to solve the subgroup membership problem in .
Theorem 6.4*.*
Let be fixed. The following problem is in (resp. for binary inputs): given a quotient presentation of , elements and , decide whether or not is an element of the subgroup .
Moreover, if , the circuit computes the unique expression where is the full-form sequence for with the encoded in unary (resp. binary).
Alternatively, for unary inputs, the output can be given as word where and .
Note that we do not know whether there is an analog of the second type of output for binary inputs. A possible way of expressing the output would be as a word with binary exponents over . However, simply applying the same procedure as for unary inputs will not lead to a word with binary exponents.
Proof 6.5*.*
The circuit works as follows: first, the the full form of the coordinate matrix corresponding to and the standard-form sequence are computed in (resp. ) using Theorem 6.3. As before, denote by the -entry of and by its pivots.
By Lemma 3.1, any element of can be written as . We show how to find these exponents. Denote and , with being defined below. For , do the following. If for any , then . Otherwise, check whether divides . If not, then . If yes, let
[TABLE]
If , continue to . If , then if and otherwise.
Since is bounded by a constant, there are only a constant number of steps. Each step can be done in by Theorem 2.2 (division) and Theorem 4.1 (computation of Mal’cev coordinates).
For the second type of output in the unary case, while performing the matrix reduction, we store for every row of the matrix also how that row can be expressed as a word over the subgroup generators (here, we need the unary inputs, as otherwise the group elements cannot be expressed as words in polynomial space). In every operation on the matrix these words are updated correspondingly, which clearly can be done in . In the end after writing , every can be substituted by the respective word.
Since abelian groups are nilpotent, we obtain:
Corollary 6.6*.*
Let be fixed. The following problem is in : Given a list and (all as words over the generators), decide whether . Moreover, in the case of a positive answer, compute in unary such that .
In other words: for fixed , given a unary encoded system of linear equations with and , a unary encoded solution with can be computed in .
6.2 Subgroup presentations
The full-form sequence associated to a subgroup forms a Mal’cev basis for . This allows us to compute a consistent nilpotent presentation for . Note, however, that the resulting presentation is not a quotient presentation (although it can be transformed into one, see Proposition 8.1) – partly this is due to the fact that, in general, . The following is the extended version of [16, Thm. 3.11]:
Theorem 6.7*.*
Let be fixed. The following is in for unary inputs and in for binary inputs:
Input: a quotient presentation for and elements .
Output: a consistent nilpotent presentation for given by a list of generators and numbers encoded in unary (resp. binary) for representing the relations (2)-(4).
Proof 6.8*.*
First, the full sequence for is computed in (resp. ) according to Theorem 6.3. Let . In the proof of [16, Thm. 3.11], it is shown that is a Mal’cev basis for . Hence, it remains to compute the relators (2)-(4) in order to give a consistent nilpotent presentation of . The order of modulo is simply (as before and for can be read from the quotient presentation). Each relation (2) can be computed using the (resp. ) circuit of Theorem 6.4 with input and . Since and is the unique full sequence for , the membership algorithm returns the expression on the right side of (2). Relations (3) and (4) are established using the same method. Note that there are only a constant number of relations to establish – so everything can be done in (resp. ).
7 More algorithmic problems
7.1 Homorphisms and kernels
Given nilpotent groups and and a subgroup and a generating set of , a homomorphism can be specified by a list of elements where for . For a homomorphism, we consider the problem of finding a generating set for its kernel, and given finding such that . Following [16], both problems are solved using matrix reduction in the group .
Theorem 7.1* (Kernels and preimages).*
Let be fixed. The following is in for unary inputs and in for binary inputs: On input of
- •
given as quotient presentations,
- •
a subgroup ,
- •
a list of elements defining a homomorphism via , and
- •
optionally, an element guaranteed to be in the image of ,
compute
- (i)
a generating set for the kernel of , and 2. (ii)
an element such that .
In case of unary inputs, and will be returned as words, and for binary inputs, as words with binary exponents.
Proof 7.2*.*
Let be the standard Mal’cev basis of and the standard Mal’cev basis of We have two embeddings of with and for . We can assume that the Mal’cev basis of is chosen in such a way that these embeddings send all Mal’cev generators of to Mal’cev generators of . Note that we have .
Thus, we can read all relators of and in via the embeddings and , respectively. To obtain a quotient presentation of , we simply need to add the relations that and commute – that is we need to introduce additional relations for all Mal’cev generators which are not in the image of or . As the new quotient presentation is basically a copy of those of and , it can be computed in . From now on we work only in the direct product and identify and with their images under and .
Let and let be the sequence in full form for the subgroup , where and . Let be the greatest integer such that (with if all are 1). Set and . In [16, Thm. 4.1] it is shown that is the full-form sequence for the kernel of and is the full-form sequence for the image.
Now, to solve (i), it suffices to compute using Theorem 6.3 and return the corresponding as defined above. For (ii), apply Theorem 6.4 to express as – then return .
7.2 Centralizers
Before we focus on the conjugacy problem, we need one more preliminary result: the problem of computing centralizers.
Theorem 7.3* (Centralizers).*
Let be fixed. The following is in for unary inputs and in for binary inputs:
On input of some given as quotient presentation and an element , compute a generating set for the centralizer of in (in case of binary inputs, the generating set will be given as set of words with binary exponents).
Proof 7.4*.*
Let be the lower central series of . Clearly this central series projects onto a central series of and we simply write for its projection in . Denote with the standard Mal’cev basis of , which is associated to the lower central series – in particular is a generating set for .
We proceed by induction on . If , then and are abelian and so the output is . Assume that the theorem holds for groups in – in particular, for (we obtain a quotient presentation of by simply forgetting about the Mal’cev generators in ). A generating set for the centralizer of in can be computed in (resp. ) by induction. Let
[TABLE]
where . Then is the preimage of under the homomorphism . Define by
[TABLE]
Since , commutes with modulo ; hence, and so . Moreover, is a homomorphism: we have
[TABLE]
and ; therefore, , and and commute, both being elements of the abelian group .
If commutes with , then , i. e., . Thus, the centralizer of is precisely the kernel of . A generating set can be computed in (resp. ) using Theorem 7.1.
7.3 The conjugacy problem
Now, we can combine the previous theorems to solve the conjugacy problem in following [16, Thm. 4.6].
Theorem 7.5* (Conjugacy Problem).*
Let be fixed. The following is in for unary inputs and in for binary inputs: On input of some given as quotient presentation and elements , either
- •
produce some such that , or
- •
determine that no such element exists.
In case of unary inputs, will be returned as a word, for binary inputs, as a word with binary exponents.
Proof 7.6*.*
Again we proceed by induction on . If , then is abelian and is conjugate to if and only if . If so, we return .
Now let us assume and that the theorem holds for any nilpotent group of class – in particular, for . We use the notation as in the proof of Theorem 7.3.
The first step of the circuit is to check conjugacy of and in which can be done in by induction. If these elements are not conjugate, then and are not conjugate and the overall answer is ‘No’. Otherwise, we obtain some such that .
Let be the canonical homomorphism, (where denotes the centralizer of ), and define by . As in the proof of Theorem 7.3, the image of is indeed in and is a homomorphism. We claim that and are conjugate if and only if . Indeed, if there exists such that , then
[TABLE]
hence , so as well. Then , as required. The converse is immediate. So it suffices to express, if possible, as with , in which case the conjugator is .
Now, the circuit computes a generating set for using Theorem 7.3. Then is generated by , where again . After that, is computed and Theorem 6.4 used to determine whether . If so, Theorem 7.1 is applied to find some such that . Finally, is returned in case all previous tests succeed. Since we only concatenate a fixed constant number of (resp. ) computations, the whole computation is in (resp. ) again.
Remark 7.7*.*
We want to outline briefly how in the unary case the bounds of [16, Thm. 4.6] can be used to directly solve the conjugacy problem of nilpotent groups in . Since [16, Thm. 4.6] is for a non-uniform setting, we fix a nilpotent group with generating set . Let be words over as inputs for the conjugacy problem with of total length . By [16, Thm. 4.6], the length of conjugators is polynomial in . By using binary exponents, the conjugators can be written with respect to a Mal’cev basis of using only bits for some constant which only depends on (this is a well-known fact – see e. g. [16, Thm. 2.3]). In particular, for all possible conjugators which have bit-length at most , it can be checked in parallel by a uniform family of circuits whether in by using the circuits for the word problem [24] (note that for this purpose each can be written down in unary since it is of length at most ).
8 Computing quotient presentations
The results in the previous sections always required that the group is given as a quotient presentation. However, we can use Theorem 6.3 to transform an arbitrary presentation with at most generators of a group in into a quotient presentation.
Proposition 8.1*.*
Let and be fixed integers. The following is in : given an arbitrary finite presentation with generators of a group (as a list of relators given as words over ), compute a quotient presentation of (encoded in unary) and an explicit isomorphism.
Moreover, if the relators are given as words with binary exponents, then the binary encoded quotient presentation can be computed in .
Proof 8.2*.*
Let and let be the set of relators, i. e., is presented as . Let be the free nilpotent group of class on generators . Let be the standard Mal’cev basis of such that for and let denote the set of relations such that is a consistent nilpotent presentation for .
Consider the natural surjection and let , which is the normal closure of in . Denoting , is generated by iterated commutators , where , , and . The total length of these generators is linear since and are constant. Using Theorem 6.3 in the group , we can produce the full-form sequence for in (resp. in for binary inputs).
Now and by Lemma 3.2 this is a (consistent) quotient presentation.
Remark 8.3*.*
Because of Proposition 8.1, in all theorems above where the input is a quotient presentation, we can also take an arbitrary -generated presentation of a group in as input. However, be aware that for the word problem (Theorem 4.1 and Corollary 4.2) the complexity changes from to in the binary case.
9 Power problem and conjugacy in wreath products of nilpotent groups
In [19], the conjugacy problem in iterated wreath products of abelian is shown to be in (for a definition of iterated wreath products we refer to [19]). The crucial step there is the transfer result that the conjugacy problem in a wreath product is -Turing-reducible to the conjugacy problems of and and the so-called power problem of .
The power problem of is defined as follows: on input of (as words over the generators) decide whether is a power of that is whether there is some such that in . In the “yes” case compute this in binary representation. If has finite order in , the computed has to be the smallest non-negative such .
By [19], also the power problem of is -Turing-reducible to the power problems of and given that torsion elements of have uniformly bounded order. The latter condition is also preserved by wreath products. Thus, in the light of [19], it remains to show that the power problem of nilpotent groups is in and that the order of torsion elements is uniformly bounded, in order to establish the following theorem (note that [19] is only for fixed groups; therefore, we formulate also the following results in a non-uniform setting):
Theorem 9.1*.*
Let and be finitely generated nilpotent groups and let , then the conjugacy problem of the -fold iterated wreath products as well as is in .
Proof 9.2*.*
The following two lemmas together with a repeated application of Theorem 3, Lemma 5, and Theorem 5 of [19].
Lemma 9.3*.*
Every finitely generated nilpotent group has a uniform bound on the order of torsion elements.
Proof 9.4*.*
We proceed by induction along a Mal’cev basis of . If has infinite order, we are done by induction. Otherwise, let be the order of and be such that for all torsion elements . Consider a torsion element . Then . Thus, . Therefore, is an upper bound on the order of torsion elements in .
Lemma 9.5*.*
For every finitely generated nilpotent group , the power problem of is in uniform .
Proof 9.6*.*
We show a slightly more general statement by induction along a Mal’cev basis of : for every fixed arithmetic progression , the power problem restricted to is in , i. e., given it can be decided in whether there is some with in and, if so, that can be computed in .
We consider the input words and in the quotient . Let and in this quotient. If , it remains to solve the power problem in the subgroup , which can be done by induction. Next, we distinguish the two cases that has infinite order and that it has finite order (in ).
In the case of infinite order, the only possible value for can be computed as (in by Theorem 2.2). If this is not an integer or not contained in the arithmetic progression (i. e., ), then is not a power of . Otherwise, one simply checks whether in (i. e., solving the word problem). As is bounded by the input length by Lemma 2.3, this can be done in by Theorem 4.1.
In the case of finite order, let denote the order of . It can be checked for all in parallel whether . In case that there is such an , the answer to the power problem is the same as the answer to the power problem in the subgroup restricted to the arithmetic progression (the intersection can be hard-wired since there are only finitely many possibilities for a fixed group since the modulo is bounded by the least common multiple of the orders of finite order elements of the Mal’cev basis) – if there is no such , the answer is “no”.
10 Conclusion and Open Problem
We have seen that most problems which in [16] were shown to be in indeed are in even in the uniform setting where the number of generators and nilpotency class is fixed. Moreover, their binary versions are in meaning that nilpotent groups are no more complicated than abelian groups in many algorithmic aspects. This contrasts with the slightly larger class of polycyclic groups: while the word problem is still in [24, 12], the conjugacy problem is not even known to be in . We conclude with some possible generalizations of our results:
Question 10.1*.*
Does a uniform version of Theorem 4.1 hold (i. e., is the uniform word problem still in ) for fixed nilpotency class but an arbitrary number of generators?
What happens to the complexity if also the nilpotency class is part of the input? Note that in that case it is even not clear whether the word problem is still in polynomial time.
Question 10.2*.*
Is there a way to solve the conjugacy problem for nilpotent groups with binary exponents in ? Notice that we needed to compute greatest common divisors for solving the subgroup membership problem. However, there might be a way of solving the conjugacy problem using another method.
Question 10.3*.*
What is the complexity of the uniform conjugacy problem when the nilpotency class is not fixed?
On the way for proving that the subgroup membership problem of nilpotent groups is in , we established that the extended gcd problem with unary inputs and outputs is in . However, the computed solution is not as small as the one computed by the algorithm from [17]:
Question 10.4*.*
Is the following problem in : given unary encoded numbers , compute with such that ?
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] N. Blackburn. Conjugacy in nilpotent groups. Proceedings of the American Mathematical Society , 16(1):143–148, 1965.
- 2[2] W. W. Boone. The Word Problem. Ann. of Math. , 70(2):207–265, 1959.
- 3[3] M. Dehn. Über unendliche diskontinuierliche Gruppen. Math. Ann. , 71(1):116–144, 1911.
- 4[4] B. Eick and D. Kahrobaei. Polycyclic groups: A new platform for cryptology? Ar Xiv Mathematics e-prints , 2004.
- 5[5] M. Elberfeld, A. Jakoby, and T. Tantau. Algorithmic meta theorems for circuit classes of constant and logarithmic depth. Electronic Colloquium on Computational Complexity (ECCC) , 18:128, 2011.
- 6[6] A. Garreta, A. Miasnikov, and D. Ovchinnikov. Properties of random nilpotent groups. Ar Xiv e-prints , Dec. 2016.
- 7[7] P. Hall. The Edmonton notes on nilpotent groups . Queen Mary College Mathematics Notes. Mathematics Department, Queen Mary College, London, 1969.
- 8[8] W. Hesse. Division is in uniform TC 0 . In F. Orejas, P. G. Spirakis, and J. van Leeuwen, editors, ICALP , volume 2076 of Lecture Notes in Computer Science , pages 104–114. Springer, 2001.
