Robustness of a routing tree for the Push Tree Problem

The Push Tree problem contains elements from both the Steiner Tree and Shortest Path problem. It deals with the trade-offs between the push and pull mechanism used in information distribution and retrieval. In , a two step approach for the Push Tree Problem was proposed. In the first step, a «good» spanning tree (called routing tree) is constructed and then the problem is solved in this particular tree. Finding a routing tree is NP-hard but the second step may be performed easily, thus the idea is to use the routing tree as a (semi-) stable infrastructure and to perform adaptations to changing information patterns inside the routing tree. In this paper, we study the robustness of a routing tree when the information requests disappear at some nodes

Dependability in Aggregation by Averaging

Aggregation is an important building block of modern distributed applications, allowing the determination of meaningful properties (e.g. network size, total storage capacity, average load, majorities, etc.) that are used to direct the execution of the system. However, the majority of the existing aggregation algorithms exhibit relevant dependability issues, when prospecting their use in real application environments. In this paper, we reveal some dependability issues of aggregation algorithms based on iterative averaging techniques, giving some directions to solve them. This class of algorithms is considered robust (when compared to common tree-based approaches), being independent from the used routing topology and providing an aggregation result at all nodes. However, their robustness is strongly challenged and their correctness often compromised, when changing the assumptions of their working environment to more realistic ones. The correctness of this class of algorithms relies on the maintenance of a fundamental invariant, commonly designated as "mass conservation". We will argue that this main invariant is often broken in practical settings, and that additional mechanisms and modifications are required to maintain it, incurring in some degradation of the algorithms performance. In particular, we discuss the behavior of three representative algorithms Push-Sum Protocol, Push-Pull Gossip protocol and Distributed Random Grouping under asynchronous and faulty (with message loss and node crashes) environments. More specifically, we propose and evaluate two new versions of the Push-Pull Gossip protocol, which solve its message interleaving problem (evidenced even in a synchronous operation mode).Comment: 14 pages. Presented in Inforum 200

A push–relabel approximation algorithm for approximating the minimum-degree MST problem and its generalization to matroids

AbstractIn the minimum-degree minimum spanning tree (MDMST) problem, we are given a graph G, and the goal is to find a minimum spanning tree (MST) T, such that the maximum degree of T is as small as possible. This problem is NP-hard and generalizes the Hamiltonian path problem. We give an algorithm that outputs an MST of degree at most 2Δopt (G)+o(Δopt (G)), where Δopt (G) denotes the degree of the optimal tree. This result improves on a previous result of Fischer [T. Fischer, Optimizing the degree of minimum weight spanning trees. Technical Report 14853, Dept. of Computer Science, Cornell University, Ithaca, NY, 1993] that finds an MST of degree at most bΔopt (G)+logbn, for any b>1.The MDMST problem is a special case of the following problem: given a k-ary hypergraph G=(V,E) and weighted matroid M with E as its ground set, find a minimum-cost basis (MCB) T of M such that the degree of T in G is as small as possible. Our algorithm immediately generalizes to this problem, finding an MCB of degree at most k2Δopt (G,M)+O(kkΔopt (G,M)).We use the push–relabel framework developed by Goldberg [A. V. Goldberg, A new max-flow algorithm, Technical Report MIT/LCS/TM-291, Massachusetts Institute of Technology, 1985 (Technical Report)] for the maximum-flow problem. To our knowledge, this is the first use of the push–relabel technique in an approximation algorithm for an NP-hard problem.The MDMST problem is closely connected to the bounded-degree minimum spanning tree (BDMST) problem. Given a graph G and degree bound B on its nodes, the BDMST problem is to find a minimum cost spanning tree among the spanning trees with maximum degree B. Previous algorithms for this problem by Könemann and Ravi [J. Könemann, R. Ravi, A matter of degree: Improved approximation algorithms for degree-bounded minimum spanning trees, SIAM Journal on Computing 31(6) (2002) 1783–1793; J. Könemann, R. Ravi, Primal-dual meets local search: Approximating MST’s with nonuniform degree bounds, in: Proceedings of the Thirty-Fifth ACM Symposium on Theory of Computing, 2003, pp. 389–395] and by Chaudhuri et al. [K. Chaudhuri, S. Rao, S. Riesenfeld, K. Talwar, What would Edmonds do? Augmenting paths and witnesses for bounded degree MSTs, in: Proceedings of APPROX/RANDOM, 2005, pp. 26–39] incur a near-logarithmic additive error in the degree. We give the first BDMST algorithm that approximates both the degree and the cost to within a constant factor of the optimum. These results generalize to the case of nonuniform degree bounds

Efficiently computing maximum flows in scale-free networks

We study the maximum-flow/minimum-cut problem on scale-free networks, i.e., graphs whose degree distribution follows a power-law. We propose a simple algorithm that capitalizes on the fact that often only a small fraction of such a network is relevant for the flow. At its core, our algorithm augments Dinitz’s algorithm with a balanced bidirectional search. Our experiments on a scale-free random network model indicate sublinear run time. On scale-free real-world networks, we outperform the commonly used highest-label Push-Relabel implementation by up to two orders of magnitude. Compared to Dinitz’s original algorithm, our modifications reduce the search space, e.g., by a factor of 275 on an autonomous systems graph. Beyond these good run times, our algorithm has an additional advantage compared to Push-Relabel. The latter computes a preflow, which makes the extraction of a minimum cut potentially more difficult. This is relevant, for example, for the computation of Gomory-Hu trees. On a social network with 70000 nodes, our algorithm computes the Gomory-Hu tree in 3 seconds compared to 12 minutes when using Push-Relabel

On space efficiency of algorithms working on structural decompositions of graphs

Dynamic programming on path and tree decompositions of graphs is a technique that is ubiquitous in the field of parameterized and exponential-time algorithms. However, one of its drawbacks is that the space usage is exponential in the decomposition's width. Following the work of Allender et al. [Theory of Computing, '14], we investigate whether this space complexity explosion is unavoidable. Using the idea of reparameterization of Cai and Juedes [J. Comput. Syst. Sci., '03], we prove that the question is closely related to a conjecture that the Longest Common Subsequence problem parameterized by the number of input strings does not admit an algorithm that simultaneously uses XP time and FPT space. Moreover, we complete the complexity landscape sketched for pathwidth and treewidth by Allender et al. by considering the parameter tree-depth. We prove that computations on tree-depth decompositions correspond to a model of non-deterministic machines that work in polynomial time and logarithmic space, with access to an auxiliary stack of maximum height equal to the decomposition's depth. Together with the results of Allender et al., this describes a hierarchy of complexity classes for polynomial-time non-deterministic machines with different restrictions on the access to working space, which mirrors the classic relations between treewidth, pathwidth, and tree-depth.Comment: An extended abstract appeared in the proceedings of STACS'16. The new version is augmented with a space-efficient algorithm for Dominating Set using the Chinese remainder theore

New results on pushdown module checking with imperfect information

Model checking of open pushdown systems (OPD) w.r.t. standard branching temporal logics (pushdown module checking or PMC) has been recently investigated in the literature, both in the context of environments with perfect and imperfect information about the system (in the last case, the environment has only a partial view of the system's control states and stack content). For standard CTL, PMC with imperfect information is known to be undecidable. If the stack content is assumed to be visible, then the problem is decidable and 2EXPTIME-complete (matching the complexity of PMC with perfect information against CTL). The decidability status of PMC with imperfect information against CTL restricted to the case where the depth of the stack content is visible is open. In this paper, we show that with this restriction, PMC with imperfect information against CTL remains undecidable. On the other hand, we individuate an interesting subclass of OPDS with visible stack content depth such that PMC with imperfect information against the existential fragment of CTL is decidable and in 2EXPTIME. Moreover, we show that the program complexity of PMC with imperfect information and visible stack content against CTL is 2EXPTIME-complete (hence, exponentially harder than the program complexity of PMC with perfect information, which is known to be EXPTIME-complete).Comment: In Proceedings GandALF 2011, arXiv:1106.081