Twisted conjugacy in dihedral Artin groups I: Torus Knot groups

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

There is an important class of finitely presented groups known as automatic groups, in which many computations can be undertaken efficiently. In particular, there is a normal form for group elements which is the language of a finite state automation, and arbitrary words in the group generators can be reduced to normal form in quadratic time. The normal form can also be used to enumerate group elements, and to compute the (rational) growth function of the group. The theory of automatic groups is developed [2], and the algorithms are described in more detail in [4]. Implementations of the algorithms are available in a software package of the author ([3]).The word-hyperbolic groups form an important subclass of the automatic groups. They are defined by the property that geodesic triangles in the Cayley graph of the group are uniformly thin. In other words, there is a constant e, such a that any point on one of the sides of such a triangle is within distance e of the union of the other two sides of the triangle. Small cancellation groups and groups acting discretely and cocompactly on hyperbolic space are examples of word-hyperbolic groups. Their theory is developed in [1].The word problem in a word-hyperbolic group can be solved by a Dehn algorithm in linear time. Furthermore, Epstein has shown that the conjugacy problem can be solved in time O(n ln n). However, both of these algorithms require a prior knowledge of the constant e, and it does not seem to be easy to compute this constant in general.In practice, the quadratic time algorithm for the word problem coming from the automatic groups procedures performs very effectively, and it would be useful to have alternatives for the conjugacy problem.The automatic groups machinery does provide such an algorithm (which works in the the intermediate class of biautomatic groups), but that unfortunately is exponential.Alternative algorithms for conjugacy testing of elements and subgroups are currently being developed and implemented by a research student of mine, Joe Marshall. They have the minor disadvanatage that their basic versions work only in torsion-free groups, but adaptations to the more general case seem possible. They include also a test for malnormality of a subgroup H of G, which means that g-1Hg∩H = 1 for all g ∈ G\H. This test is important in topological applications.They make essential use of the boundary of the group. The points on the boundary can be defined as the equivalence classes of infinite geodesic rays starting from the base point of the Cayley graph, where two such rays are equivalent if they remain a bounded distance apart. The precise bound involved here turns out to be another universal constant d of the Cayley graph, but unlike e it can be computed in practice relatively easily. Roughly speaking, a certain linear function of d provides us with a bound on the length of the elements g that we need to consider as possible conjugating elements when testing for conjugacy or malnormality. To make the algorithm practical, we need to restrict this set of potential conjugators considerably more than this, and Marshall has come up with various tricks for doing this.

G. Burde proved (1990) that the $\mathrm {SU}$ representation space of two-bridge knot groups is one-dimensional. The same holds for all torus knot groups. The aim of this note is to prove the following: Given a knot $k \subset S^3$ we denote by $\hat {C}_2$ its twofold branched covering space. Assume that there is a prime number $p$ such that $H_1(\hat {C}_2,\mathbb {Z}_p)\cong \mathbb {Z}_p$. Then there exist representations of the knot group onto the binary dihedral group $D_p \subset \mathrm {SU}$ and these representations are smooth points on a one-dimensional curve of representations into $\mathrm {SU}$.

Decision problems and profinite completions of groups

We discuss time complexity of the Conjugacy Problem in HNN-extensions of groups, in particular, in Miller's groups. We show that for "almost all", in some explicit sense, elements, the Conjugacy Problem is decidable in cubic time. It is worth noting that the Conjugacy Problem in a Miller group may be undecidable. Our results show that "hard" instances of the problem comprise a negligibly small part of the group.

For each odd prime p, and for each non-split link admitting non-trivial p-colorings, we prove that the maximum number of colors, mod p, is p. We also prove that we can assemble a non-trivial p-coloring with any number of colors, from the minimum to the maximum number of colors. Furthermore, for any rational link, we prove that there exists a non-trivial coloring of any Schubert Normal Form (SNF) of it, modulo its determinant, which uses all colors available. If this determinant is an odd prime, then any non-trivial coloring of this SNF, modulo the determinant, uses all available colors. We prove also that the number of crossings in the SNF equals twice the determinant of the link minus 2. Facts about torus links and their coloring abilities are also proved.

This paper presents a special purpose dual linear programming algorithm to solve a linear least absolute value multiple linear regression problem. Various computer implementations of the fundamental algorithm are discussed and compared with existing special-purpose procedures to solve the least absolute value problem. Computational results with four implementations of the algorithm are given.

A new class of groups C, containing all coherent RAAGs and all toral relatively hyperbolic groups, is defined. It is shown that, for a group G in the class C, the Z[t]-exponential group GZ[t] may be constructed as an iterated centraliser extension. Using this fact, it is proved that GZ[t] is fully residually G (i.e. it has the same universal theory as G) and so its finitely generated subgroups are limit groups over G. If G is a coherent RAAG, then the converse also holds - any limit group over G embeds into GZ[t]. Moreover, it is proved that limit groups over G are finitely presented, coherent and CAT(0), so in particular have solvable word and conjugacy problems.

For finitely generated nilpotent groups, we employ Mal’cev coordinates to solve several classical algorithmic problems efficiently. Computation of normal forms, the membership problem, the conjugacy problem, and computation of presentations for subgroups are solved using only logarithmic space and quasilinear time. Logarithmic space presentation-uniform versions of these algorithms are provided. Compressed-word versions of the same problems, in which each input word is provided as a straight-line program, are solved in polynomial time.

Peter Lackner’s practice features an innovative approach to the systematisation of twelve-tone rows. In the second section of this chapter together with Harald Fripertinger a complete classification of tone rows in the twelve-tone scale is described, which is based on the notion of group actions. The main objects in this project are the orbits of tone rows under the action of the direct product of two dihedral groups. This means that tone rows are considered to be equivalent if and only if they can be constructed by transposing, inversion, retrograde, and/or time shift (rotation) from a single row. We determine the orbit, the normal form, the stabilizer class of a tone row, or its trope structure.

The analysis of many processes modeled by directed graphs requires the selection of a subset of vertices which cut all the cycles in the graph. Reducing the size of such a cutset usually leads to a simpler and more efficient analysis, but the problem of finding minimum cutsets in general directed graphs is known to be $NP$-complete. In this paper we show that in reducible graphs (and thus in almost all the “practical” flowcharts of programs), minimum cutsets can be found in linear time. We further show that the linear algorithm can check its own applicability to a given graph, thus eliminating the need of prechecking (in nonlinear time) whether it is reducible or not. An immediate application of this result is in program verification systems based on Floyd’s inductive assertions method.

The single-source shortest paths problem (SSSP) is one of the classic problems in algorithmic graph theory: given a positively weighted graph G with a source vertex s , find the shortest path from s to all other vertices in the graph. Since 1959, all theoretical developments in SSSP for general directed and undirected graphs have been based on Dijkstra's algorithm, visiting the vertices in order of increasing distance from s . Thus, any implementation of Dijkstra's algorithm sorts the vertices according to their distances from s . However, we do not know how to sort in linear time. Here, a deterministic linear time and linear space algorithm is presented for the undirected single source shortest paths problem with positive integer weights. The algorithm avoids the sorting bottleneck by building a hierarchical bucketing structure, identifying vertex pairs that may be visited in any order.

Finite state automata are of fundamental importance in theory as well as applications in computer science. This dissertation presents several parallel algorithms for processing of them, including minimizing the number of states for a given finite state automaton, finding homing sequences for a given finite state automaton, converting a regular expression into an $\\varepsilon$-free nondeterministic finite automaton. Implementation of some algorithms, as well as their experimental results, are also given. For minimization of deterministic finite automata, we present a parallel algorithm and discuss its implementation on a practical parallel machine using data parallel and message passing paradigms. Its time complexity on a p processor EREW PRAM $(p\\le n)$ for inputs of size n is $O({n\\log\\sp2n\\over p}+\\log n\\ \\log p)$ uniformly on almost all instances. The work done by our algorithm is thus within a factor of $O(\\log n)$ of the best known sequential algorithm. The space used by our algorithm is linear in the input size. The actual resource requirements of our implementations are consistent with these estimates. For finding homing sequences of deterministic finite automata, we present both deterministic and randomized algorithms. Two randomized algorithms of time complexity $O(log\\sp2n)$ are given. One of the randomized algorithms produces a homing sequence of length $O(n\\ log\\sp2n)$ for almost all DFA's with n states. The deterministic algorithm is based on a well known sequential algorithm. The implementation of the deterministic parallel algorithm shows that it can handle randomly generated instances with millions of states, and all DFA's with thousands of states using currently available parallel machines. Finally, we present an efficient parallel algorithm for converting a regular expression into an $\\varepsilon$-free nondeterministic finite automaton. The resulting automaton is natural representation of a regular expression and has some important and practical uses in the document processing area. The time complexity of the algorithm is $O(\\log n)$ and the number of processors used is $O(n\\sp2).$

Planarity, bipartiteness and (directed) acyclicity are basic graph properties with classic linear time recognition algorithms. However, the problems of testing whether a given (di)graph has k vertices whose deletion makes it planar, bipartite or a directed acyclic graph (DAG) are all fundamental NP-complete problems when k is part of the input. As a result, a significant amount of research has been devoted to understanding whether, for every fixed k, these problems admit a polynomial time algorithm (where the exponent in the polynomial is independent of k) and in particular, whether they admit linear time algorithms. While we now know that for any fixed k, we can test in linear time whether a graph is k vertices away from being planar [FOCS 2009, SODA 2014] or bipartite [SODA 2014, SICOMP 2016], the best known algorithms in the case of directed acyclicity are the algorithm of Garey and Tarjan [IPL 78] which runs in time O(nk–1m) and the algorithm of Chen, Liu, Lu, O'Sullivan and Razgon [JACM 2008] which runs in time O(k!4kk4nm). In other words, it has remained open whether it is possible to recognize in linear time, a graph which is 2 vertices away from being acyclic! In this paper, we settle this question by giving an algorithm that decides whether a given graph is k vertices away from being acyclic, in time O(k!4kk5(n + m)). That is, for every fixed k, our algorithm runs in time O(m + n), thus mirroring the case for planarity and bipartiteness. Our algorithm is designed via a general methodology that shaves off a factor of n from some algorithms that use the powerful technique of iterative compression. The two main features of our methodology are: (i) This is the first generic technique for designing linear time algorithms for directed cut-problems and (ii) it can be used in combination with future improvements in algorithms for the compression version of other well-studied cut-problems such as Multicut and Directed Subset Feedback Vertex Set.

We present observations on the linear programming algorithm proposed independently by Oliker and by Wang to design a single reflector for a point source and a far-field target. Given a set of source rays and discretized target intensities, the linear programming algorithm solves a variational problem to produce a reflector solution that consists of paraboloid patches. The computational complexity increases quadratically with the number of source rays and targets; this makes it important to minimize the number of source rays. However, minimizing the number of source rays results in solutions where the source rays at the intersection between neighboring patches split between multiple targets. This is unlike other discretized target reflector design methods, such as the Oliker supporting ellipsoid algorithm, that are used to aim numerous rays per ellipsoid at only one target. We uncovered a relationship between the optimal numbers of source rays and targets needed to run the problem. This relationship makes it possible to limit the number of source rays used in the design to the order of the number of target points. In this paper, we highlight the main features and current limitations of the linear programming algorithm. Finally, we propose a fast algorithm for 2D reflector design inspired by the intersection property of the linear programming method. The direct calculation method is shown to be several orders of magnitude faster than the linear programming method.