103 research outputs found

    Global Versus Local Computations: Fast Computing with Identifiers

    Full text link
    This paper studies what can be computed by using probabilistic local interactions with agents with a very restricted power in polylogarithmic parallel time. It is known that if agents are only finite state (corresponding to the Population Protocol model by Angluin et al.), then only semilinear predicates over the global input can be computed. In fact, if the population starts with a unique leader, these predicates can even be computed in a polylogarithmic parallel time. If identifiers are added (corresponding to the Community Protocol model by Guerraoui and Ruppert), then more global predicates over the input multiset can be computed. Local predicates over the input sorted according to the identifiers can also be computed, as long as the identifiers are ordered. The time of some of those predicates might require exponential parallel time. In this paper, we consider what can be computed with Community Protocol in a polylogarithmic number of parallel interactions. We introduce the class CPPL corresponding to protocols that use O(nlogkn)O(n\log^k n), for some k, expected interactions to compute their predicates, or equivalently a polylogarithmic number of parallel expected interactions. We provide some computable protocols, some boundaries of the class, using the fact that the population can compute its size. We also prove two impossibility results providing some arguments showing that local computations are no longer easy: the population does not have the time to compare a linear number of consecutive identifiers. The Linearly Local languages, such that the rational language (ab)(ab)^*, are not computable.Comment: Long version of SSS 2016 publication, appendixed version of SIROCCO 201

    An Optimal Algorithm for Tiling the Plane with a Translated Polyomino

    Full text link
    We give a O(n)O(n)-time algorithm for determining whether translations of a polyomino with nn edges can tile the plane. The algorithm is also a O(n)O(n)-time algorithm for enumerating all such tilings that are also regular, and we prove that at most Θ(n)\Theta(n) such tilings exist.Comment: In proceedings of ISAAC 201

    On the Necessary Memory to Compute the Plurality in Multi-Agent Systems

    Get PDF
    We consider the Relative-Majority Problem (also known as Plurality), in which, given a multi-agent system where each agent is initially provided an input value out of a set of kk possible ones, each agent is required to eventually compute the input value with the highest frequency in the initial configuration. We consider the problem in the general Population Protocols model in which, given an underlying undirected connected graph whose nodes represent the agents, edges are selected by a globally fair scheduler. The state complexity that is required for solving the Plurality Problem (i.e., the minimum number of memory states that each agent needs to have in order to solve the problem), has been a long-standing open problem. The best protocol so far for the general multi-valued case requires polynomial memory: Salehkaleybar et al. (2015) devised a protocol that solves the problem by employing O(k2k)O(k 2^k) states per agent, and they conjectured their upper bound to be optimal. On the other hand, under the strong assumption that agents initially agree on a total ordering of the initial input values, Gasieniec et al. (2017), provided an elegant logarithmic-memory plurality protocol. In this work, we refute Salehkaleybar et al.'s conjecture, by providing a plurality protocol which employs O(k11)O(k^{11}) states per agent. Central to our result is an ordering protocol which allows to leverage on the plurality protocol by Gasieniec et al., of independent interest. We also provide a Ω(k2)\Omega(k^2)-state lower bound on the necessary memory to solve the problem, proving that the Plurality Problem cannot be solved within the mere memory necessary to encode the output.Comment: 14 pages, accepted at CIAC 201

    Logics for Reversible Regular Languages and Semigroups with Involution

    Full text link
    We present MSO and FO logics with predicates `between' and `neighbour' that characterise various fragments of the class of regular languages that are closed under the reverse operation. The standard connections that exist between MSO and FO logics and varieties of finite semigroups extend to this setting with semigroups extended with an involution. The case is different for FO with neighbour relation where we show that one needs additional equations to characterise the class.Comment: Accepted for DLT 201

    A Minimal Periods Algorithm with Applications

    Full text link
    Kosaraju in ``Computation of squares in a string'' briefly described a linear-time algorithm for computing the minimal squares starting at each position in a word. Using the same construction of suffix trees, we generalize his result and describe in detail how to compute in O(k|w|)-time the minimal k-th power, with period of length larger than s, starting at each position in a word w for arbitrary exponent k2k\geq2 and integer s0s\geq0. We provide the complete proof of correctness of the algorithm, which is somehow not completely clear in Kosaraju's original paper. The algorithm can be used as a sub-routine to detect certain types of pseudo-patterns in words, which is our original intention to study the generalization.Comment: 14 page

    Leader Election in Anonymous Rings: Franklin Goes Probabilistic

    Get PDF
    We present a probabilistic leader election algorithm for anonymous, bidirectional, asynchronous rings. It is based on an algorithm from Franklin, augmented with random identity selection, hop counters to detect identity clashes, and round numbers modulo 2. As a result, the algorithm is finite-state, so that various model checking techniques can be employed to verify its correctness, that is, eventually a unique leader is elected with probability one. We also sketch a formal correctness proof of the algorithm for rings with arbitrary size

    Synchronizing Objectives for Markov Decision Processes

    Get PDF
    We introduce synchronizing objectives for Markov decision processes (MDP). Intuitively, a synchronizing objective requires that eventually, at every step there is a state which concentrates almost all the probability mass. In particular, it implies that the probabilistic system behaves in the long run like a deterministic system: eventually, the current state of the MDP can be identified with almost certainty. We study the problem of deciding the existence of a strategy to enforce a synchronizing objective in MDPs. We show that the problem is decidable for general strategies, as well as for blind strategies where the player cannot observe the current state of the MDP. We also show that pure strategies are sufficient, but memory may be necessary.Comment: In Proceedings iWIGP 2011, arXiv:1102.374

    Complementation of Rational Sets on Scattered Linear Orderings of Finite Rank

    Get PDF
    International audienceIn a preceding paper, automata have been introduced for words indexed by linear orderings. These automata are a generalization of automata for finite, infinite, bi-finite and even transfinite words studied by Buchi Kleene's theorem has been generalized to these words. We show that deterministic automata do not have the same expressive power. Despite this negative result, we prove that rational sets of words of finite ranks are closed under complementation

    Fast Approximate Counting and Leader Election in Populations

    Get PDF
    We study the problems of leader election and population size counting for population protocols: networks of finite-state anonymous agents that interact randomly under a uniform random scheduler. We show a protocol for leader election that terminates in O(logm(n)log2n)O(\log_m(n) \cdot \log_2 n) parallel time, where mm is a parameter, using O(max{m,logn})O(\max\{m,\log n\}) states. By adjusting the parameter mm between a constant and nn, we obtain a single leader election protocol whose time and space can be smoothly traded off between O(log2n)O(\log^2 n) to O(logn)O(\log n) time and O(logn)O(\log n) to O(n)O(n) states. Finally, we give a protocol which provides an upper bound n^\hat{n} of the size nn of the population, where n^\hat{n} is at most nan^a for some a>1a>1. This protocol assumes the existence of a unique leader in the population and stabilizes in Θ(logn)\Theta{(\log{n})} parallel time, using constant number of states in every node, except the unique leader which is required to use Θ(log2n)\Theta{(\log^2{n})} states
    corecore