Polynomial-space Algorithm Research Articles

Countdown games, and simulation on (succinct) one-counter nets

We answer an open complexity question by Hofman, Lasota, Mayr, Totzke (LMCS 2016) for simulation preorder on the class of succinct one-counter nets (i.e., one-counter automata with no zero tests where counter increments and decrements are integers written in binary); the problem was known to be PSPACE-hard and in EXPSPACE. We show that all relations between bisimulation equivalence and simulation preorder are EXPSPACE-hard for these nets; simulation preorder is thus EXPSPACE-complete. The result is proven by a reduction from reachability games whose EXPSPACE-completeness in the case of succinct one-counter nets was shown by Hunter (RP 2015), by using other results. We also provide a direct self-contained EXPSPACE-completeness proof for a special case of such reachability games, namely for a modification of countdown games that were shown EXPTIME-complete by Jurdzinski, Sproston, Laroussinie (LMCS 2008); in our modification the initial counter value is not given but is freely chosen by the first player. We also present an alternative proof for the upper bound by Hofman et al. In particular, we give a new simplified proof of the belt theorem that yields a simple graphic presentation of simulation preorder on (non-succinct) one-counter nets and leads to a polynomial-space algorithm (which is trivially extended to an exponential-space algorithm for succinct one-counter nets).

Faster Graph Coloring in Polynomial Space

We present a polynomial-space algorithm that computes the number of independent sets of any input graph in time O(1.1389^n) for graphs with maximum degree 3 and in time O(1.2356^n) for general graphs, where n is the number of vertices in the input graph. Together with the inclusion-exclusion approach of Björklund, Husfeldt, and Koivisto [SIAM J. Comput. 2009], this leads to a faster polynomial-space algorithm for the graph coloring problem with running time O(2.2356^n) as well as an exponential-space O(1.2330^n) time algorithm for counting independent sets. Our main algorithm counts independent sets in graphs with maximum degree at most 3 and no vertex with three neighbors of degree 3. This polynomial-space algorithm is designed and analyzed using the recently introduced Separate, Measure and Conquer approach [Gaspers & Sorkin, ICALP 2015]. Using Wahlström’s compound measure approach, this improvement in running time for small degree graphs is then bootstrapped to larger degrees, giving the improvement for general graphs. Combining both approaches leads to some inflexibility in choosing vertices to branch on for the small-degree cases, which we counter by structural graph properties.

Finding Optimal Triangulations Parameterized by Edge Clique Cover

We consider problems that can be formulated as a task of finding an optimal triangulation of a graph w.r.t. some notion of optimality. We present algorithms parameterized by the size of a minimum edge clique cover (texttt {cc}) to such problems. This parameterization occurs naturally in many problems in this setting, e.g., in the perfect phylogeny problem texttt {cc} is at most the number of taxa, in fractional hypertreewidth texttt {cc} is at most the number of hyperedges, and in treewidth of Bayesian networks texttt {cc} is at most the number of non-root nodes. We show that the number of minimal separators of graphs is at most 2^texttt {cc}, the number of potential maximal cliques is at most 3^texttt {cc}, and these objects can be listed in times O^*(2^texttt {cc}) and O^*(3^texttt {cc}), respectively, even when no edge clique cover is given as input; the O^*(cdot ) notation omits factors polynomial in the input size. These enumeration algorithms imply O^*(3^texttt {cc}) time algorithms for problems such as treewidth, weighted minimum fill-in, and feedback vertex set. For generalized and fractional hypertreewidth we give O^*(4^m) time and O^*(3^m) time algorithms, respectively, where m is the number of hyperedges. When an edge clique cover of size texttt {cc}' is given as a part of the input we give O^*(2^{texttt {cc}'}) time algorithms for treewidth, minimum fill-in, and chordal sandwich. This implies an O^*(2^n) time algorithm for perfect phylogeny, where n is the number of taxa. We also give polynomial space algorithms with time complexities O^*(9^{texttt {cc}'}) and O^*(9^{texttt {cc}+ O(log ^2 texttt {cc})}) for problems in this framework.

Bisimilarity on Basic Parallel Processes

The main aim of this paper is to give a simple transparent proof of the result showing that the problem of bisimulation equivalence on the class of Basic Parallel Processes (BPP), denoted by BPP-Bisim, can be decided by a polynomial-space algorithm. This result (by the author) has been previously only presented in a conference version, in a rather technical form that is not easily readable and verifiable. Since the result has clarified the complexity of the problem BPP-Bisim, namely its PSPACE-completeness (using the lower bound by Srba), and the problem deals with a fundamental behavioural equivalence and with one of the simplest models that naturally extend finite-state systems into infinite-state ones, it seems appropriate to have a transparent version of the proof.

Many-visits TSP revisited

We study the Many-Visits Traveling Salesman Problem, where given a number k(v) for each of n cities and pairwise (possibly asymmetric) integer distances, one has to find an optimal tour that visits each city v exactly k(v) times. The currently fastest algorithm is due to Berger, Kozma, Mnich and Vincze [SODA 2019, TALG 2020] and runs in time and space O⁎(5n). They also show a polynomial-space algorithm running in time O(16n+o(n)). In this work, we show three main results:•A randomized polynomial-space algorithm running in time O⁎(2nD), where D is the maximum distance between two cities. By using standard methods, this results in a (1+ϵ)-approximation running in time O⁎(2nϵ−1).•A tight analysis of Berger et al.'s exponential-space algorithm, resulting in an O⁎(4n) running time bound.•A new polynomial-space algorithm, running in time O(7.88n).

An improved exact algorithm for minimum dominating set in chordal graphs

Minimum Dominating Set is among the most studied classical NP-hard problems. On general graphs, an O(1.4864n) exact algorithm for this problem is known. Minimum Dominating Set remains NP-hard on chordal graphs where the current asymptotically-fastest exact algorithm solves the problem in O(1.3687n) time and super-polynomial space. In this paper, a simple exact polynomial-space algorithm that exploits the local structure of neighborhoods of simplicial vertices in chordal graphs is presented, resulting in an improved running time in O(1.3384n).

Improved algorithms for the general exact satisfiability problem

The Exact Satisfiability problem asks if we can find a satisfying assignment to each clause such that exactly one literal in each clause is assigned 1, while the rest are all assigned 0. We can generalise this problem further by defining that a Cj clause is solved iff exactly j of the literals in the clause are 1 and all others are 0. We now introduce the family of Generalised Exact Satisfiability problems called GiXSAT as the problem to check whether a given instance consisting of Cj clauses with j∈{0,1,…,i} for each clause has a satisfying assignment. In this paper, we present faster exact polynomial space algorithms, using a nonstandard measure, to solve GiXSAT, for i∈{2,3,4}, in O(1.3674n) time, O(1.5687n) time and O(1.6545n) time, respectively, using polynomial space, where n is the number of variables. This improves the current state of the art for polynomial space algorithms from O(1.4203n) time for G2XSAT by Zhou, Jiang and Yin and from O(1.6202n) time for G3XSAT by Dahllöf and from O(1.6844n) time for G4XSAT which was by Dahllöf as well. In addition, we present faster exact algorithms solving G2XSAT, G3XSAT and G4XSAT in O(1.3188n) time, O(1.3407n) time and O(1.3536n) time respectively at the expense of using exponential space.

Approximate Counting of k -Paths: Simpler, Deterministic, and in Polynomial Space

Recently, Brand et al. [STOC 2018] gave a randomized mathcal O(4 k m ε -2 -time exponential-space algorithm to approximately compute the number of paths on k vertices in a graph G up to a multiplicative error of 1 ± ε based on exterior algebra. Prior to our work, this has been the state-of-the-art. In this article, we revisit the algorithm by Alon and Gutner [IWPEC 2009, TALG 2010], and obtain the following results: • We present a deterministic 4 k + O (√ k (log k +log 2 ε -1 )) m -time polynomial-space algorithm. This matches the running time of the best known deterministic polynomial-space algorithm for deciding whether a given graph G has a path on k vertices. • Additionally, we present a randomized 4 k +mathcal O(log k (log k +logε -1 )) m -time polynomial-space algorithm. Our algorithm is simple—we only make elementary use of the probabilistic method. Here, n and m are the number of vertices and the number of edges, respectively. Additionally, our approach extends to approximate counting of other patterns of small size (such as q -dimensional p -matchings).

Finding and Counting Permutations via CSPs

Permutation patterns and pattern avoidance have been intensively studied in combinatorics and computer science, going back at least to the seminal work of Knuth on stack-sorting (1968). Perhaps the most natural algorithmic question in this area is deciding whether a given permutation of length n contains a given pattern of length k. In this work we give two new algorithms for this well-studied problem, one whose running time is n^{k/4 + o(k)}, and a polynomial-space algorithm whose running time is the better of O(1.6181^n) and O(n^{k/2 + 1}). These results improve the earlier best bounds of n^{0.47k + o(k)} and O(1.79^n) due to Ahal and Rabinovich (2000) resp. Bruner and Lackner (2012) and are the fastest algorithms for the problem when k in varOmega (log {n}). We show that both our new algorithms and the previous exponential-time algorithms in the literature can be viewed through the unifying lens of constraint-satisfaction. Our algorithms can also count, within the same running time, the number of occurrences of a pattern. We show that this result is close to optimal: solving the counting problem in time f(k) cdot n^{o(k/log {k})} would contradict the exponential-time hypothesis (ETH). For some special classes of patterns we obtain improved running times. We further prove that 3-increasing (4321-avoiding) and 3-decreasing (1234-avoiding) permutations can, in some sense, embed arbitrary permutations of almost linear length, which indicates that a sub-exponential running time is unlikely with the current techniques, even for patterns from these restricted classes.

Parameterized algorithms and kernels for almost induced matching

The Almost Induced Matching problem asks whether we can delete at most k vertices from the input graph such that each vertex in the remaining graph has a degree exactly one. This paper studies parameterized algorithms for this problem by taking the size k of the deletion set as the parameter. We give a 7k-vertex kernel and an O⁎(1.7485k)-time and polynomial-space algorithm, both of which are the best-known results. The linear-vertex kernel is obtained by using an extended crown decomposition and careful analysis, and the parameterized algorithm is based on a branch-and-search paradigm.

On compact representations of Voronoi cells of lattices

In a seminal work, Micciancio & Voulgaris (2013) described a deterministic single-exponential time algorithm for the Closest Vector Problem (CVP) on lattices. It is based on the computation of the Voronoi cell of the given lattice and thus may need exponential space as well. We address the major open question whether there exists such an algorithm that requires only polynomial space. To this end, we define a lattice basis to be $c$-compact if every facet normal of the Voronoi cell is a linear combination of the basis vectors using coefficients that are bounded by $c$ in absolute value. Given such a basis, we get a polynomial space algorithm for CVP whose running time naturally depends on $c$. Thus, our main focus is the behavior of the smallest possible value of $c$, with the following results: There always exist $c$-compact bases, where $c$ is bounded by $n^2$ for an $n$-dimension lattice; there are lattices not admitting a $c$-compact basis with $c$ growing sublinearly with the dimension; and every lattice with a zonotopal Voronoi cell has a $1$-compact basis.

Reordering all agents in asynchronous backtracking for distributed constraint satisfaction problems

Distributed constraint satisfaction problems (DisCSPs) can express decision problems where physically distributed agents control different decision variables, but must coordinate with each other to agree on a global solution. Asynchronous Backtracking (ABT) is a pivotal search procedure for DisCSPs. ABT requires a static total ordering on the agents. However, reordering agents during search is an essential component for efficiently solving a DisCSP. All polynomial space algorithms proposed so far to improve ABT by reordering agents during search only allow a limited amount of reordering. In this paper, we propose AgileABT, a general framework for reordering agents asynchronously that is able to change the ordering of all agents. This is done via the original notion of termination value, a label attached to the orders exchanged by agents during search. We prove that AgileABT is sound and complete. We show that, thanks to termination values, our framework allows us to implement the main variable ordering heuristics from centralized CSPs, which until now could not be applied to the distributed setting. We prove that AgileABT terminates and has a polynomial space complexity in all these cases. Our empirical study shows the significance of our framework compared to state-of-the-art asynchronous dynamic ordering algorithms for solving distributed CSP.

Complexity of detectability, opacity and A-diagnosability for modular discrete event systems

Modular discrete event systems are modeled as a parallel composition of finite automata. While deciding weak detectability, opacity, and A-diagnosability for monolithic systems is PSPACE-complete, the complexity for modular systems is unknown. We show that for modular systems the problems are EXPSPACE-complete, and hence there is neither a polynomial-time nor a polynomial-space algorithm solving them. While the upper bound is a natural modification of the PSPACE algorithms for monolithic systems, the lower bound requires a novel and nontrivial construction. We further discuss a case where the complexity drops to PSPACE-complete.

Designing deterministic polynomial-space algorithms by color-coding multivariate polynomials

We introduce an enhancement of color coding to design deterministic polynomial-space parameterized algorithms. Our approach aims at reducing the number of random choices by exploiting the special structure of a solution. Using our approach, we derive polynomial-space O⁎(3.86k)-time (exponential-space O⁎(3.41k)-time) deterministic algorithm for k-Internal Out-Branching, improving upon the previously fastest exponential-space O⁎(5.14k)-time algorithm for this problem. (The notation O⁎ hides polynomial factors.) We also design polynomial-space O⁎((2e)k+o(k))-time (exponential-space O⁎(4.32k)-time) deterministic algorithms for k-ColorfulOut-Branching on arc-colored digraphs and k-Colorful Perfect Matching on planar edge-colored graphs. In k-Colorful Out-Branching, given an arc-colored digraph D, decide whether D has an out-branching with arcs of at least k colors. k-Colorful Perfect Matching is defined similarly. To obtain our polynomial-space algorithms, we show that (n,k,αk)-splitters (α⩾1) and in particular (n,k)-perfect hash families can be enumerated one by one with polynomial delay using polynomial space.

Exact algorithms for weak Roman domination

We consider the Weak Roman Domination problem. Given an undirected graph G=(V,E), the aim is to find a weak Roman domination function (wrd-function for short) of minimum cost, i.e. a function f:V→{0,1,2} such that every vertex v∈V is defended (i.e. there exists a neighbor u of v, possibly u=v, such that f(u)⩾1) and for every vertex v∈V with f(v)=0 there exists a neighbor u of v such that f(u)⩾1 and the function fu→v defined by fu→v(v)=1, fu→v(u)=f(u)−1 and fu→v(x)=f(x) otherwise does not contain any undefended vertex. The cost of a wrd-function f is defined by cost(f)=∑v∈Vf(v). The trivial enumeration algorithm runs in time O∗(3n) and polynomial space and is the best one known for the problem so far. We are breaking the trivial enumeration barrier by providing two faster algorithms: we first prove that the problem can be solved in O∗(2n) time needing exponential space, and then describe an O∗(2.2279n) algorithm using polynomial space. Our results rely on structural properties of a wrd-function, as well as on the best polynomial space algorithm for the Red-Blue Dominating Set problem. Moreover we show that the problem can be solved in linear-time on interval graphs.

Improved exact algorithms for mildly sparse instances of Max SAT

We present improved exponential time exact algorithms for Max SAT. Our algorithms run in time of the form O(2(1−μ(c))n) for instances with n variables and m=cn clauses. In this setting, there are three incomparable currently best algorithms: a deterministic exponential space algorithm with μ(c)=1O(clog⁡c) due to Dantsin and Wolpert (2006) [9], a randomized polynomial space algorithm with μ(c)=1O(clog3⁡c) and a deterministic polynomial space algorithm with μ(c)=1O(c2log2⁡c) due to Sakai, Seto and Tamaki (2015) [30]. Our first result is a deterministic polynomial space algorithm with μ(c)=1O(clog⁡c) that achieves the previous best time complexity without exponential space or randomization. Furthermore, this algorithm can handle instances with exponentially large weights and hard constraints.The previous algorithms and our deterministic polynomial space algorithm run super-polynomially faster than 2n only if m=O(n2). Our second results are deterministic exponential space algorithms for Max SAT with μ(c)=1O((clog⁡c)2/3) and for Max 3-SAT with μ(c)=1O(c1/2) that run super-polynomially faster than 2n when m=o(n5/2/log5/2⁡n) and m=o(n3/log2⁡n) respectively. Our third result is a randomized exponential space algorithm for Max SAT with μ(c)=1O(c1/2log3/2⁡c) that run super-polynomially faster than 2n when m=o(n3/log5⁡n).

A Moderately Exponential Time Algorithm for k-IBDD Satisfiability

A k-indexed Binary Decision Diagram (k-IBDD) is a branching program with k-layers and each layer consists of an Ordered Binary Decision Diagram (OBDD). This paper studies the satisfiability of k-IBDD (k-IBDD SAT). A k-IBDD SAT is, given a k-IBDD, to ask whether there exists a consistent path from the root to the 1-sink. We propose a moderately exponential time algorithm using exponential space for k-IBDD SAT of n variables and cn size. Our algorithm runs in time \(O\left( 2^{(1-\mu (c))n}\right) \), where \(\mu (c)=\Omega \left( \frac{1}{(\log {c})^{2^{k-1}-1}}\right) \). As a corollary, we obtain a polynomial space and deterministic algorithm, which solves k-IBDD SAT of size polynomial in n and runs in \(O\left( 2^{ n - n^{ 1/2^{k-1} }}\right) \) time.

The problem of determining the weak (periodic) detectability of discrete event systems is PSPACE-complete

In Shu and Lin, 2011, exponential time (actually polynomial space) algorithms for determining the weak detectability and weak periodic detectability of nondeterministic discrete event systems (DESs) are designed. In this paper, we prove that the problems of determining the weak detectability and weak periodic detectability of deterministic DESs are both PSPACE-hard (hence PSPACE-complete). Then as corollaries, the problems of determining the weak detectability and weak periodic detectability of nondeterministic DESs are also PSPACE-hard (hence PSPACE-complete).

On finding rainbow and colorful paths

In the Colorful Path problem we are given a graph G=(V,E) and an arbitrary vertex coloring function c:V→[k]. The goal is to find a colorful path, i.e., a path on k vertices, that visits each color. This problem has been introduced in the classical work of Alon et al. (1995) [1], and the authors proposed a dynamic programming algorithm that runs in time 2knO(1) and uses O(2k) space. Since then the only progress obtained is reducing the space size to a polynomial at the cost of using randomization. In this work we show that a progress in time complexity is unlikely: if Colorful Path can be solved in time (2−ε)knO(1), then Set Cover admits a (2−ε′)n(nm)O(1)-time algorithm. The same applies to other versions of the problem: when edges are colored instead of vertices, or we ask for a walk instead of a path, or when the requested path/walk has specified endpoints.We study also a second, very related problem. In Rainbowst-Connectivity, we are given a k-edge-colored graph and two vertices s and t. The goal is to decide whether there is a rainbow path between s and t, that is, a path on which no color repeats. In its vertex variant (Rainbow Vertexst-Connectivity) the input graph is k-vertex-colored, and a rainbow path is defined analogously. Uchizawa et al. (2011) [14] show that both variants can be solved in 2knO(1) time and exponential space. We show that the space size can be reduced to a polynomial, while keeping the same running time. In contrast to the polynomial space algorithm for Colorful Path, our algorithm for finding rainbow paths is deterministic.

An Improved Algorithm for Parameterized Edge Dominating Set Problem

An edge dominating set of a graph G = (V, E) is a subset M ⊆ E of edges such that each edge in E \M is incident to at least one edge in M. In this paper, we consider the parameterized edge dominating set problem which asks us to test whether a given graph has an edge dominating set with size bounded from above by an integer k or not, and we design an O*(2.2351k)-time and polynomial-space algorithm. This is an improvement over the previous best time bound of O*(2.3147k). We also show two corollaries: the parameterized weighted edge dominating set problem can be solved in O*(2.2351k) time and polynomial space; and a minimum edge dominating set of a graph G can be found in O*(1.7957τ) time where τ is the size of a minimum vertex cover of G.