arXiv subjects

Armin Weiß

Publications and source records attributed to Armin Weiß.

35 records · Page 2Linked to original sources

arXiv2020

Equation satisfiability in solvable groups

The study of the complexity of the equation satisfiability problem in finite groups had been initiated by Goldmann and Russell (2002) where they showed that this problem is in polynomial time for nilpotent groups while it is NP-complete for non-solvable groups. Since then, several results have appeared showing that the problem can be solved in polynomial time in certain solvable groups $G$ having a nilpotent normal subgroup $H$ with nilpotent factor $G/H$. This paper shows that such normal subgroup must exist in each finite group with equation satisfiability solvable in polynomial time, unless the Exponential Time Hypothesis fails.

cs.CC↗

arXiv2020

Groups with ALOGTIME-hard word problems and PSPACE-complete compressed word problems

We give lower bounds on the complexity of the word problem of certain non-solvable groups: for a large class of non-solvable infinite groups, including in particular free groups, Grigorchuk's group and Thompson's groups, we prove that their word problem is $\mathsf{NC}^1$-hard. For some of these groups (including Grigorchuk's group and Thompson's groups) we prove that the compressed word problem (which is equivalent to the circuit evaluation problem) is $\mathsf{PSPACE}$-complete.

math.GR↗

arXiv2019

On the Average Case of MergeInsertion

MergeInsertion, also known as the Ford-Johnson algorithm, is a sorting algorithm which, up to today, for many input sizes achieves the best known upper bound on the number of comparisons. Indeed, it gets extremely close to the information-theoretic lower bound. While the worst-case behavior is well understood, only little is known about the average case. This work takes a closer look at the average case behavior. In particular, we establish an upper bound of $n \log n - 1.4005n + o(n)$ comparisons. We also give an exact description of the probability distribution of the length of the chain a given element is inserted into and use it to approximate the average number of comparisons numerically. Moreover, we compute the exact average number of comparisons for $n$ up to 148. Furthermore, we experimentally explore the impact of different decision trees for binary insertion. To conclude, we conduct experiments showing that a slightly different insertion order leads to a better average case and we compare the algorithm to the recent combination with (1,2)-Insertionsort by Iwama and Teruyama.

cs.DS↗

arXiv2019

The power word problem

In this work we introduce a new succinct variant of the word problem in a finitely generated group $G$, which we call the power word problem: the input word may contain powers $p^x$, where $p$ is a finite word over generators of $G$ and $x$ is a binary encoded integer. The power word problem is a restriction of the compressed word problem, where the input word is represented by a straight-line program (i.e., an algebraic circuit over $G$). The main result of the paper states that the power word problem for a finitely generated free group $F$ is AC$^0$-Turing-reducible to the word problem for $F$. Moreover, the following hardness result is shown: For a wreath product $G \wr \mathbb{Z}$, where $G$ is either free of rank at least two or finite non-solvable, the power word problem is complete for coNP. This contrasts with the situation where $G$ is abelian: then the power word problem is shown to be in TC$^0$.

math.GR↗

arXiv2018

QuickXsort - A Fast Sorting Scheme in Theory and Practice

QuickXsort is a highly efficient in-place sequential sorting scheme that mixes Hoare's Quicksort algorithm with X, where X can be chosen from a wider range of other known sorting algorithms, like Heapsort, Insertionsort and Mergesort. Its major advantage is that QuickXsort can be in-place even if X is not. In this work we provide general transfer theorems expressing the number of comparisons of QuickXsort in terms of the number of comparisons of X. More specifically, if pivots are chosen as medians of (not too fast) growing size samples, the average number of comparisons of QuickXsort and X differ only by $o(n)$-terms. For median-of-$k$ pivot selection for some constant $k$, the difference is a linear term whose coefficient we compute precisely. For instance, median-of-three QuickMergesort uses at most $n \lg n - 0.8358n + O(\log n)$ comparisons. Furthermore, we examine the possibility of sorting base cases with some other algorithm using even less comparisons. By doing so the average-case number of comparisons can be reduced down to $n \lg n- 1.4106n + o(n)$ for a remaining gap of only $0.0321n$ comparisons to the known lower bound (while using only $O(\log n)$ additional space and $O(n \log n)$ time overall). Implementations of these sorting strategies show that the algorithms challenge well-established library implementations like Musser's Introsort.

cs.DS↗

arXiv2018

Worst-Case Efficient Sorting with QuickMergesort

The two most prominent solutions for the sorting problem are Quicksort and Mergesort. While Quicksort is very fast on average, Mergesort additionally gives worst-case guarantees, but needs extra space for a linear number of elements. Worst-case efficient in-place sorting, however, remains a challenge: the standard solution, Heapsort, suffers from a bad cache behavior and is also not overly fast for in-cache instances. In this work we present median-of-medians QuickMergesort (MoMQuickMergesort), a new variant of QuickMergesort, which combines Quicksort with Mergesort allowing the latter to be implemented in place. Our new variant applies the median-of-medians algorithm for selecting pivots in order to circumvent the quadratic worst case. Indeed, we show that it uses at most $n \log n + 1.6n$ comparisons for $n$ large enough. We experimentally confirm the theoretical estimates and show that the new algorithm outperforms Heapsort by far and is only around 10% slower than Introsort (std::sort implementation of stdlibc++), which has a rather poor guarantee for the worst case. We also simulate the worst case, which is only around 10% slower than the average case. In particular, the new algorithm is a natural candidate to replace Heapsort as a worst-case stopper in Introsort.

cs.DS↗

arXiv2018

QuickMergesort: Practically Efficient Constant-Factor Optimal Sorting

We consider the fundamental problem of internally sorting a sequence of $n$ elements. In its best theoretical setting QuickMergesort, a combination Quicksort with Mergesort with a Median-of-$\sqrt{n}$ pivot selection, requires at most $n \log n - 1.3999n + o(n)$ element comparisons on the average. The questions addressed in this paper is how to make this algorithm practical. As refined pivot selection usually adds much overhead, we show that the Median-of-3 pivot selection of QuickMergesort leads to at most $n \log n - 0{.}75n + o(n)$ element comparisons on average, while running fast on elementary data. The experiments show that QuickMergesort outperforms state-of-the-art library implementations, including C++'s Introsort and Java's Dual-Pivot Quicksort. Further trade-offs between a low running time and a low number of comparisons are studied. Moreover, we describe a practically efficient version with $n \log n + O(n)$ comparisons in the worst case.

cs.DS↗

arXiv2018

The isomorphism problem for finite extensions of free groups is in PSPACE

We present an algorithm for the following problem: given a context-free grammar for the word problem of a virtually free group $G$, compute a finite graph of groups $\mathcal{G}$ with finite vertex groups and fundamental group $G$. Our algorithm is non-deterministic and runs in doubly exponential time. It follows that the isomorphism problem of context-free groups can be solved in doubly exponential space. Moreover, if, instead of a grammar, a finite extension of a free group is given as input, the construction of the graph of groups is in NP and, consequently, the isomorphism problem in PSPACE.

math.GR↗

arXiv2017

The conjugacy problem in free solvable groups and wreath product of abelian groups is in TC$^0$

We show that the conjugacy problem in a wreath product $A \wr B$ is uniform-$\mathsf{TC}^0$-Turing-reducible to the conjugacy problem in the factors $A$ and $B$ and the power problem in $B$. If $B$ is torsion free, the power problem for $B$ can be replaced by the slightly weaker cyclic submonoid membership problem for $B$. Moreover, if $A$ is abelian, the cyclic subgroup membership problem suffices, which itself is uniform-$\mathsf{AC}^0$-many-one-reducible to the conjugacy problem in $A \wr B$. Furthermore, under certain natural conditions, we give a uniform $\mathsf{TC}^0$ Turing reduction from the power problem in $A \wr B$ to the power problems of $A$ and $B$. Together with our first result, this yields a uniform $\mathsf{TC}^0$ solution to the conjugacy problem in iterated wreath products of abelian groups - and, by the Magnus embedding, also in free solvable groups.

cs.CC↗

arXiv2017

TC^0 circuits for algorithmic problems in nilpotent groups

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 extended gcd problem.

math.GR↗

arXiv2016

BlockQuicksort: How Branch Mispredictions don't affect Quicksort

Since the work of Kaligosi and Sanders (2006), it is well-known that Quicksort -- which is commonly considered as one of the fastest in-place sorting algorithms -- suffers in an essential way from branch mispredictions. We present a novel approach to address this problem by partially decoupling control from data flow: in order to perform the partitioning, we split the input in blocks of constant size (we propose 128 data elements); then, all elements in one block are compared with the pivot and the outcomes of the comparisons are stored in a buffer. In a second pass, the respective elements are rearranged. By doing so, we avoid conditional branches based on outcomes of comparisons at all (except for the final Insertionsort). Moreover, we prove that for a static branch predictor the average total number of branch mispredictions is at most $εn \log n + O(n)$ for some small $ε$ depending on the block size when sorting $n$ elements. Our experimental results are promising: when sorting random integer data, we achieve an increase in speed of 80% over the GCC implementation of C++ std::sort. Also for many other types of data and non-random inputs, there is still a significant speedup over std::sort. Only in few special cases like sorted or almost sorted inputs, std::sort can beat out implementation. Moreover, even on random input permutations, our implementation is even slightly faster than an implementation of the highly tuned Super Scalar Sample Sort, which uses a linear amount of additional space.

cs.DS↗

arXiv2016

On the dimension of matrix embeddings of torsion-free nilpotent groups

Since the work of Jennings (1955), it is well-known that any finitely generated torsion-free nilpotent group can be embedded into unitriangular integer matrices $UT_N(Z)$ for some $N$. In 2006, Nickel proposed an algorithm to calculate such embeddings. In this work, we show that if $UT_n(Z)$ is embedded into $UT_N(Z)$ using Nickel's algorithm, then $N \geq 2^{n/2 -2}$ if the standard ordering of the Mal'cev basis (as in Nickel's original paper) is used. In particular, we establish an exponential worst-case running time of Nickel's algorithm. On the other hand, we also prove a general exponential upper bound on the dimension of the embedding by showing that for any torsion free, finitely generated nilpotent group the matrix representation produced by Nickel's algorithm has never larger dimension than Jennings' embedding. Moreover, when starting with a special Mal'cev basis, Nickel's embedding for $UT_n(Z)$ has only quadratic size. Finally, we consider some special cases like free nilpotent groups and Heisenberg groups and compare the sizes of the embeddings.

math.GR↗

arXiv2016

Amenability of Schreier graphs and strongly generic algorithms for the conjugacy problem

In various occasions the conjugacy problem in finitely generated amalgamated products and HNN extensions can be decided efficiently for elements which cannot be conjugated into the base groups. This observation asks for a bound on how many such elements there are. Such bounds can be derived using the theory of amenable graphs: In this work we examine Schreier graphs of amalgamated products and HNN extensions. For an amalgamated product $G = H *_A K $ with $[H:A] \geq [K:A] \geq 2$, the Schreier graph with respect to $H$ or $K$ turns out to be non-amenable if and only if $[H:A] \geq 3$. Moreover, for an HNN extension of the form $G = $, we show that the Schreier graph of $G$ with respect to the subgroup $H$ is non-amenable if and only if $A \neq H \neq ϕ(A)$. As application of these characterizations we show that under certain conditions the conjugacy problem in fundamental groups of finite graphs of groups with free abelian vertex groups can be solved in polynomial time on a strongly generic set. Furthermore, the conjugacy problem in groups with more than one end can be solved with a strongly generic algorithm which has essentially the same time complexity as the word problem. These are rather striking results as the word problem might be easy, but the conjugacy problem might be even undecidable. Finally, our results yield another proof that the set where the conjugacy problem of the Baumslag group is decidable in polynomial time is also strongly generic.

math.GR↗

arXiv2016

A Logspace Solution to the Word and Conjugacy problem of Generalized Baumslag-Solitar Groups

Baumslag-Solitar groups were introduced in 1962 by Baumslag and Solitar as examples for finitely presented non-Hopfian two-generator groups. Since then, they served as examples for a wide range of purposes. As Baumslag-Solitar groups are HNN extensions, there is a natural generalization in terms of graph of groups. Concerning algorithmic aspects of generalized Baumslag-Solitar groups, several decidability results are known. Indeed, a straightforward application of standard algorithms leads to a polynomial time solution of the word problem (the question whether some word over the generators represents the identity of the group). The conjugacy problem (the question whether two given words represent conjugate group elements) is more complicated; still decidability has been established by Anshel and Stebe for ordinary Baumslag-Solitar groups and for generalized Baumslag-Solitar groups independently by Lockhart and Beeker. However, up to now no precise complexity estimates have been given. In this work, we give a LOGSPACE algorithm for both problems. More precisely, we describe a uniform TC^0 many-one reduction of the word problem to the word problem of the free group. Then we refine the known techniques for the conjugacy problem and show that it can be solved in LOGSPACE. Moreover, for ordinary Baumslag-Solitar groups also conjugacy is AC^0-Turing-reducible to the word problem of the free group. Finally, we consider uniform versions (where also the graph of groups is part of the input) of both word and conjugacy problem: while the word problem still is solvable in LOGSPACE, the conjugacy problem becomes EXPSPACE-complete.

cs.CC↗

arXiv2013

Conjugacy in Baumslag's group, generic case complexity, and division in power circuits

The conjugacy problem belongs to algorithmic group theory. It is the following question: given two words x, y over generators of a fixed group G, decide whether x and y are conjugated, i.e., whether there exists some z such that zxz^{-1} = y in G. The conjugacy problem is more difficult than the word problem, in general. We investigate the complexity of the conjugacy problem for two prominent groups: the Baumslag-Solitar group BS(1,2) and the Baumslag(-Gersten) group G(1,2). The conjugacy problem in BS(1,2) is TC^0-complete. To the best of our knowledge BS(1,2) is the first natural infinite non-commutative group where such a precise and low complexity is shown. The Baumslag group G(1,2) is an HNN-extension of BS(1,2). We show that the conjugacy problem is decidable (which has been known before); but our results go far beyond decidability. In particular, we are able to show that conjugacy in G(1,2) can be solved in polynomial time in a strongly generic setting. This means that essentially for all inputs conjugacy in G(1,2) can be decided efficiently. In contrast, we show that under a plausible assumption the average case complexity of the same problem is non-elementary. Moreover, we provide a lower bound for the conjugacy problem in G(1,2) by reducing the division problem in power circuits to the conjugacy problem in G(1,2). The complexity of the division problem in power circuits is an open and interesting problem in integer arithmetic.

cs.DM↗

arXiv2013

QuickXsort: Efficient Sorting with n log n - 1.399n +o(n) Comparisons on Average

In this paper we generalize the idea of QuickHeapsort leading to the notion of QuickXsort. Given some external sorting algorithm X, QuickXsort yields an internal sorting algorithm if X satisfies certain natural conditions. With QuickWeakHeapsort and QuickMergesort we present two examples for the QuickXsort-construction. Both are efficient algorithms that incur approximately n log n - 1.26n +o(n) comparisons on the average. A worst case of n log n + O(n) comparisons can be achieved without significantly affecting the average case. Furthermore, we describe an implementation of MergeInsertion for small n. Taking MergeInsertion as a base case for QuickMergesort, we establish a worst-case efficient sorting algorithm calling for n log n - 1.3999n + o(n) comparisons on average. QuickMergesort with constant size base cases shows the best performance on practical inputs: when sorting integers it is slower by only 15% to STL-Introsort.

cs.DS↗

arXiv2012

Context-Free Groups and Their Structure Trees

Let Gamma be a connected, locally finite graph of finite tree width and G be a group acting on it with finitely many orbits and finite node stabilizers. We provide an elementary and direct construction of a tree T on which G acts with finitely many orbits and finite vertex stabilizers. Moreover, the tree is defined directly in terms of the structure tree of optimally nested cuts of Gamma. Once the tree is constructed, standard Bass-Serre theory yields that G is virtually free. This approach simplifies the existing proofs for the fundamental result of Muller and Schupp that characterizes context-free groups as f.g. virtually free groups. Our construction avoids the explicit use of Stallings' structure theorem and it is self-contained. We also give a simplified proof for an important consequence of the structure tree theory by Dicks and Dunwoody which has been stated by Thomassen and Woess. It says that a f.g. group is accessible if and only if its Cayley graph is accessible.

math.GR↗