2,901 research outputs found

    Self-stabilizing algorithms for Connected Vertex Cover and Clique decomposition problems

    Full text link
    In many wireless networks, there is no fixed physical backbone nor centralized network management. The nodes of such a network have to self-organize in order to maintain a virtual backbone used to route messages. Moreover, any node of the network can be a priori at the origin of a malicious attack. Thus, in one hand the backbone must be fault-tolerant and in other hand it can be useful to monitor all network communications to identify an attack as soon as possible. We are interested in the minimum \emph{Connected Vertex Cover} problem, a generalization of the classical minimum Vertex Cover problem, which allows to obtain a connected backbone. Recently, Delbot et al.~\cite{DelbotLP13} proposed a new centralized algorithm with a constant approximation ratio of 22 for this problem. In this paper, we propose a distributed and self-stabilizing version of their algorithm with the same approximation guarantee. To the best knowledge of the authors, it is the first distributed and fault-tolerant algorithm for this problem. The approach followed to solve the considered problem is based on the construction of a connected minimal clique partition. Therefore, we also design the first distributed self-stabilizing algorithm for this problem, which is of independent interest

    Survey of Distributed Decision

    Get PDF
    We survey the recent distributed computing literature on checking whether a given distributed system configuration satisfies a given boolean predicate, i.e., whether the configuration is legal or illegal w.r.t. that predicate. We consider classical distributed computing environments, including mostly synchronous fault-free network computing (LOCAL and CONGEST models), but also asynchronous crash-prone shared-memory computing (WAIT-FREE model), and mobile computing (FSYNC model)

    Design of Self-Stabilizing Approximation Algorithms via a Primal-Dual Approach

    Get PDF
    Self-stabilization is an important concept in the realm of fault-tolerant distributed computing. In this paper, we propose a new approach that relies on the properties of linear programming duality to obtain self-stabilizing approximation algorithms for distributed graph optimization problems. The power of this new approach is demonstrated by the following results: - A self-stabilizing 2(1+?)-approximation algorithm for minimum weight vertex cover that converges in O(log? /(?log log ?)) synchronous rounds. - A self-stabilizing ?-approximation algorithm for maximum weight independent set that converges in O(?+log^* n) synchronous rounds. - A self-stabilizing ((2?+1)(1+?))-approximation algorithm for minimum weight dominating set in ?-arboricity graphs that converges in O((log?)/?) synchronous rounds. In all of the above, ? denotes the maximum degree. Our technique improves upon previous results in terms of time complexity while incurring only an additive O(log n) overhead to the message size. In addition, to the best of our knowledge, we provide the first self-stabilizing algorithms for the weighted versions of minimum vertex cover and maximum independent set

    The difficulty of folding self-folding origami

    Full text link
    Why is it difficult to refold a previously folded sheet of paper? We show that even crease patterns with only one designed folding motion inevitably contain an exponential number of `distractor' folding branches accessible from a bifurcation at the flat state. Consequently, refolding a sheet requires finding the ground state in a glassy energy landscape with an exponential number of other attractors of higher energy, much like in models of protein folding (Levinthal's paradox) and other NP-hard satisfiability (SAT) problems. As in these problems, we find that refolding a sheet requires actuation at multiple carefully chosen creases. We show that seeding successful folding in this way can be understood in terms of sub-patterns that fold when cut out (`folding islands'). Besides providing guidelines for the placement of active hinges in origami applications, our results point to fundamental limits on the programmability of energy landscapes in sheets.Comment: 8 pages, 5 figure

    Lattice Linear Problems vs Algorithms

    Full text link
    Modelling problems using predicates that induce a partial order among global states was introduced as a way to permit asynchronous execution in multiprocessor systems. A key property of such problems is that the predicate induces one lattice in the state space which guarantees that the execution is correct even if nodes execute with old information about their neighbours. Thus, a compiler that is aware of this property can ignore data dependencies and allow the application to continue its execution with the available data rather than waiting for the most recent one. Unfortunately, many interesting problems do not exhibit lattice linearity. This issue was alleviated with the introduction of eventually lattice linear algorithms. Such algorithms induce a partial order in a subset of the state space even though the problem cannot be defined by a predicate under which the states form a partial order. This paper focuses on analyzing and differentiating between lattice linear problems and algorithms. It also introduces a new class of algorithms called (fully) lattice linear algorithms. A characteristic of these algorithms is that the entire reachable state space is partitioned into one or more lattices and the initial state locks into one of these lattices. Thus, under a few additional constraints, the initial state can uniquely determine the final state. For demonstration, we present lattice linear self-stabilizing algorithms for minimal dominating set and graph colouring problems, and a parallel processing 2-approximation algorithm for vertex cover. The algorithm for minimal dominating set converges in n moves, and that for graph colouring converges in n+2m moves. The algorithm for vertex cover is the first lattice linear approximation algorithm for an NP-Hard problem; it converges in n moves. Some part is cut due to 1920 character limit. Please see the pdf for full abstract.Comment: arXiv admin note: text overlap with arXiv:2209.1470

    Approximating max-min linear programs with local algorithms

    Full text link
    A local algorithm is a distributed algorithm where each node must operate solely based on the information that was available at system startup within a constant-size neighbourhood of the node. We study the applicability of local algorithms to max-min LPs where the objective is to maximise minkvckvxv\min_k \sum_v c_{kv} x_v subject to vaivxv1\sum_v a_{iv} x_v \le 1 for each ii and xv0x_v \ge 0 for each vv. Here ckv0c_{kv} \ge 0, aiv0a_{iv} \ge 0, and the support sets Vi={v:aiv>0}V_i = \{v : a_{iv} > 0 \}, Vk={v:ckv>0}V_k = \{v : c_{kv}>0 \}, Iv={i:aiv>0}I_v = \{i : a_{iv} > 0 \} and Kv={k:ckv>0}K_v = \{k : c_{kv} > 0 \} have bounded size. In the distributed setting, each agent vv is responsible for choosing the value of xvx_v, and the communication network is a hypergraph H\mathcal{H} where the sets VkV_k and ViV_i constitute the hyperedges. We present inapproximability results for a wide range of structural assumptions; for example, even if Vi|V_i| and Vk|V_k| are bounded by some constants larger than 2, there is no local approximation scheme. To contrast the negative results, we present a local approximation algorithm which achieves good approximation ratios if we can bound the relative growth of the vertex neighbourhoods in H\mathcal{H}.Comment: 16 pages, 2 figure

    Domination parameters with number 2: interrelations and algorithmic consequences

    Full text link
    In this paper, we study the most basic domination invariants in graphs, in which number 2 is intrinsic part of their definitions. We classify them upon three criteria, two of which give the following previously studied invariants: the weak 22-domination number, γw2(G)\gamma_{w2}(G), the 22-domination number, γ2(G)\gamma_2(G), the {2}\{2\}-domination number, γ{2}(G)\gamma_{\{2\}}(G), the double domination number, γ×2(G)\gamma_{\times 2}(G), the total {2}\{2\}-domination number, γt{2}(G)\gamma_{t\{2\}}(G), and the total double domination number, γt×2(G)\gamma_{t\times 2}(G), where GG is a graph in which a corresponding invariant is well defined. The third criterion yields rainbow versions of the mentioned six parameters, one of which has already been well studied, and three other give new interesting parameters. Together with a special, extensively studied Roman domination, γR(G)\gamma_R(G), and two classical parameters, the domination number, γ(G)\gamma(G), and the total domination number, γt(G)\gamma_t(G), we consider 13 domination invariants in graphs GG. In the main result of the paper we present sharp upper and lower bounds of each of the invariants in terms of every other invariant, large majority of which are new results proven in this paper. As a consequence of the main theorem we obtain some complexity results for the studied invariants, in particular regarding the existence of approximation algorithms and inapproximability bounds.Comment: 45 pages, 4 tables, 7 figure
    corecore