The online bisection problem requires maintaining a dynamic partition of n nodes into two equal-sized clusters. Requests arrive sequentially as node pairs. If the nodes lie in different clusters, the algorithm pays unit cost. After each request, the algorithm may migrate nodes between clusters at unit cost per node. This problem models datacenter resource allocation where virtual machines must be assigned to servers, balancing communication costs against migration overhead. We study the variant where requests are restricted to edges of a ring network, an abstraction of ring-allreduce patterns in distributed machine learning. Despite this restriction, the problem remains challenging with an (n) deterministic lower bound. We present a randomized algorithm achieving O(ε ^-3·log ^2 n) competitive ratio using resource augmentation that allows clusters of size at most (3/4 + ε ) · n . Our approach formulates the problem as a metrical task system with a restricted state space. By limiting the number of cut-edges (i.e., ring edges between clusters) to at most 2k, where k = Θ (1/ε ) , we reduce the state space from exponential to polynomial (i.e., n^O(k) ). The key technical contribution is proving that this restriction increases cost by only a factor of O(k). Our algorithm follows by applying the randomized MTS solution of Bubeck et al. [SODA 2019]. The best result to date for bisection with ring demands is the O(n ·log n) -competitive deterministic online algorithm of Rajaraman and Wasim [ESA 2024] for the general setting. While prior work for ring-demands by Räcke et al. [SPAA 2023] achieved O(log ^3 n) for multiple clusters, their approach employs a resource augmentation factor of 2+ε , making it inapplicable to bisection.

We present two constant-time dynamic data-structures that support insertions, deletions, and queries with one-sided errors: a space-efficient dynamic (key-only) filter and a compact dynamic data-structure that combines retrieval and filtering (called a key-value filter). A one-sided error occurs when a query for a key not in the dataset is issued and the outcome is wrong, i.e., a “yes” in a filter or a non-null in the key-value filter. The response to a query with a key in the dataset always returns the correct answer, i.e., a “yes” in a filter and the correct value in a key-value filter. The probability of the one-sided error in our data-structures is (1/(log n)) , where n is the maximum cardinality of the dataset, and the probability space is over the random bits of the data-structure (i.e., random choice of hash function). The computational framework is the Word RAM model. We differentiate between accesses to non-modifiable memory (i.e., read-only memory that stores the program instructions, hash function seed or tables, etc.) and accesses to modifiable memory (i.e., read-write memory that stores the representation of the dataset). We are not aware of previous works that make this distinction in the context of data-structures. Our dynamic filter design requires only a single access to the modifiable memory per operation in the worst-case. We also present a dynamic key-value filter for values of O(loglog n) bits that requires 1+o(1) accesses to the modifiable memory per operation in expectation. Previous dynamic filter designs require, in the worst case, at least two accesses to modifiable memory for queries with keys not in the dataset. Previous dynamic retrieval data-structure designs always require two dictionary accesses for queries with keys not in the dataset even for single bit values. We prove bounds on the number of balls that overflow in a dynamic balls-into-bins random process for a range of bin capacities that extends the Iceberg Lemma of [Bender et al., JACM 2023]. The correctness of the key-value filter is based on the previously unstudied natural case of unit-capacity bins with more bins than balls. Finally, we observe that the splitting technique for achieving succinct representation of hash functions is not necessary for our data-structures.

We present the first hardware design that supports operations over the Fano–Elias encoding (FE-encoding). Our design is a combinational circuit (i.e., single clock cycle) that supports insertions, deletions, and queries. FE-encoding allows one to store f binary strings, each of length ℓ + log m using a string that is m + f + f ℓ bits long (rather than f ( ℓ + log m )). The asymptotic gate-count of the circuit is Θ ( ( m + f ) ⋅ lg m + f ⋅ ℓ ). The asymptotic delay is Θ ( lg m + lg f + lg ℓ ). We implemented our design on an FPGA with four combinations of parameters in which the FE-encoding fits in 512 or 1024 bits. We present the first hardware design for a dynamic filter that maintains a set subject to insertions, deletions, and approximate membership queries. The design contains four main blocks: two memory banks that store FE-encodings and two combinational circuits for FE-encoding. Additional logic deals with double buffering and forwarding. We implemented the dynamic filter on an FPGA with the following parameters: (1) Elements in the dataset are 32-bit strings. (2) The supported dataset can contain up to n m a x = 45 ⋅ 2 14 = 737, 280 elements. (3) The latency is 2-4 clock cycles. (4) Fixed (i.e., constant and stable) throughput. A new operation can be issued every clock cycle. (5) We prove that the probability of a false-positive error is bounded by 0 . 385 ⋅ 1 0 − 2. (6) We prove that the expected number of insertion failures is less than 1 for every 75 million insertions. Synthesis of our filter on a Xilinx Alveo U250 FPGA achieves a clock rate of 100 MHz (the critical path is due to the memory access). We measure a fixed throughput of 97.7 million operations per second (the loss of 2.3% in the throughput is due to instabilities in the bandwidth of the AXI4 Lite I/O channel). A unique feature of our filter implementation is that the throughput is stable and constant for all benchmarks and loads. Namely, the combination of operations does not influence the throughput and the throughput does not depend on the number of elements in the dataset (as long as the cardinality of the dataset is bounded by n m a x). Previous dynamic filter implementations in software (implemented on x86 or GPU’s) do not exhibit stable and constant throughputs.

Designs of data structures for approximate membership queries with false-positive errors that support both insertions and deletions stipulate the following two conditions: (1) Duplicate insertions are prohibited, i.e., it is prohibited to insert an element x if x is currently a member of the dataset. (2) Deletions of nonelements are prohibited, i.e., it is prohibited to delete x if x is not currently a member of the dataset. Under these conditions, the space required for the approximate representation of a datasets of cardinality n with a false-positive probability of ϵ^+ is at most (1+o(1))n·log_2 (1/ϵ^+) + O(n) bits [Bender et al., 2018; Bercea and Even, 2019]. We prove that if these conditions are lifted, then the space required for the approximate representation of datasets of cardinality n from a universe of cardinality u is at least 1/2· (1-ϵ^+ -1/n)·logun -O(n) bits.

The dynamic offline linear arrangement problem deals with reordering n elements subject to a sequence of edge requests. The input consists of a sequence of m edges (i.e., unordered pairs of elements). The output is a sequence of permutations (i.e., bijective mapping of the elements to n equidistant points). In step t, the order of the elements is changed to the t-th permutation, and then the t-th request is served. The cost of the output consists of two parts per step: request cost and rearrangement cost. The former is the current distance between the endpoints of the request, while the latter is proportional to the number of adjacent element swaps required to move from one permutation to the consecutive permutation. The goal is to find a minimum cost solution. We present a deterministic O(log n log log n)-approximation algorithm for this problem, improving over a randomized O(log(2) n)-approximation by Olver et al. [22]. Our algorithm is based on first solving spreading-metric LP relaxation on a time-expanded graph, applying a tree decomposition on the basis of the LP solution, and finally converting the tree decomposition to a sequence of permutations. The techniques we employ are general and have the potential to be useful for other dynamic graph optimization problems.

We present the first parallel architecture for a dynamic approximate membership data-structure (i.e., a filter) that supports insertions, deletions, and approximate membership queries. Our architecture borrows techniques from PRAM emulation to obtain a parallel filter based on two levels of fingerprint-dictionaries. A key component in the architecture is a special-purpose wide-word processor we designed to support operations over small dictionaries. We implemented this architecture on an FPGA running at 100MHz. The implementation stores up to 1.44 million keys, has a false-positive rate less than 0.3%, receives batches 16 of operations per cycle, preserves sequential order, and runs with a stable throughput of over a billion operations per second with respect to several benchmarks.

Many applications of approximate membership query data structures, or filters , require only an incremental filter that supports insertions but not deletions. However, the design space of incremental filters is missing a "sweet spot" filter that combines space efficiency, fast queries, and fast insertions. Incremental filters, such as the Bloom and blocked Bloom filter, are not space efficient. Dynamic filters (i.e., supporting deletions), such as the cuckoo or vector quotient filter, are space efficient but do not exhibit consistently fast insertions and queries. In this paper, we propose the prefix filter , an incremental filter that addresses the above challenge: (1) its space (in bits) is similar to state-of-the-art dynamic filters; (2) query throughput is high and is comparable to that of the cuckoo filter; and (3) insert throughput is high with overall build times faster than those of the vector quotient filter and cuckoo filter by 1.39X--1.46X and 3.2X--3.5X, respectively. We present a rigorous analysis of the prefix filter that holds also for practical set sizes (i.e., n = 2 25 ). The analysis deals with the probability of failure, false positive rate, and probability that an operation requires accessing more than a single cache line.

Many applications of approximate membership query data structures, or filters , require only an incremental filter that supports insertions but not deletions. However, the design space of incremental filters is missing a "sweet spot" filter that combines space efficiency, fast queries, and fast insertions. Incremental filters, such as the Bloom and blocked Bloom filter, are not space efficient. Dynamic filters (i.e., supporting deletions), such as the cuckoo or vector quotient filter, are space efficient but do not exhibit consistently fast insertions and queries. In this paper, we propose the prefix filter , an incremental filter that addresses the above challenge: (1) its space (in bits) is similar to state-of-the-art dynamic filters; (2) query throughput is high and is comparable to that of the cuckoo filter; and (3) insert throughput is high with overall build times faster than those of the vector quotient filter and cuckoo filter by 1.39X--1.46X and 3.2X--3.5X, respectively. We present a rigorous analysis of the prefix filter that holds also for practical set sizes (i.e., n = 2 25 ). The analysis deals with the probability of failure, false positive rate, and probability that an operation requires accessing more than a single cache line.

We resolve the open problem posed by Arbitman, Naor, and Segev [FOCS 2010] of designing a dynamic dictionary for multisets in the following setting: (1) The dictionary supports multiplicity queries and allows insertions and deletions to the multiset. (2) The dictionary is designed to support multisets of cardinality at most n (i.e., including multiplicities). (3) The space required for the dictionary is (1+o(1))· nlogu/n + (n) bits, where u denotes the cardinality of the universe of the elements. This space is 1+o(1) times the information-theoretic lower bound for static dictionaries over multisets of cardinality n if u=ω (n) . (4) All operations are completed in constant time in the worst case with high probability in the word RAM model. A direct consequence of our construction is the first dynamic counting filter (i.e., a dynamic data structure that supports approximate multiplicity queries with a one-sided error) that, with high probability, supports operations in constant time and requires space that is 1+o(1) times the information-theoretic lower bound for filters plus O(n) bits. The main technical component of our solution is based on efficiently storing variable-length bounded binary counters and its analysis via weighted balls-into-bins experiments in which the weight of a ball is logarithmic in its multiplicity.

We consider the problem of dynamically assigning.. elements unique indices, known as hashcodes, in the range [( 1 + o (1))n]. This problem is known as perfect hashing and is considered a fundamental building block in the design of more involved data structures. The challenge we address is that of designing a data structure that meets several, seemingly opposing, requirements: (1) the range and the space of the data structure must be, at all times, proportional to the current cardinality n(t) of the input set, and (2) the hashcodes it assigns must be stable in that the hashcode of an element must not change while the element is continuously in the set. A simple argument shows that these two desiderata are impossible to achieve when arbitrary deletions and insertions are allowed. In this paper, we show that one can achieve them when only insertions occur and, more generally, when the hashcode range and the space are allowed to grow as a function of the maximum cardinality N-t of the set until time t. The data structure executes all operations in worst case constant time with high probability and requires space that is within a constant factor of the lower bound. In particular, this leads to a hash table design that does not need to move elements as its size grows. More generally, we present, as an application, a cyclic sequence of reductions between data structures that lead to the following bootstrapping result. Let B(u,n) denote the lower bound on the space of a dictionary for n elements over a universe [u]. Given a compact dynamic dictionary (i.e., space O (B(u,n))), we can use it to build a dynamic dictionary with space B(u,n) + O (n log log n). This reduction increases the time per operation by an additive constant and applies both to the extendable and non-extendable settings (failure probability is 1/poly(n) per insertion).

We consider the problem of sampling from a distribution on graphs, specifically when the distribution is defined by an evolving graph model, and consider the time, space, and randomness complexities of such samplers. In the standard approach, the whole graph is chosen randomly according to the randomized evolving process, stored in full, and then queries on the sampled graph are answered by simply accessing the stored graph. This may require prohibitive amounts of time, space, and random bits, especially when only a small number of queries are actually issued. Instead, we propose a setting where one generates parts of the sampled graph on-the-fly, in response to queries, and therefore requires amounts of time, space, and random bits that are a function of the actual number of queries. Yet, the responses to the queries correspond to a graph sampled from the distribution in question. Within this framework, we focus on two random graph models: the Barabási-Albert Preferential Attachment model (BA-graphs) ( Science , 286 (5439):509–512) (for the special case of out-degree 1) and the random recursive tree model ( Theory of Probability and Mathematical Statistics , (51):1–28). We give on-the-fly generation algorithms for both models. With probability 1-1/poly( n ), each and every query is answered in polylog( n ) time, and the increase in space and the number of random bits consumed by any single query are both polylog( n ), where n denotes the number of vertices in the graph. Our work thus proposes a new approach for the access to huge graphs sampled from a given distribution, and our results show that, although the BA random graph model is defined by a sequential process, efficient random access to the graph’s nodes is possible. In addition to the conceptual contribution, efficient on-the-fly generation of random graphs can serve as a tool for the efficient simulation of sublinear algorithms over large BA-graphs, and the efficient estimation of their on such graphs.

We present a time-optimal deterministic distributed algorithm for approximating a minimum weight vertex cover in hypergraphs of rank f. This problem is equivalent to the Minimum Weight Set Cover problem in which the frequency of every element is bounded by f. The approximation factor of our algorithm is (f+ε ) . Let denote the maximum degree in the hypergraph. Our algorithm runs in the congest model and requires O(log / loglog ) rounds, for constants ε∈ (0,1] and f∈ℕ^+ . This is the first distributed algorithm for this problem whose running time does not depend on the vertex weights nor the number of vertices. Thus adding another member to the exclusive family of provably optimal distributed algorithms. For constant values of f and ε , our algorithm improves over the (f+ε ) -approximation algorithm of Kuhn et al. (SODA, 2006)whose running time is O(log + log W) , where W is the ratio between the largest and smallest vertex weights in the graph. Our algorithm also achieves an f-approximation for the problem in O(flog n) rounds, improving over the classical result of Khuller et al. (J Algorithms, 1994) that achieves a running time of O(flog ^2 n) . Finally, for weighted vertex cover ( f=2 ) our algorithm achieves a deterministic running time of O(log n) , matching the randomized previously best result of Koufogiannakis and Young (Distrib Comput, 2011). We also show that integer covering-programs can be reduced to the Minimum Weight Set Cover problem in the distributed setting. This allows us to achieve an (f⌈log _2(M)+1 ⌉ +ε ) -approximate integral solution in O( (1+f/log n)·( log/loglog + (f·log M)^1.01·logε ^-1· (log )^0.01) ) rounds, where f bounds the number of variables in a constraint, bounds the number of constraints a variable appears in, and M=max{ 1, ⌈ 1/a_min⌉} , where a_min is the smallest normalized constraint coefficient.

Bucket Sort is known to run in expected linear time when the input keys are distributed independently and uniformly at random in the interval $[0,1)$. The analysis holds even when a quadratic time algorithm is used to sort the keys in each bucket. We show how to obtain linear time guarantees on the running time of Bucket Sort that hold with very high probability. Specifically, we investigate the asymptotic behavior of the exponent in the upper tail probability of the running time of Bucket Sort. We consider large additive deviations from the expectation, of the form $cn$ for large enough (constant) $c$, where $n$ is the number of keys that are sorted. Our analysis shows a profound difference between variants of Bucket Sort that use a quadratic time algorithm within each bucket and variants that use a $\Theta(b\log b)$ time algorithm for sorting $b$ keys in a bucket. When a quadratic time algorithm is used to sort the keys in a bucket, the probability that Bucket Sort takes $cn$ more time than expected is exponential in $\Theta(\sqrt{n}\log n)$. When a $\Theta(b\log b)$ algorithm is used to sort the keys in a bucket, the exponent becomes $\Theta(n)$. We prove this latter theorem by showing an upper bound on the tail of a random variable defined on tries, a result which we believe is of independent interest. This result also enables us to analyze the upper tail probability of a well-studied trie parameter, the external path length, and show that the probability that it deviates from its expected value by an additive factor of $cn$ is exponential in $\Theta(n)$.

We address the problem of controlling the COVID19 contagion with a limited number of PCR-tests. We developed a tool that can assist policy makers in decisions as well as in justifying these decisions. Our tool consists of: A stochastic disease model, a compressed representation of interactions between people via a graph that scales well to large populations, policies for selecting PCR-testees per day, and a simulator that simulates the spread of the COVID-19 while taking into account the testing and quarantine decisions of the chosen policy. The graph model includes features that help determine the infection risk of individuals. We consider both external infection (inflicted by people outside the studied community) as well as internal infection. The graph model and known infections induce weights to people. These weights are used to select the testees per day in a greedy algorithm and in a linear-programming optimization algorithm. Our simulations indicate a reduction in total morbidity of 30 - 50% using the optimization algorithm compared to random sampling. A reduction of up to 40% in peak morbidity is achieved compared to random sampling. We also studied the efficiency of quarantining in various policies.

A dynamic dictionary is a data structure that maintains sets of cardinality at most $n$ from a given universe and supports insertions, deletions, and membership queries. A filter approximates membership queries with a one-sided error that occurs with probability at most $\epsilon$. The goal is to obtain dynamic filters that are space-efficient (the space is $1+o(1)$ times the information-theoretic lower bound) and support all operations in constant time with high probability. One approach to designing filters is to reduce to the retrieval problem. When the size of the universe is polynomial in $n$, this approach yields a space-efficient dynamic filter as long as the error parameter $\epsilon$ satisfies $\log(1/\epsilon) = \omega(\log\log n)$. For the case that $\log(1/\epsilon) = O(\log\log n)$, we present the first space-efficient dynamic filter with constant time operations in the worst case (whp). In contrast, the space-efficient dynamic filter of Pagh, Pagh, Rao (SODA 2005) supports insertions and deletions in amortized expected constant time. Our approach employs the classic reduction of Carter et al. (STOC 1978) on a new type of dictionary construction that supports random multisets.

We study the tradeoff between computational effort and classification accuracy in a cascade of deep neural networks. During inference, the user sets the acceptable accuracy degradation which then automatically determines confidence thresholds for the intermediate classifiers. As soon as the confidence threshold is met, inference terminates immediately without having to compute the output of the complete network. Confidence levels are derived directly from the softmax outputs of intermediate classifiers, as we do not train special decision functions. We show that using a softmax output as a confidence measure in a cascade of deep neural networks leads to a reduction of 15% –50 % in the number of MAC operations while degrading the classification accuracy by roughly 1% . Our method can be easily incorporated into pre-trained non-cascaded architectures, as we exemplify on ResNet. Our main contribution is a method that dynamically adjusts the tradeoff between accuracy and computation without retraining the model.

We study the performance of stochastic gradient descent (SGD) in deep neural network (DNN) models. We show that during a single training epoch the signs of the partial derivatives of the loss with respect to a single parameter are distributed almost uniformly over the minibatches. We propose an optimization routine, where we maintain a moving average history of the sign of each derivative. This history is used to classify new derivatives as “exploratory” if they disagree with the sign of the history. Conversely, we classify the new derivatives as “exploiting” if they agree with the sign of the history. Each derivative is weighed according to our classification, providing control over exploration and exploitation. The proposed approach leads to training a model with higher accuracy as we demonstrate through a series of experiments.

A filter, such as a Bloom filter, maintains a compact, probabilistic representation of a set S of elements from a universe U. The challenge is to design a filter that uses optimal space and requires a constant number of memory accesses per query while supporting both insertions and deletions. The two main modern constructions of filters are cuckoo filters and adaptive filters built on quotient filters. Cuckoo filters (Fan et al. 2014) perform well in practice but rely on unproven heuristics. Adaptive filters (Bender et al. 2012, 2018) as well as cuckoo filters experience performance degradation as the number of stored elements approaches the capacity of the filter. Thus, space utilization is sub-optimal. We present a filter that, with high probability, asymptotically achieves optimal space and performance even if the number of elements reaches the capacity of the filter. This construction copes with the problem of "false deletes" (that it has in common with cuckoo filters) via an elegant connection to adaptive filters. Time permitting, applications that benefit from adaptive filters will be discussed. Joint work with Michael A. Bender, Ioana O. Bercea, Alex Conway, Tomer Even, Martin Farach-Colton, Rob Johnson.

A fully-dynamic dictionary is a data structure for maintaining sets that supports insertions, deletions and membership queries. A filter approximates membership queries with a one-sided error. We present two designs: 1. The first space-efficient fully-dynamic dictionary that maintains both sets and random multisets and supports queries, insertions, and deletions with a constant number of memory accesses in the worst case with high probability. The comparable dictionary of Arbitman, Naor, and Segev [FOCS 2010] works only for sets. 2. By a reduction from our dictionary for random multisets, we obtain a space-efficient fully-dynamic filter that supports queries, insertions, and deletions with a constant number of memory accesses in the worst case with high probability (as long as the false positive probability is $2^{-O(w)}$, where $w$ denotes the word length). This is the first in-memory space-efficient fully-dynamic filter design that provably achieves these properties. We also present an application of the techniques used to design our dictionary to the static Retrieval Problem.

We consider two models of computation: centralized local algorithms and local distributed algorithms. Algorithms in one model are adapted to the other model to obtain improved algorithms.Distributed vertex coloring is employed to design improved centralized local algorithms for: maximal independent set, maximal matching, and an approximation scheme for maximum (weighted) matching over bounded degree graphs. The improvement is threefold: the algorithms are deterministic, stateless, and the number of probes grows polynomially in log⁎⁡n, where n is the number of vertices of the input graph.The recursive centralized local improvement technique by Nguyen and Onak (FOCS 2008) is employed to obtain a distributed approximation scheme for maximum (weighted) matching.