arXiv subjects

Boaz Patt-Shamir

Publications and source records attributed to Boaz Patt-Shamir.

17 recordsLinked to original sources

arXiv2026

Consensus with Stochastic Broadcast

We study binary consensus in the \emph{stochastic broadcast model}, which assumes $n\geq 2$ processes communicating synchronously by message broadcasts. At each round, every process broadcasts a message to all the other processes. Each broadcast succeeds independently with some probability $p\in[0,1]$. If a broadcast succeeds, all processes receive the message, and if it fails, no process receives the message. The sender does not know whether its broadcast was successful or not. In this model, consensus is not solvable; the objective is to design, for a given number of rounds $r$, consensus algorithms that terminate in $r$ rounds, minimizing the probability of error disagreement. This problem has been studied in depth for 2 processes [DISC 2025]. We extend the study to $n> 2$.

cs.DC↗

arXiv2025

Colorful Vertex Recoloring of Bipartite Graphs

In vertex recoloring, we are given $n$ vertices with their initial coloring, and edges arrive in an online fashion. The algorithm must maintain a valid coloring by recoloring vertices, at a cost. The problem abstracts a scenario of job placement in machines (possibly in the cloud), where vertices represent jobs, colors represent machines, and edges represent ``anti affinity'' (disengagement) constraints. Online recoloring is a hard problem. One family of instances which is fairly well-understood is bipartite graphs, in which two colors are sufficient to satisfy all constraints. In this case it is known that the competitive ratio of vertex recoloring is $Θ(\log n)$. We propose a generalization of the problem, which allows using additional colors (possibly at a higher cost), to improve overall performance. We analyze the simple case of bipartite graphs of bounded largest \emph{bond} (a bond of a connected graph is an edge-cut that partitions the graph into two connected components). First, we propose two algorithms. One exhibits a trade-off for the uniform-cost case: given $Ω(\logβ)\le c\le O(\log n)$ colors, the algorithm guarantees that its cost is at most $O(\frac{\log n}{c})$ times the optimal offline cost for two colors, where $n$ is the number of vertices and $β$ is the size of the largest bond. The other algorithm is for the case where the additional colors come at a higher cost, $D>1$: given $Δ$ additional colors, where $Δ$ is the maximum degree in the graph, the algorithm guarantees $O(\log D)$ competitiveness. As to lower bounds, we show that if the cost of the extra colors is $D>1$, no (randomized) algorithm can achieve a competitive ratio of $o(\log D)$. We also show that for bipartite graphs of unbounded bond size, any deterministic online algorithm has competitive ratio $Ω(\min(D,\log n))$.

cs.DS↗

arXiv2021

Distributed Computing With the Cloud

We investigate the effect of omnipresent cloud storage on distributed computing. We specify a network model with links of prescribed bandwidth that connect standard processing nodes, and, in addition, passive storage nodes. Each passive node represents a cloud storage system, such as Dropbox, Google Drive etc. We study a few tasks in this model, assuming a single cloud node connected to all other nodes, which are connected to each other arbitrarily. We give implementations for basic tasks of collaboratively writing to and reading from the cloud, and for more advanced applications such as matrix multiplication and federated learning. Our results show that utilizing node-cloud links as well as node-node links can considerably speed up computations, compared to the case where processors communicate either only through the cloud or only through the network links. We provide results for general directed graphs, and for graphs with ``fat'' links between processing nodes. For the general case, we provide optimal algorithms for uploading and downloading files using flow techniques. We use these primitives to derive algorithms for \emph{combining}, where every processor node has an input value and the task is to compute a combined value under some given associative operator. In the case of fat links, we assume that links between processors are bidirectional and have high bandwidth, and we give near-optimal algorithms for any commutative combining operator (such as vector addition). For the task of matrix multiplication (or other non-commutative combining operators), where the inputs are ordered, we present sharp results in the simple ``wheel'' network, where procesing nodes are arranged in a ring, and are all connected to a single cloud node.

cs.DC↗

arXiv2019

With Great Speed Come Small Buffers: Space-Bandwidth Tradeoffs for Routing

We consider the Adversarial Queuing Theory (AQT) model, where packet arrivals are subject to a maximum average rate $0\leρ\le1$ and burstiness $σ\ge0$. In this model, we analyze the size of buffers required to avoid overflows in the basic case of a path. Our main results characterize the space required by the average rate and the number of distinct destinations: we show that $O(k d^{1/k})$ space suffice, where $d$ is the number of distinct destinations and $k=\lfloor 1/ρ\rfloor$; and we show that $Ω(\frac 1 k d^{1/k})$ space is necessary. For directed trees, we describe an algorithm whose buffer space requirement is at most $1 + d' + σ$ where $d'$ is the maximum number of destinations on any root-leaf path.

cs.DS↗

arXiv2017

Proof-Labeling Schemes: Broadcast, Unicast and In Between

We study the effect of limiting the number of different messages a node can transmit simultaneously on the verification complexity of proof-labeling schemes (PLS). In a PLS, each node is given a label, and the goal is to verify, by exchanging messages over each link in each direction, that a certain global predicate is satisfied by the system configuration. We consider a single parameter r that bounds the number of distinct messages that can be sent concurrently by any node: in the case r=1, each node may only send the same message to all its neighbors (the broadcast model), in the case r is at least Delta, where Delta is the largest node degree in the system, each neighbor may be sent a distinct message (the unicast model), and in general, for r between 1 and Delta, each of the r messages is destined to a subset of the neighbors. We show that message compression linear in r is possible for verifying fundamental problems such as the agreement between edge endpoints on the edge state. Some problems, including verification of maximal matching, exhibit a large gap in complexity between r=1 and r>1. For some other important predicates, the verification complexity is insensitive to r, e.g., the question whether a subset of edges constitutes a spanning-tree. We also consider the congested clique model. We show that the crossing technique for proving lower bounds on the verification complexity can be applied in the case of congested clique only if r=1. Together with a new upper bound, this allows us to determine the verification complexity of MST in the broadcast clique. Finally, we establish a general connection between the deterministic and randomized verification complexity for any given number r.

cs.DC↗

arXiv2017

Buffer Size for Routing Limited-Rate Adversarial Traffic

We consider the slight variation of the adversarial queuing theory model, in which an adversary injects packets with routes into the network subject to the following constraint: For any link $e$, the total number of packets injected in any time window $[t,t')$ and whose route contains $e$, is at most $ρ(t'-t)+σ$, where $ρ$ and $σ$ are non-negative parameters. Informally, $ρ$ bounds the long-term rate of injections and $σ$ bounds the "burstiness" of injection: $σ=0$ means that the injection is as smooth as it can be. It is known that greedy scheduling of the packets (under which a link is not idle if there is any packet ready to be sent over it) may result in $Ω(n)$ buffer size even on an $n$-line network and very smooth injections ($σ=0$). In this paper we propose a simple non-greedy scheduling policy and show that, in a tree where all packets are destined at the root, no buffer needs to be larger than $σ+2ρ$ to ensure that no overflows occur, which is optimal in our model. The rule of our algorithm is to forward a packet only if its next buffer is completely empty. The policy is centralized: in a single step, a long "train" of packets may progress together. We show that in some sense central coordination is required, by presenting an injection pattern with $σ=0$ for the $n$-node line that results in $Ω(n)$ packets in a buffer if local control is used, even for the more sophisticated "downhill" algorithm, which forwards a packet only if its next buffer is less occupied than its current one.

cs.DC↗

arXiv2017

Stable Secretaries

We define and study a new variant of the secretary problem. Whereas in the classic setting multiple secretaries compete for a single position, we study the case where the secretaries arrive one at a time and are assigned, in an on-line fashion, to one of multiple positions. Secretaries are ranked according to talent, as in the original formulation, and in addition positions are ranked according to attractiveness. To evaluate an online matching mechanism, we use the notion of blocking pairs from stable matching theory: our goal is to maximize the number of positions (or secretaries) that do not take part in a blocking pair. This is compared with a stable matching in which no blocking pair exists. We consider the case where secretaries arrive randomly, as well as that of an adversarial arrival order, and provide corresponding upper and lower bounds.

cs.GT↗

arXiv2017

On the Probe Complexity of Local Computation Algorithms

The Local Computation Algorithms (LCA) model is a computational model aimed at problem instances with huge inputs and output. For graph problems, the input graph is accessed using probes: strong probes (SP) specify a vertex $v$ and receive as a reply a list of $v$'s neighbors, and weak probes (WP) specify a vertex $v$ and a port number $i$ and receive as a reply $v$'s $i^{th}$ neighbor. Given a local query (e.g., "is a certain vertex in the vertex cover of the input graph?"), an LCA should compute the corresponding local output (e.g., "yes" or "no") while making only a small number of probes, with the requirement that all local outputs form a single global solution (e.g., a legal vertex cover). We study the probe complexity of LCAs that are required to work on graphs that may have arbitrarily large degrees. In particular, such LCAs are expected to probe the graph a number of times that is significantly smaller than the maximum, average, or even minimum degree. For weak probes, we focus on the weak coloring problem. Among our results we show a separation between weak 3-coloring and weak 2-coloring for deterministic LCAs: $\log^* n + O(1)$ weak probes suffice for weak 3-coloring, but $Ω\left(\frac{\log n}{\log\log n}\right)$ weak probes are required for weak 2-coloring. For strong probes, we consider randomized LCAs for vertex cover and maximal/maximum matching. Our negative results include showing that there are graphs for which finding a \emph{maximal} matching requires $Ω(\sqrt{n})$ strong probes. On the positive side, we design a randomized LCA that finds a $(1-ε)$ approximation to \emph{maximum} matching in regular graphs, and uses $\frac{1}{ε}^{O\left( \frac{1}{ε^2}\right)}$ probes, independently of the number of vertices and of their degrees.

cs.DS↗

arXiv2016

Competitive Path Computation and Function Placement in SDNs

We consider a task of serving requests that arrive in an online fashion in Software-Defined Networks (SDNs) with network function virtualization (NFV). Each request specifies an abstract routing and processing "plan" for a flow. Each processing function can be performed by a specified subset of servers in the system. The algorithm needs to either reject the request or admit it and return detailed routing (a.k.a. "path computation") and processing assignment ("function placement"). Each request also specifies the communication bandwidth and the processing load it requires. Components in the system (links and processors) have bounded capacity; a feasible solution may not violate the capacity constraints. Requests have benefits and the goal is to maximize the total benefit of accepted requests. In this paper we first formalize the problem, and propose a new service model that allows us to cope with requests with unknown duration. The new service model augments the traditional accept/reject schemes with a new possible response of "stand by." Our main result is an online algorithm for path computation and function placement that guarantees, in each time step, throughput of at least $Ω\left(\frac{\text{OPT}^*}{\log n}\right)$, where $n$ is the system size and $\text{OPT}^*$ is an upper bound on the maximal possible throughput. The guarantee holds assuming that requests ask for at most an $O\left(1/{\log n}\right)$-fraction of the capacity of any component in the system. Furthermore, the guarantee holds even though our algorithm serves requests in an all-or-nothing fashion using a single path and never preempts accepted flows, while $\text{OPT}^*$ may serve fractional requests, may split the allocation over multiple paths, and may arbitrarily preempt and resume service of requests.

cs.DS↗

arXiv2015

Near-Optimal Distributed Maximum Flow

We present a near-optimal distributed algorithm for $(1+o(1))$-approximation of single-commodity maximum flow in undirected weighted networks that runs in $(D+ \sqrt{n})\cdot n^{o(1)}$ communication rounds in the \Congest model. Here, $n$ and $D$ denote the number of nodes and the network diameter, respectively. This is the first improvement over the trivial bound of $O(n^2)$, and it nearly matches the $\tildeΩ(D+ \sqrt{n})$ round complexity lower bound. The development of the algorithm contains two results of independent interest: (i) A $(D+\sqrt{n})\cdot n^{o(1)}$-round distributed construction of a spanning tree of average stretch $n^{o(1)}$. (ii) A $(D+\sqrt{n})\cdot n^{o(1)}$-round distributed construction of an $n^{o(1)}$-congestion approximator consisting of the cuts induced by $O(\log n)$ virtual trees. The distributed representation of the cut approximator allows for evaluation in $(D+\sqrt{n})\cdot n^{o(1)}$ rounds. All our algorithms make use of randomization and succeed with high probability.

cs.DS↗

arXiv2015

Better Online Deterministic Packet Routing on Grids

We consider the following fundamental routing problem. An adversary inputs packets arbitrarily at sources, each packet with an arbitrary destination. Traffic is constrained by link capacities and buffer sizes, and packets may be dropped at any time. The goal of the routing algorithm is to maximize throughput, i.e., route as many packets as possible to their destination. Our main result is an $O\left(\log n\right)$-competitive deterministic algorithm for an $n$-node line network (i.e., $1$-dimensional grid), requiring only that buffers can store at least $5$ packets, and that links can deliver at least $5$ packets per step. We note that $O(\log n)$ is the best ratio known, even for randomized algorithms, even when allowed large buffers and wide links. The best previous deterministic algorithm for this problem with constant-size buffers and constant-capacity links was $O(\log^5 n)$-competitive. Our algorithm works like admission-control algorithms in the sense that if a packet is not dropped immediately upon arrival, then it is "accepted" and guaranteed to be delivered. We also show how to extend our algorithm to a polylog-competitive algorithm for any constant-dimension grid.

cs.DS↗

arXiv2014

Fast Partial Distance Estimation and Applications

We study approximate distributed solutions to the weighted {\it all-pairs-shortest-paths} (APSP) problem in the CONGEST model. We obtain the following results. $1.$ A deterministic $(1+o(1))$-approximation to APSP in $\tilde{O}(n)$ rounds. This improves over the best previously known algorithm, by both derandomizing it and by reducing the running time by a $Θ(\log n)$ factor. In many cases, routing schemes involve relabeling, i.e., assigning new names to nodes and require that these names are used in distance and routing queries. It is known that relabeling is necessary to achieve running times of $o(n/\log n)$. In the relabeling model, we obtain the following results. $2.$ A randomized $O(k)$-approximation to APSP, for any integer $k>1$, running in $\tilde{O}(n^{1/2+1/k}+D)$ rounds, where $D$ is the hop diameter of the network. This algorithm simplifies the best previously known result and reduces its approximation ratio from $O(k\log k)$ to $O(k)$. Also, the new algorithm uses uses labels of asymptotically optimal size, namely $O(\log n)$ bits. $3.$ A randomized $O(k)$-approximation to APSP, for any integer $k>1$, running in time $\tilde{O}((nD)^{1/2}\cdot n^{1/k}+D)$ and producing {\it compact routing tables} of size $\tilde{O}(n^{1/k})$. The node lables consist of $O(k\log n)$ bits. This improves on the approximation ratio of $Θ(k^2)$ for tables of that size achieved by the best previously known algorithm, which terminates faster, in $\tilde{O}(n^{1/2+1/k}+D)$ rounds.

cs.DC↗

arXiv2014

Improved Distributed Steiner Forest Construction

We present new distributed algorithms for constructing a Steiner Forest in the CONGEST model. Our deterministic algorithm finds, for any given constant $ε>0$, a $(2+ε)$-approximation in $\tilde{O}(sk+\sqrt{\min(st,n)})$ rounds, where $s$ is the shortest path diameter, $t$ is the number of terminals, $k$ is the number of terminal components in the input, and $n$ is the number of nodes. Our randomized algorithm finds, with high probability, an $O(\log n)$- approximation in time $\tilde{O}(k+\min(s,\sqrt n)+D)$, where $D$ is the unweighted diameter of the network. We also prove a matching lower bound of $\tildeΩ(k+\min(s,\sqrt{n})+D)$ on the running time of any distributed approximation algorithm for the Steiner Forest problem. Previous algorithms were randomized, and obtained either an $O(\log n)$-approximation in $\tilde{O}(sk)$ time, or an $O(1/ε)$-approximation in $\tilde{O}((\sqrt{n}+t)^{1+ε}+D)$ time.

cs.DC↗

arXiv2012

Fast Routing Table Construction Using Small Messages

We describe a distributed randomized algorithm computing approximate distances and routes that approximate shortest paths. Let n denote the number of nodes in the graph, and let HD denote the hop diameter of the graph, i.e., the diameter of the graph when all edges are considered to have unit weight. Given 0 < eps <= 1/2, our algorithm runs in weak-O(n^(1/2 + eps) + HD) communication rounds using messages of O(log n) bits and guarantees a stretch of O(eps^(-1) log eps^(-1)) with high probability. This is the first distributed algorithm approximating weighted shortest paths that uses small messages and runs in weak-o(n) time (in graphs where HD in weak-o(n)). The time complexity nearly matches the lower bounds of weak-Omega(sqrt(n) + HD) in the small-messages model that hold for stateless routing (where routing decisions do not depend on the traversed path) as well as approximation of the weigthed diameter. Our scheme replaces the original identifiers of the nodes by labels of size O(log eps^(-1) log n). We show that no algorithm that keeps the original identifiers and runs for weak-o(n) rounds can achieve a polylogarithmic approximation ratio. Variations of our techniques yield a number of fast distributed approximation algorithms solving related problems using small messages. Specifically, we present algorithms that run in weak-O(n^(1/2 + eps) + HD) rounds for a given 0 < eps <= 1/2, and solve, with high probability, the following problems: - O(eps^(-1))-approximation for the Generalized Steiner Forest (the running time in this case has an additive weak-O(t^(1 + 2eps)) term, where t is the number of terminals); - O(eps^(-2))-approximation of weighted distances, using node labels of size O(eps^(-1) log n) and weak-O(n^(eps)) bits of memory per node; - O(eps^(-1))-approximation of the weighted diameter; - O(eps^(-3))-approximate shortest paths using the labels 1,...,n.

cs.DC↗

arXiv2009

Vector Bin Packing with Multiple-Choice

We consider a variant of bin packing called multiple-choice vector bin packing. In this problem we are given a set of items, where each item can be selected in one of several $D$-dimensional incarnations. We are also given $T$ bin types, each with its own cost and $D$-dimensional size. Our goal is to pack the items in a set of bins of minimum overall cost. The problem is motivated by scheduling in networks with guaranteed quality of service (QoS), but due to its general formulation it has many other applications as well. We present an approximation algorithm that is guaranteed to produce a solution whose cost is about $\ln D$ times the optimum. For the running time to be polynomial we require $D=O(1)$ and $T=O(\log n)$. This extends previous results for vector bin packing, in which each item has a single incarnation and there is only one bin type. To obtain our result we also present a PTAS for the multiple-choice version of multidimensional knapsack, where we are given only one bin and the goal is to pack a maximum weight set of (incarnations of) items in that bin.

cs.DS↗

arXiv2009

Distributed Discovery of Large Near-Cliques

Given an undirected graph and $0\leε\le1$, a set of nodes is called $ε$-near clique if all but an $ε$ fraction of the pairs of nodes in the set have a link between them. In this paper we present a fast synchronous network algorithm that uses small messages and finds a near-clique. Specifically, we present a constant-time algorithm that finds, with constant probability of success, a linear size $ε$-near clique if there exists an $ε^3$-near clique of linear size in the graph. The algorithm uses messages of $O(\log n)$ bits. The failure probability can be reduced to $n^{-Ω(1)}$ in $O(\log n)$ time, and the algorithm also works if the graph contains a clique of size $Ω(n/\log^α\log n)$ for some $α\in (0,1)$.

cs.DC↗

arXiv2008

Rent, Lease or Buy: Randomized Algorithms for Multislope Ski Rental

In the Multislope Ski Rental problem, the user needs a certain resource for some unknown period of time. To use the resource, the user must subscribe to one of several options, each of which consists of a one-time setup cost (``buying price''), and cost proportional to the duration of the usage (``rental rate''). The larger the price, the smaller the rent. The actual usage time is determined by an adversary, and the goal of an algorithm is to minimize the cost by choosing the best option at any point in time. Multislope Ski Rental is a natural generalization of the classical Ski Rental problem (where the only options are pure rent and pure buy), which is one of the fundamental problems of online computation. The Multislope Ski Rental problem is an abstraction of many problems where online decisions cannot be modeled by just two options, e.g., power management in systems which can be shut down in parts. In this paper we study randomized algorithms for Multislope Ski Rental. Our results include the best possible online randomized strategy for any additive instance, where the cost of switching from one option to another is the difference in their buying prices; and an algorithm that produces an $e$-competitive randomized strategy for any (non-additive) instance.

cs.DS↗