arXiv subjects

Markus Lohrey

Publications and source records attributed to Markus Lohrey.

At least 19 recordsLinked to original sources

arXiv2026

Ranked MSO-enumeration over compressed words

It is shown that the ranked query enumeration problem for a fixed MSO-query on strings can be solved with linear preprocessing and constant delay in the grammar-compressed setting, where the input string is given by a so-called straight-line program, i.e., a context-free grammar that produces exactly one string. Moreover, `ranked' means that the output tuples of the MSO-query are printed in a specific order that has to be MSO-definable. This is the first result for ranked query enumeration on compressed data. A corollary of this result is that for a fixed polyregular function $f$ and a word $w$ that is given by a straight-line program of size $n$, one can list after preprocessing time $\mathcal{O}(n)$ the symbols in $f(w)$ from left to right with constant delay, which generalizes a result of Bojanczyk for the case where $w$ is uncompressed. The proofs for these results are based on factorization trees, which are made accessible to the grammar-compressed setting (a contribution of independent interest).

cs.DS↗

arXiv2025

On the complexity of computing Strahler numbers

It is shown that the problem of computing the Strahler number of a binary tree given as a term is complete for the circuit complexity class uniform $\mathsf{NC}^1$. For several variants, where the binary tree is given by a pointer structure or in a succinct form by a directed acyclic graph or a tree straight-line program, the complexity of computing the Strahler number is determined as well. We show that the problem of deciding whether a given context-free grammar in Chomsky normal form produces a derivation tree with a Strahler number of at least $k$ is $\mathsf{P}$-complete. If the derivation tree is restricted to be acyclic, the problem becomes $\mathsf{PSPACE}$-complete.

cs.CC↗

arXiv2025

FO-Query Enumeration over SLP-Compressed Structures of Bounded Degree

Enumerating the result set of a first-order query over a relational structure of bounded degree can be done with linear preprocessing and constant delay. In this work, we extend this result towards the compressed perspective where the structure is given in a potentially highly compressed form by a straight-line program (SLP). Our main result is an algorithm that enumerates the result set of a first-order query over a structure of bounded degree that is represented by an SLP satisfying the so-called apex condition. For a fixed formula, the enumeration algorithm has constant delay and needs a preprocessing time that is linear in the size of the SLP.

cs.LO↗

arXiv2025

Streaming algorithms for products of probabilities

We consider streaming algorithms for approximating a product of input probabilities up to multiplicative error of $1-\epsilon$. It is shown that every randomized streaming algorithm for this problem needs space $\Omega(\log n + \log b - \log \epsilon) - \mathcal{O}(1)$, where $n$ is length of the input stream and $b$ is the bit length of the input numbers. This matches an upper bound from Alur et al.~up to a constant multiplicative factor. Moreover, we consider the threshold problem, where it is asked whether the product of the input probabilities is below a given threshold. It is shown that every randomized streaming algorithm for this problem needs space $\Omega(n \cdot b)$.

cs.DS↗

arXiv2025

Finding cycle types in permutation groups with few generators

The problem whether a given permutation group contains a permutation with a given cycle type is studied. This problem is known to be NP-complete. In this paper it is shown that the problem can be solved in logspace for a cyclic permutation group and that it is NP-complete for a 2-generated abelian permutation group. In addition it is shown that it is NP-complete whether a 2-generated abelian permutation group contains a fixpoint-free permutation.

math.GR↗

arXiv2024

MSO-Enumeration Over SLP-Compressed Unranked Forests

We study the problem of enumerating the answers to a query formulated in monadic second order logic (MSO) over an unranked forest F that is compressed by a straight-line program (SLP) D. Our main result states that this can be done after O(|D|) preprocessing and with output-linear delay (in data complexity). This is a substantial improvement over the previously known algorithms for MSO-evaluation over trees, since the compressed size |D| might be much smaller than (or even logarithmic in) the actual data size |F|, and there are linear time SLP-compressors that yield very good compressions on practical inputs. In particular, this also constitutes a meta-theorem in the field of algorithmics on SLP-compressed inputs: all enumeration problems on trees or strings that can be formulated in MSO-logic can be solved with linear preprocessing and output-linear delay, even if the inputs are compressed by SLPs. We also show that our approach can support vertex relabelling updates in time that is logarithmic in the uncompressed data. Our result extends previous work on the enumeration of MSO-queries over uncompressed trees and on the enumeration of document spanners over compressed text documents.

cs.FL↗

arXiv2024

Regular Languages in the Sliding Window Model

We study the space complexity of the following problem: For a fixed regular language $L$, we receive a stream of symbols and want to test membership of a sliding window of size $n$ in $L$. For deterministic streaming algorithms we prove a trichotomy theorem, namely that the (optimal) space complexity is either constant, logarithmic or linear, measured in the window size $n$. Additionally, we provide natural language-theoretic characterizations of the space classes. We then extend the results to randomized streaming algorithms and we show that in this setting, the space complexity of any regular language is either constant, doubly logarithmic, logarithmic or linear. Finally, we introduce sliding window testers, which can distinguish whether a sliding window of size $n$ belongs to the language $L$ or has Hamming distance $> \epsilon n$ to $L$. We prove that every regular language has a deterministic (resp., randomized) sliding window tester that requires only logarithmic (resp., constant) space.

cs.FL↗

arXiv2023

Parameterized Complexity of Factorization Problems

We study the parameterized complexity of the following factorization problem: given elements $a,a_1, \ldots, a_m$ of a monoid and a parameter $k$, can $a$ be written as the product of at most (or exactly) $k$ elements from $a_1, \ldots, a_m$. Several new upper bounds and fpt-equivalences with more restricted problems (subset sum and knapsack) are shown. Finally, some new upper bounds for variants of the parameterized change-making problems are shown.

math.GR↗

arXiv2023

The Power Word Problem in Graph Products

The power word problem for a group $G$ asks whether an expression $u_1^{x_1} \cdots u_n^{x_n}$, where the $u_i$ are words over a finite set of generators of $G$ and the $x_i$ binary encoded integers, is equal to the identity of $G$. It 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$). We start by showing some easy results concerning the power word problem. In particular, the power word problem for a group $G$ is $NC^1$-many-one reducible to the power word problem for a finite-index subgroup of $G$. For our main result, we consider graph products of groups that do not have elements of order two. We show that the power word problem in a fixed such graph product is $AC^0$-Turing-reducible to the word problem for the free group $F_2$ and the power word problems of the base groups. Furthermore, we look into the uniform power word problem in a graph product, where the dependence graph and the base groups are part of the input. Given a class of finitely generated groups $\mathcal{C}$ without order two elements, the uniform power word problem in a graph product can be solved in $\mathsf{AC^0(C_=L^{UPowWP(\mathcal{C})})}$, where $UPowWP(\mathcal{C})$ denotes the uniform power word problem for groups from the class $\mathcal{C}$. As a consequence of our results, the uniform knapsack problem in right-angled Artin groups is NP-complete. The present paper is a combination of the two conference papers. In [StoberW22] and previous iterations of this paper our results on graph products were wrongly stated without the additional assumption that the base groups do not have elements of order two. In the present work we correct this mistake. While we strongly conjecture that the result as stated previously is true, our proof relies on this additional assumption.

math.GR↗

arXiv2022

Knapsack and the power word problem in solvable Baumslag-Solitar groups

We prove that the power word problem for certain metabelian subgroups of $\mathsf{GL}(2,\mathbb{C})$ (including the solvable Baumslag-Solitar groups $\mathsf{BS}(1,q) = \langle a,t \mid t a t^{-1} = a^q \rangle$) belongs to the circuit complexity class $\mathsf{TC}^0$. In the power word problem, the input consists of group elements $g_1, \ldots, g_d$ and binary encoded integers $n_1, \ldots, n_d$ and it is asked whether $g_1^{n_1} \cdots g_d^{n_d} = 1$ holds. Moreover, we prove that the knapsack problem for $\mathsf{BS}(1,q)$ is $\mathsf{NP}$-complete. In the knapsack problem, the input consists of group elements $g_1, \ldots, g_d,h$ and it is asked whether the equation $g_1^{x_1} \cdots g_d^{x_d} = h$ has a solution in $\mathbb{N}^d$. For the more general case of a system of so-called exponent equations, where the exponent variables $x_i$ can occur multiple times, we show that solvability is undecidable for $\mathsf{BS}(1,q)$.

math.GR↗

arXiv2022

Low-Latency Sliding Window Algorithms for Formal Languages

Low-latency sliding window algorithms for regular and context-free languages are studied, where latency refers to the worst-case time spent for a single window update or query. For every regular language $L$ it is shown that there exists a constant-latency solution that supports adding and removing symbols independently on both ends of the window (the so-called two-way variable-size model). We prove that this result extends to all visibly pushdown languages. For deterministic 1-counter languages we present a $\mathcal{O}(\log n)$ latency sliding window algorithm for the two-way variable-size model where $n$ refers to the window size. We complement these results with a conditional lower bound: there exists a fixed real-time deterministic context-free language $L$ such that, assuming the OMV (online matrix vector multiplication) conjecture, there is no sliding window algorithm for $L$ with latency $n^{1/2-ε}$ for any $ε>0$, even in the most restricted sliding window model (one-way fixed-size model). The above mentioned results all refer to the unit-cost RAM model with logarithmic word size. For regular languages we also present a refined picture using word sizes $\mathcal{O}(1)$, $\mathcal{O}(\log\log n)$, and $\mathcal{O}(\log n)$.

cs.FL↗

arXiv2022

Membership Problems in Finite Groups

We show that the subset sum problem, the knapsack problem and the rational subset membership problem for permutation groups are NP-complete. Concerning the knapsack problem we obtain NP-completeness for every fixed $n \geq 3$, where $n$ is the number of permutations in the knapsack equation. In other words: membership in products of three cyclic permutation groups is NP-complete. This sharpens a result of Luks, which states NP-completeness of the membership problem for products of three abelian permutation groups. We also consider the context-free membership problem in permutation groups and prove that it is PSPACE-complete but NP-complete for a restricted class of context-free grammars where acyclic derivation trees must have constant Horton-Strahler number. Our upper bounds hold for black box groups. The results for context-free membership problems in permutation groups yield new complexity bounds for various intersection non-emptiness problems for DFAs and a single context-free grammar.

math.GR↗

arXiv2022

Streaming algorithms for groups and semigroups

We investigate deterministic and randomized streaming algorithms for word problems in finitely generated groups and semigroups. For this we introduce the notion of a distinguisher: a randomized streaming algorithm that processes two input words in parallel and, with high probability, reaches identical memory states if the words represent the same element, and distinct states otherwise. We construct such distinguishers with low error probability using logarithmic, and in some cases doubly logarithmic, space. For example, our results apply to linear semigroups and to semigroups obtained (under suitable restrictions) via standard constructions such as graph products, wreath products, and semilattice decompositions. In case of commutative semigroups and cancellative nilpotent semigroups, we achieve space complexity $\mathcal{O}(\log \log n)$. We complement these upper bounds with lower bounds demonstrating that certain well-known semigroups do not admit sublinear-space distinguishers. This includes, for example, free inverse monoids of rank at least two and Thompson's group $F$. Finally, we study randomized streaming algorithms for subgroup membership problems in free groups and their direct products.

math.GR↗

arXiv2022

Exponent equations in HNN-extensions

We consider exponent equations in finitely generated groups. These are equations, where the variables appear as exponents of group elements and take values from the natural numbers. Solvability of such (systems of) equations has been intensively studied for various classes of groups in recent years. In many cases, it turns out that the set of all solutions on an exponent equation is a semilinear set that can be constructed effectively. Such groups are called knapsack semilinear. Examples of knapsack semilinear groups are hyperbolic groups, virtually special groups, co-context-free groups and free solvable groups. Moreover, knapsack semilinearity is preserved by many group theoretic constructions, e.g., finite extensions, graph products, wreath products, amalgamated free products with finite amalgamated subgroups, and HNN-extensions with finite associated subgroups. On the other hand, arbitrary HNN-extensions do not preserve knapsack semilinearity. In this paper, we consider the knapsack semilinearity of HNN-extensions, where the stable letter $t$ acts trivially by conjugation on the associated subgroup $A$ of the base group $G$. We show that under some additional technical conditions, knapsack semilinearity transfers from base group $G$ to the HNN-extension $H$. These additional technical conditions are satisfied in many cases, e.g., when $A$ is a centralizer in $G$ or $A$ is a quasiconvex subgroup of the hyperbolic group $G$.

math.GR↗

arXiv2021

Complexity of word problems for HNN-extensions

The computational complexity of the word problem in HNN-extension of groups is studied. HNN-extension is a fundamental construction in combinatorial group theory. It is shown that the word problem for an ascending HNN-extension of a group H is logspace reducible to the so-called compressed word problem for H. The main result of the paper states that the word problem for an HNN-extension of a hyperbolic group H with cyclic associated subgroups can be solved in polynomial time. This result can be easily extended to fundamental groups of graphs of groups with hyperbolic vertex groups and cyclic edge groups.

math.GR↗

arXiv2020

Balancing Straight-Line Programs

It is shown that a context-free grammar of size $m$ that produces a single string $w$ (such a grammar is also called a string straight-line program) can be transformed in linear time into a context-free grammar for $w$ of size $\mathcal{O}(m)$, whose unique derivation tree has depth $\mathcal{O}(\log |w|)$. This solves an open problem in the area of grammar-based compression. Similar results are shown for two formalism for grammar-based tree compression: top dags and forest straight-line programs. These balancing results are all deduced from a single meta theorem stating that the depth of an algebraic circuit over an algebra with a certain finite base property can be reduced to $\mathcal{O}(\log n)$ with the cost of a constant multiplicative size increase. Here, $n$ refers to the size of the unfolding (or unravelling) of the circuit.

cs.DS↗

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↗

arXiv2020

A Comparison of Empirical Tree Entropies

Whereas for strings, higher-order empirical entropy is the standard entropy measure, several different notions of empirical entropy for trees have been proposed in the past, notably label entropy, degree entropy, conditional versions of the latter two, and empirical entropy of trees (here, called label-shape entropy). In this paper, we carry out a systematic comparison of these entropy measures. We underpin our theoretical investigations by experimental results with real XML data.

cs.IT↗