101 research outputs found
Global Versus Local Computations: Fast Computing with Identifiers
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 , 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
, 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
We give a -time algorithm for determining whether translations of a
polyomino with edges can tile the plane. The algorithm is also a
-time algorithm for enumerating all such tilings that are also regular,
and we prove that at most such tilings exist.Comment: In proceedings of ISAAC 201
On the Necessary Memory to Compute the Plurality in Multi-Agent Systems
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 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 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 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
-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
A Minimal Periods Algorithm with Applications
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 and integer . 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
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
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
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
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 parallel time, where is a parameter, using states. By adjusting the parameter between a constant and , we obtain a single leader election protocol whose time and space can be smoothly traded off between to time and to states. Finally, we give a protocol which provides an upper bound of the size of the population, where is at most for some . This protocol assumes the existence of a unique leader in the population and stabilizes in parallel time, using constant number of states in every node, except the unique leader which is required to use states
Private Identity Agreement for Private Set Functionalities
Private set intersection and related functionalities are among the most prominent real-world applications of secure multiparty computation. While such protocols have attracted significant attention from the research community, other functionalities are often required to support a PSI application in practice. For example, in order for two parties to run a PSI over the unique users contained in their databases, they might first invoke on a support functionality to agree on the primary keys to represent their users.
This paper studies a secure approach to agreeing on primary keys. We introduce and realize a functionality that computes a common set of identifiers based on incomplete information held by two parties, which we refer to as private identity agreement. We explain the subtleties in designing such a functionality that arise from privacy requirements when intending to compose securely with PSI protocols. We also argue that the cost of invoking this functionality can be amortized over a large number of PSI sessions, and that for applications that require many repeated PSI executions, this represents an improvement over a PSI protocol that directly uses incomplete or fuzzy matches
- …