arXiv subjects
Publications and source records attributed to Martin Fürer.
A symmetric matrix $M=(m_{ij}) \in \mathbb{R}^{n \times n}$ is said to be associated with an $n$-vertex graph $G=(V,E)$ with vertex set $\{v_1,\ldots,v_n\}$ if, for every $i \neq j$, we have $m_{ij} \neq 0$ if and only if $\{v_i,v_j\}\in E$. We prove that, for every cograph $G$, there is a matrix $M$ associated with $G$ for which the number of distinct eigenvalues is at most 4.
This paper presents a linear FPT algorithm to find a tree decomposition with a 2-approximation of the treewidth with a significantly smaller exponential dependence on the treewidth. The algorithm runs in time $O(\text{poly}(k) 81^k n)$, compared to Korhonen's running time of $O(\text{poly}(k) 1782^k n)$ = $O(2^{10.8k} n)$.
We present a new approximation algorithm for the treewidth problem which finds an upper bound on the treewidth and constructs a corresponding tree decomposition as well. Our algorithm is a faster variation of Reed's classical algorithm. For the benefit of the reader, and to be able to compare these two algorithms, we start with a detailed time analysis of Reed's algorithm. We fill in many details that have been omitted in Reed's paper. Computing tree decompositions parameterized by the treewidth $k$ is fixed parameter tractable (FPT), meaning that there are algorithms running in time $\mathcal{O}(f(k) g(n))$ where $f$ is a computable function, and $g(n)$ is polynomial in $n$, where $n$ is the number of vertices. An analysis of Reed's algorithm shows $f(k) = 2^{\mathcal{O}(k \log k)}$ and $g(n) = n \log n$ for a 5-approximation. Reed simply claims time $\mathcal{O}(n \log n)$ for bounded $k$ for his constant factor approximation algorithm, but the bound of $2^{Ω(k \log k)} n \log n$ is well known. From a practical point of view, we notice that the time of Reed's algorithm also contains a term of $\mathcal{O}(k^2 2^{24k} n \log n)$, which for small $k$ is much worse than the asymptotically leading term of $2^{\mathcal{O}(k \log k)} n \log n$. We analyze $f(k)$ more precisely, because the purpose of this paper is to improve the running times for all reasonably small values of $k$. Our algorithm runs in $\mathcal{O}(f(k)n\log{n})$ too, but with a much smaller dependence on $k$. In our case, $f(k) = 2^{\mathcal{O}(k)}$. This algorithm is simple and fast, especially for small values of $k$. We should mention that Bodlaender et al. [2016] have an algorithm with a linear dependence on $n$, and Korhonen [2021] obtains the much better approximation ratio of 2, while the current paper achieves a better dependence on $k$.
We define a notion called leftmost separator of size at most $k$. A leftmost separator of size $k$ is a minimal separator $S$ that separates two given sets of vertices $X$ and $Y$ such that we "cannot move $S$ more towards $X$" such that $|S|$ remains smaller than the threshold. One of the incentives is that by using leftmost separators we can improve the time complexity of treewidth approximation. Treewidth approximation is a problem which is known to have a linear time FPT algorithm in terms of input size, and only single exponential in terms of the parameter, treewidth. It is not known whether this result can be improved theoretically. However, the coefficient of the parameter $k$ (the treewidth) in the exponent is large. Hence, our goal is to decrease the coefficient of $k$ in the exponent, in order to achieve a more practical algorithm. Hereby, we trade a linear-time algorithm for an $\mathcal{O}(n \log n)$-time algorithm. The previous known $\mathcal{O}(f(k) n \log n)$-time algorithms have dependences of $2^{24k}k!$, $2^{8.766k}k^2$ (a better analysis shows that it is $2^{7.671k}k^2$), and higher. In this paper, we present an algorithm for treewidth approximation which runs in time $\mathcal{O}(2^{6.755k}\ n \log n)$, Furthermore, we count the number of leftmost separators and give a tight upper bound for them. We show that the number of leftmost separators of size $\leq k$ is at most $C_{k-1}$ (Catalan number). Then, we present an algorithm which outputs all leftmost separators in time $\mathcal{O}(\frac{4^k}{\sqrt{k}}n)$.
Let $M=(m_{ij})$ be a symmetric matrix of order $n$ whose elements lie in an arbitrary field $\mathbb{F}$, and let $G$ be the graph with vertex set $\{1,\ldots,n\}$ such that distinct vertices $i$ and $j$ are adjacent if and only if $m_{ij} \neq 0$. We introduce a dynamic programming algorithm that finds a diagonal matrix that is congruent to $M$. If $G$ is given with a tree decomposition $\mathcal{T}$ of width $k$, then this can be done in time $O(k|\mathcal{T}| + k^2 n)$, where $|\mathcal{T}|$ denotes the number of nodes in $\mathcal{T}$. Among other things, this allows one to compute the determinant, the rank and the inertia of a symmetric matrix in time $O(k|\mathcal{T}| + k^2 n)$.
An NP-hard graph problem may be intractable for general graphs but it could be efficiently solvable using dynamic programming for graphs with bounded width (or depth or some other structural parameter). Dynamic programming is a well-known approach used for finding exact solutions for NP-hard graph problems based on tree decompositions. It has been shown that there exist algorithms using linear time in the number of vertices and single exponential time in the width (depth or other parameters) of a given tree decomposition for many connectivity problems. Employing dynamic programming on a tree decomposition usually uses exponential space. In 2010, Lokshtanov and Nederlof introduced an elegant framework to avoid exponential space by algebraization. Later, Fürer and Yu modified the framework in a way that even works when the underlying set is dynamic, thus applying it to tree decompositions. In this work, we design space-efficient algorithms to solve the Hamiltonian Cycle and the Traveling Salesman problems, using polynomial space while the time complexity is only slightly increased. This might be inevitable since we are reducing the space usage from an exponential amount (in dynamic programming solution) to polynomial. We give an algorithm to solve Hamiltonian cycle in time $\mathcal{O}((4w)^d\, nM(n\log{n}))$ using $\mathcal{O}(dn\log{n})$ space, where $M(r)$ is the time complexity to multiply two integers, each of which being represented by at most $r$ bits. Then, we solve the more general Traveling Salesman problem in time $\mathcal{O}((4w)^d poly(n))$ using space $\mathcal{O}(\mathcal{W}dn\log{n})$, where $w$ and $d$ are the width and the depth of the given tree decomposition and $\mathcal{W}$ is the sum of weights. Furthermore, this algorithm counts the number of Hamiltonian Cycles.
An algorithm is presented that solves the Minimum Dominating Set problem exactly using polynomial space based on dynamic programming for a tree decomposition. A direct application of dynamic programming based on a tree decomposition would result in an exponential space algorithm, but we use zeta transforms to obtain a polynomial space algorithm in exchange for a moderate increase of the time. This framework was pioneered by Lokshtanov and Nederlof 2010 and adapted to a dynamic setting by Fürer and Yu 2017. Our space-efficient algorithm is a parametrized algorithm based on tree-depth and treewidth. The naive algorithm for Minimum Dominating Set runs in $\mathcal{O}^*(2^n)$ time. Most of the previous works have focused on time complexity. But space optimization is a crucial aspect of algorithm design, since in several scenarios space is a more valuable resource than time. Our parametrized algorithm runs in $\mathcal{O}^*(3^{d})$, and its space complexity is $\mathcal{O}(nk)$, where $d$ is the depth and $k$ is the width of the given tree decomposition. We observe that Reed's 1992 algorithm constructing a tree decomposition of a graph uses only polynomial space. So, even if the tree decomposition is not given, we still obtain an efficient polynomial space algorithm. There are some other algorithms which use polynomial space for this problem, but they are not efficient for graphs with small tree depth.
Finding a diagonal matrix congruent to $A - cI$ for constants $c$, where $A$ is the adjacency matrix of a graph $G$ allows us to quickly tell the number of eigenvalues in a given interval. If $G$ has clique-width $k$ and a corresponding $k$-expression is known, then diagonalization can be done in time $O(\text{poly}(k) n)$ where $n$ is the order of $G$.
The classical Weisfeiler-Lehman method WL[2] uses edge colors to produce a powerful graph invariant. It is at least as powerful in its ability to distinguish non-isomorphic graphs as the most prominent algebraic graph invariants. It determines not only the spectrum of a graph, and the angles between standard basis vectors and the eigenspaces, but even the angles between projections of standard basis vectors into the eigenspaces. Here, we investigate the combinatorial power of WL[2]. For sufficiently large k, WL[k] determines all combinatorial properties of a graph. Many traditionally used combinatorial invariants are determined by WL[k] for small k. We focus on two fundamental invariants, the num- ber of cycles Cp of length p, and the number of cliques Kp of size p. We show that WL[2] determines the number of cycles of lengths up to 6, but not those of length 8. Also, WL[2] does not determine the number of 4-cliques.
Tree-width and path-width are widely successful concepts. Many NP-hard problems have efficient solutions when restricted to graphs of bounded tree-width. Many efficient algorithms are based on a tree decomposition. Sometimes the more restricted path decomposition is required. The bottleneck for such algorithms is often the computation of the width and a corresponding tree or path decomposition. For graphs with $n$ vertices and tree-width or path-width $k$, the standard linear time algorithm to compute these decompositions dates back to 1996. Its running time is linear in $n$ and exponential in $k^3$ and not usable in practice. Here we present a more efficient algorithm to compute the path-width and provide a path decomposition. Its running time is $2^{O(k^2)} n$. In the classical algorithm of Bodlaender and Kloks, the path decomposition is computed from a tree decomposition. Here, an optimal path decomposition is computed from a path decomposition of about twice the width. The latter is computed from a constant factor smaller graph.
Multi-clique-width is obtained by a simple modification in the definition of clique-width. It has the advantage of providing a natural extension of tree-width. Unlike clique-width, it does not explode exponentially compared to tree-width. Efficient algorithms based on multi-clique-width are still possible for interesting tasks like computing the independent set polynomial or testing $c$-colorability. In particular, $c$-colorability can be tested in time linear in $n$ and singly exponential in $c$ and the width $k$ of a given multi-$k$-expression. For these tasks, the running time as a function of the multi-clique-width is the same as the running time of the fastest known algorithm as a function of the clique-width. This results in an exponential speed-up for some graphs, if the corresponding graph generating expressions are given. The reason is that the multi-clique-width is never bigger, but is exponentially smaller than the clique-width for many graphs. This gap shows up when the tree-width is basically equal to the multi-clique width as well as when the tree-width is not bounded by any function of the clique-width.
We study the problem of counting the number of {\em isomorphic} copies of a given {\em template} graph, say $H$, in the input {\em base} graph, say $G$. In general, it is believed that polynomial time algorithms that solve this problem exactly are unlikely to exist. So, a lot of work has gone into designing efficient {\em approximation schemes}, especially, when $H$ is a perfect matching. In this work, we present efficient approximation schemes to count $k$-Cliques, $k$-Independent sets and $k$-Clique covers in random graphs. We present {\em fully polynomial time randomized approximation schemes} (fpras) to count $k$-Cliques and $k$-Independent sets in a random graph on $n$ vertices when $k$ is at most $(1+o(1))\log n$, and $k$-Clique covers when $k$ is a constant. [Grimmett and McDiarmid, 1975] present a simple greedy algorithm that {\em detects} a clique (independent set) of size $(1+o(1))\log_2 n$ in $G\in \mathcal{G}(n,\frac{1}{2})$ with high probability. No algorithm is known to detect a clique or an independent set of larger size with non-vanishing probability. Furthermore, [Coja-Oghlan and Efthymiou, 2011] present some evidence that one cannot hope to easily improve a similar, almost 40 years old bound for sparse random graphs. Therefore, our results are unlikely to be easily improved. We use a novel approach to obtain a recurrence corresponding to the variance of each estimator. Then we upper bound the variance using the corresponding recurrence. This leads us to obtain a polynomial upper bound on the critical ratio. As an aside, we also obtain an alternate derivation of the closed form expression for the $k$-th moment of a binomial random variable using our techniques. The previous derivation [Knoblauch (2008)] was based on the moment generating function of a binomial random variable.
An efficient algorithm is presented to compute the characteristic polynomial of a threshold graph. Threshold graphs were introduced by Chvátal and Hammer, as well as by Henderson and Zalcstein in 1977. A threshold graph is obtained from a one vertex graph by repeatedly adding either an isolated vertex or a dominating vertex, which is a vertex adjacent to all the other vertices. Threshold graphs are special kinds of cographs, which themselves are special kinds of graphs of clique-width 2. We obtain a running time of $O(n \log^2 n)$ for computing the characteristic polynomial, while the previously fastest algorithm ran in quadratic time. Keywords: Efficient Algorithms, Threshold Graphs, Characteristic Polynomial.
We investigate a new width parameter, the fusion-width of a graph. It is a natural generalization of the tree-width, yet strong enough that not only graphs of bounded tree-width, but also graphs of bounded clique-width, trivially have bounded fusion-width. In particular, there is no exponential growth between tree-width and fusion-width, as is the case between tree-width and clique-width. The new parameter gives a good intuition about the relationship between tree-width and clique-width.
We provide two complexity measures that can be used to measure the running time of algorithms to compute multiplications of long integers. The random access machine with unit or logarithmic cost is not adequate for measuring the complexity of a task like multiplication of long integers. The Turing machine is more useful here, but fails to take into account the multiplication instruction for short integers, which is available on physical computing devices. An interesting outcome is that the proposed refined complexity measures do not rank the well known multiplication algorithms the same way as the Turing machine model.
The bandwidth of a graph G on n vertices is the minimum b such that the vertices of G can be labeled from 1 to n such that the labels of every pair of adjacent vertices differ by at most b. In this paper, we present a 2-approximation algorithm for the bandwidth problem that takes worst-case O(1.9797^n) time and uses polynomial space. This improves both the previous best 2- and 3-approximation algorithms of Cygan et al. which have an O(3^n) and O(2^n) worst-case time bounds, respectively. Our algorithm is based on constructing bucket decompositions of the input graph. A bucket decomposition partitions the vertex set of a graph into ordered sets (called buckets) of (almost) equal sizes such that all edges are either incident to vertices in the same bucket or to vertices in two consecutive buckets. The idea is to find the smallest bucket size for which there exists a bucket decomposition. The algorithm uses a simple divide-and-conquer strategy along with dynamic programming to achieve this improved time bound.
This paper studies two issues related to the paper on Computing by Self-reproduction: Autopoietic Automata by Jiri Wiedermann. It is shown that all results presented there extend to deterministic computations. In particular, nondeterminism is not needed for a lineage to generate all autopoietic automata.