64 research outputs found
Linear Time LexDFS on Cocomparability Graphs
Lexicographic depth first search (LexDFS) is a graph search protocol which
has already proved to be a powerful tool on cocomparability graphs.
Cocomparability graphs have been well studied by investigating their
complements (comparability graphs) and their corresponding posets. Recently
however LexDFS has led to a number of elegant polynomial and near linear time
algorithms on cocomparability graphs when used as a preprocessing step [2, 3,
11]. The nonlinear runtime of some of these results is a consequence of
complexity of this preprocessing step. We present the first linear time
algorithm to compute a LexDFS cocomparability ordering, therefore answering a
problem raised in [2] and helping achieve the first linear time algorithms for
the minimum path cover problem, and thus the Hamilton path problem, the maximum
independent set problem and the minimum clique cover for this graph family
On Convergence and Threshold Properties of Discrete Lotka-Volterra Population Protocols
In this work we focus on a natural class of population protocols whose
dynamics are modelled by the discrete version of Lotka-Volterra equations. In
such protocols, when an agent of type (species) interacts with an agent
of type (species) with as the initiator, then 's type becomes
with probability . In such an interaction, we think of as the
predator, as the prey, and the type of the prey is either converted to that
of the predator or stays as is. Such protocols capture the dynamics of some
opinion spreading models and generalize the well-known Rock-Paper-Scissors
discrete dynamics. We consider the pairwise interactions among agents that are
scheduled uniformly at random. We start by considering the convergence time and
show that any Lotka-Volterra-type protocol on an -agent population converges
to some absorbing state in time polynomial in , w.h.p., when any pair of
agents is allowed to interact. By contrast, when the interaction graph is a
star, even the Rock-Paper-Scissors protocol requires exponential time to
converge. We then study threshold effects exhibited by Lotka-Volterra-type
protocols with 3 and more species under interactions between any pair of
agents. We start by presenting a simple 4-type protocol in which the
probability difference of reaching the two possible absorbing states is
strongly amplified by the ratio of the initial populations of the two other
types, which are transient, but "control" convergence. We then prove that the
Rock-Paper-Scissors protocol reaches each of its three possible absorbing
states with almost equal probability, starting from any configuration
satisfying some sub-linear lower bound on the initial size of each species.
That is, Rock-Paper-Scissors is a realization of a "coin-flip consensus" in a
distributed system. Some of our techniques may be of independent value
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
Approximating Fixation Probabilities in the Generalized Moran Process
We consider the Moran process, as generalized by Lieberman et al. (Nature 433:312â316, 2005). A population resides on the vertices of a finite, connected, undirected graph and, at each time step, an individual is chosen at random with probability proportional to its assigned âfitnessâ value. It reproduces, placing a copy of itself on a neighbouring vertex chosen uniformly at random, replacing the individual that was there. The initial population consists of a single mutant of fitness r>0 placed uniformly at random, with every other vertex occupied by an individual of fitness 1. The main quantities of interest are the probabilities that the descendants of the initial mutant come to occupy the whole graph (fixation) and that they die out (extinction); almost surely, these are the only possibilities. In general, exact computation of these quantities by standard Markov chain techniques requires solving a system of linear equations of size exponential in the order of the graph so is not feasible. We show that, with high probability, the number of steps needed to reach fixation or extinction is bounded by a polynomial in the number of vertices in the graph. This bound allows us to construct fully polynomial randomized approximation schemes (FPRAS) for the probability of fixation (when râ„1) and of extinction (for all r>0)
The Complexity of Routing with Few Collisions
We study the computational complexity of routing multiple objects through a
network in such a way that only few collisions occur: Given a graph with
two distinct terminal vertices and two positive integers and , the
question is whether one can connect the terminals by at least routes (e.g.
paths) such that at most edges are time-wise shared among them. We study
three types of routes: traverse each vertex at most once (paths), each edge at
most once (trails), or no such restrictions (walks). We prove that for paths
and trails the problem is NP-complete on undirected and directed graphs even if
is constant or the maximum vertex degree in the input graph is constant.
For walks, however, it is solvable in polynomial time on undirected graphs for
arbitrary and on directed graphs if is constant. We additionally study
for all route types a variant of the problem where the maximum length of a
route is restricted by some given upper bound. We prove that this
length-restricted variant has the same complexity classification with respect
to paths and trails, but for walks it becomes NP-complete on undirected graphs
Synthesizing and tuning chemical reaction networks with specified behaviours
We consider how to generate chemical reaction networks (CRNs) from functional
specifications. We propose a two-stage approach that combines synthesis by
satisfiability modulo theories and Markov chain Monte Carlo based optimisation.
First, we identify candidate CRNs that have the possibility to produce correct
computations for a given finite set of inputs. We then optimise the reaction
rates of each CRN using a combination of stochastic search techniques applied
to the chemical master equation, simultaneously improving the of correct
behaviour and ruling out spurious solutions. In addition, we use techniques
from continuous time Markov chain theory to study the expected termination time
for each CRN. We illustrate our approach by identifying CRNs for majority
decision-making and division computation, which includes the identification of
both known and unknown networks.Comment: 17 pages, 6 figures, appeared the proceedings of the 21st conference
on DNA Computing and Molecular Programming, 201
OBDD-Based Representation of Interval Graphs
A graph can be described by the characteristic function of the
edge set which maps a pair of binary encoded nodes to 1 iff the nodes
are adjacent. Using \emph{Ordered Binary Decision Diagrams} (OBDDs) to store
can lead to a (hopefully) compact representation. Given the OBDD as an
input, symbolic/implicit OBDD-based graph algorithms can solve optimization
problems by mainly using functional operations, e.g. quantification or binary
synthesis. While the OBDD representation size can not be small in general, it
can be provable small for special graph classes and then also lead to fast
algorithms. In this paper, we show that the OBDD size of unit interval graphs
is and the OBDD size of interval graphs is $O(\
| V \ | \log \ | V \ |)\Omega(\ | V \ | \log
\ | V \ |)O(\log \ | V \ |)O(\log^2 \ | V \ |)$ operations and
evaluate the algorithms empirically.Comment: 29 pages, accepted for 39th International Workshop on Graph-Theoretic
Concepts 201
Parameterized Domination in Circle Graphs
A circle graph is the intersection graph of a set of chords in a circle. Keil [Discrete Applied Mathematics, 42(1):51-63, 1993] proved that Dominating Set, Connected Dominating Set, and Total Dominating Set are NP-complete in circle graphs. To the best of our knowledge, nothing was known about the parameterized complexity of these problems in circle graphs. In this paper we prove the following results, which contribute in this direction: Dominating Set, Independent Dominating Set, Connected Dominating Set, Total Dominating Set, and Acyclic Dominating Set are W[1]-hard in circle graphs, parameterized by the size of the solution. Whereas both Connected Dominating Set and Acyclic Dominating Set are W[1]-hard in circle graphs, it turns out that Connected Acyclic Dominating Set is polynomial-time solvable in circle graphs. If T is a given tree, deciding whether a circle graph has a dominating set isomorphic to T is NP-complete when T is in the input, and FPT when parameterized by |V(T)|. We prove that the FPT algorithm is subexponential
Approximating Fixation Probabilities in the Generalized Moran Process
We consider the Moran process, as generalized by Lieberman, Hauert and Nowak
(Nature, 433:312--316, 2005). A population resides on the vertices of a finite,
connected, undirected graph and, at each time step, an individual is chosen at
random with probability proportional to its assigned 'fitness' value. It
reproduces, placing a copy of itself on a neighbouring vertex chosen uniformly
at random, replacing the individual that was there. The initial population
consists of a single mutant of fitness placed uniformly at random, with
every other vertex occupied by an individual of fitness 1. The main quantities
of interest are the probabilities that the descendants of the initial mutant
come to occupy the whole graph (fixation) and that they die out (extinction);
almost surely, these are the only possibilities. In general, exact computation
of these quantities by standard Markov chain techniques requires solving a
system of linear equations of size exponential in the order of the graph so is
not feasible. We show that, with high probability, the number of steps needed
to reach fixation or extinction is bounded by a polynomial in the number of
vertices in the graph. This bound allows us to construct fully polynomial
randomized approximation schemes (FPRAS) for the probability of fixation (when
) and of extinction (for all ).Comment: updated to the final version, which appeared in Algorithmic
The temporal explorer who returns to the base.
In this paper we study the problem of exploring a temporal graph (i.e. a graph that changes over time), in the fundamental case where the underlying static graph is a star on n vertices. The aim of the exploration problem in a temporal star is to find a temporal walk which starts at the center of the star, visits all leaves, and eventually returns back to the center. We present here a systematic study of the computational complexity of this problem, depending on the number k of time-labels that every edge is allowed to have; that is, on the number k of time points where each edge can be present in the graph. To do so, we distinguish between the decision version STAREXP(k) , asking whether a complete exploration of the instance exists, and the maximization version MAXSTAREXP(k) of the problem, asking for an exploration schedule of the greatest possible number of edges in the star. We fully characterize MAXSTAREXP(k) and show a dichotomy in terms of its complexity: on one hand, we show that for both k=2 and k=3 , it can be efficiently solved in O(nlogn) time; on the other hand, we show that it is APX-complete, for every kâ„4 (does not admit a PTAS, unless P = NP, but admits a polynomial-time 1.582-approximation algorithm). We also partially characterize STAREXP(k) in terms of complexity: we show that it can be efficiently solved in O(nlogn) time for kâ{2,3} (as a corollary of the solution to MAXSTAREXP(k) , for kâ{2,3} ), but is NP-complete, for every kâ„6
- âŠ