Dimension-Free Correlated Sampling for the Hypersimplex
Abstract
Sampling from multiple distributions so as to maximize overlap has been studied by statisticians since the 1950s. Since the 2000s, such correlated sampling from the probability simplex has been a powerful building block in disparate areas of theoretical computer science. We study a generalization of this problem to sampling sets from given vectors in the hypersimplex, i.e., outputting sets of size (at most) , while maximizing the overlap of the sampled sets. Specifically, the expected difference between two output sets should be at most times their input vectors’ distance. A value of is known to be achievable, due to Chen et al. (ICALP’17). We improve this factor to , independent of the ambient dimension . Our algorithm satisfies other desirable properties, including (up to a factor) input-sparsity sampling time, logarithmic parallel depth and dynamic update time, as well as preservation of submodular objectives. Anticipating broader use of correlated sampling algorithms for the hypersimplex, we present applications of our algorithm to online paging, offline approximation of metric multi-labeling, and swift multi-scenario submodular welfare approximating reallocation.
Keywords and phrases:
Correlated Rounding, Dependent RoundingFunding:
Joseph (Seffi) Naor: Supported in part by ISF grant 3001/24 and United States – Israel BSF grant 2022418.Copyright and License:
2012 ACM Subject Classification:
Mathematics of computing Probabilistic algorithmsEditor:
Shubhangi SarafSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
Consider the following natural correlated sampling problem: we wish to sample from numerous discrete distributions over , or equivalently round numerous points in the -dimensional probability simplex, , in a consistent manner. In particular, for any two distributions with low total variation distance, i.e., points in with low distance, , we wish the sets drawn according to these points to be similar in expectation.
This problem is well-understood [30, 26, 25, 9, 2, 5]. Moreover, efficient correlated sampling algorithms have found numerous applications to disparate areas of computation, from approximation algorithms [30, 25, 9, 37], parallel repetition [26, 4], replicability and privacy [3, 11], parallel sampling [32, 1], cryptography [36], locality sensitive hashing [7, 14], and more.
Such correlated sampling is a special case of what statisticians refer to as coordinated sampling, and have been studying since the 1950s [28]. Here, the motivation of maximizing overlap is in minimizing overhead of initiation interviews for newly sampled interviewees or overhead of hiring new interviewers for new regions with sampled interviewees. Such rationale was used and adopted, for example in the U.S. Bureau of the Census household surveys. See discussion of such applications and nearly half a century of work on such questions in the survey by Ernst [22].
In this work we study the following correlated sampling problem, introduced by [16], generalizing from the probability simplex to the convex hull of the hypersimplex and the origin, i.e., the polytope whose extreme points are vectors in with at most ones,
We wish to round points in this set while preserving marginals, respecting the cardinality constraint of , and guaranteeing that the expected distance of the output sets for any two points is bounded in terms of the points’ distance. Formally, we study the following problem.
Definition 1.
A distribution over deterministic algorithms mapping points in to subsets of of cardinality at most is an -stretch correlated sampling algorithm for if it satisfies the following properties for all :
-
(P1)
(Cardinality) (hence ) for all in the support of .
-
(P2)
(Marginals) for all .
-
(P3)
(Stretch) .
To clarify Property P3 and its use: after a common initialization step where we draw an algorithm , we guarantee that when rounding any two vectors , the output’s expected distance (over the random choice of ) is at most the vectors’ distance times some . Naturally, we wish to keep as small as possible.
For it is known that must be at least two [2, 5],111More precisely, some must have stretch at least , for , though may tend to zero. and this bound is attainable, provided , i.e., for [30, 26, 25, 9, 2, 32]. (As we show in the full version of the paper, a constant bound of for more generally follows from the bound for .) For , in contrast, [16] show that an stretch is achievable, and use it for applications to metric multi-labelling, which we define later.
The stark difference between the case and larger is apparent. The natural question, which we study, is whether this “logarithmic in ” stretch is inherent to the problem.
1.1 Our Contribution
Our main contribution is a correlated sampling algorithm for the hypersimplex with with stretch logarithmic in , but independent of the input dimension, .
Theorem 2.
There exists an -stretch correlated sampling algorithm for for all .
Our algorithm is extremely fast, and can be implemented in time, for the number of nonzeros and the (extremely slowly-growing) iterated logarithm function (see Definition 3). Thus, the algorithm’s running time is also very nearly linear in the input sparsity, and dimension independent. Our algorithm can further be implemented in parallel depth and update time in dynamic settings.
Property P2 immediately implies preservation of linear objectives. We also prove that our algorithm preserves submodular objectives. (See Section 3.4 for some background, but for now it suffices to say that these functions capture the ubiquitous phenomenon of diminishing returns.) In particular, we prove that our correlated sampling algorithm’s output has at least as high a submodular value as independent rounding with marginals (the so-called multilinear extension), while being oblivious to the objective submodular function, and also satisfying the cardinality constraint and desired low stretch guarantees. In the full version of the paper we extend this property to correlated sampling for partition matroids, where the ground set is partitioned into parts, with a cardinality constraint on each part.
Due to the widespread uses of correlated sampling for the probability simplex, we anticipate numerous subsequent applications of our correlated sampling algorithm for the hypersimplex. To illustrate this, we provide several simple applications of our algorithm, to online paging, offline metric multi-labeling, and dynamic submodular welfare maximizing reallocation. As these applications only illustrate the variety of (potential) applications of our correlated sampling for the hypersimplex, we defer their description to Section 4. However, for our last application, we note that our dimension-free stretch hints at further applications: combining it with a simple rounding algorithm for the case that is large, we can obtain constant stretch, while approximately preserving marginals and submodular objectives. We believe this pattern will benefit future applications of our algorithm.
2 Preliminaries
Notation.
Throughout, we use boldface letters , etc., and use to denote the norm. In our running times, we use the standard iterated (binary) logarithm notation. (Throughout the paper, all logarithms are to the base two.)
Definition 3.
For any , the -th iterated and the iterated logarithm are defined as follows.
Sublinear sample time.
Our algorithms’ sampling time is sublinear in the input’s dimension. Specifically, ignoring a modest factor, their running time is independent of and only linear in the sparsity of the input vector , i.e., . (As will be clear from context, we simply write .) For this, we rely on a sparse representation that allows us to avoid reading the entire vector. In particular, we assume a natural representation allowing us to iterate through the non-zero coordinates of in increasing order in time . Another operation we require is -time computation of standard bit-wise operations, XOR, AND, and NOT (see the full version).
Interface.
Correlated sampling algorithms must use a common random seed for sampling, otherwise we may get different output sets in two different invocations of the sampling step for the same vector , violating Property P3 for vectors . Fittingly, correlated sampling algorithms use a common initialization step, where we draw , setting this randomness, and sampling steps, where we compute . Note that in all our algorithms and the previous algorithms we make use of, the randomness of the initialization step can implicitly be “spread” over later sampling steps, drawing each random bit the first time it is needed. Therefore, all algorithms presented in this paper have constant initialization time, and so we avoid mentioning this, and only mention the sample time.
Previous Correlated Sampling Algorithms.
For , [30, 26, 25, 9, 2, 32] give -stretch correlated sampling algorithms. For , [16] provided an -stretch correlated sampling algorithm for , though a full proof of the latter is unavailable online.222We thank Roy Schwartz for sharing a preprint of the full version of [16] with us. Moreover, since we are interested in input-sparsity sample time and fast parallel and dynamic implementations of these, in the full version we provide full proofs of these algorithms, and implementations, with guarantees as in the following propositions. We also provide similar guarantees for -stretch correlated sampling in more generally, by a simple reduction.
Proposition 4.
There exists a -stretch sample time correlated sampling algorithm for . The algorithm can be implemented in parallel depth and work and using update time in dynamic settings.
Proposition 5.
There exists a correlated sampling algorithm for for all with sample time and stretch . The algorithm can be implemented in parallel depth and work and using update time in dynamic settings.
Bounding Stretch.
Throughout, in our analysis we fix two vectors , and prove that we satisfy all three desired properties, P1-P3. The following well-known observation [16] will simplify our discussion. As usual, is the basis vector in the standard basis for .
Observation 6.
By triangle inequality, a correlated rounding algorithm has stretch if and only if this stretch of holds for any two points , for infinitesimally small .
3 Composed Correlated Sampling
This section is dedicated to providing, analyzing, and implementing our main correlated sampling algorithm for the hypersimplex, whose main guarantee we restate here.
See 2 We present our algorithm in Section 3.1, showing that it satisfies Properties P1 and P2, and analyze its stretch in Section 3.2. We discuss running times (in various computational models) in Section 3.3. We then prove that the algorithm preserves submodular objectives in Section 3.4.
3.1 The Composed Correlated Sampling Algorithm
We compose several correlated sampling algorithms and additional hashing and random thresholds. We precede its formal description and pseudocode (Algorithms 1, 2, and 3) with a high-level layered description and motivation, interlaced with elements of its analysis.
3.1.1 Overview
Proposition 5 gives a correlated sampling algorithm for with stretch . To obtain a smaller stretch, we aim, in a sense, to “project” the points onto a smaller dimension , so as to obtain a stretch . Assuming the projection is in some sense invertible, this allows us to “lift” the same improved stretch back to the original (larger) dimension .
A first attempt.
Consider a vector . To try and achieve the desired invertible projection, we hash coordinates into buckets. In the pseudocode, , where these parameters will be clarified below. Assuming (for now) that the sum of the -values hashed to the same bucket is not greater than one, we give this bucket’s coordinate a weight equal to the sum of the -values hashed to it. Note that the obtained vector has the same norm as . We now apply a correlated sampling algorithm to the vector and obtain a subset of of size (up to floor or ceiling). We then obtain a subset of with the right marginals, for each bucket whose coordinate in is output in , by picking a single coordinate hashed to bucket with probability , using a simple correlated sampling algorithm for the case (Proposition 4).
A second attempt.
Unfortunately, the assumption that the sum of the -values hashed to each bucket is at most one might be violated. However, by simple probabilistic arguments, one can show that taking sufficiently large , then small-valued coordinates (whose individual -values are at most, say, ) hashed to a bucket have sum exceeding one with probability at most . We then hash large-valued coordinates, of which there are , into their own buckets, which are unlikely to collide with buckets to which other coordinates were hashed. Assuming no collisions or heavy buckets, the above is our desired invertible projection. In case of -probability problematic events (heavy bucket or collisions), we fall back on some -stretch algorithm. For now we think of , though generally we can (and do) plug in other values of . By linearity of expectation, this fall back algorithm contributes to our algorithm’s stretch, which is , provided . (This paragraph motivates our choice of .)
The full algorithm.
Finally, our definition of small/large coordinates and heavy buckets can result in using two different correlated sampling algorithms (in different lines) to determine the output for different inputs and which only differ marginally in a single coordinate, i.e., . For example, this coordinate can be small for , but large for , or the change in this coordinate may result in one bucket being heavy when rounding , but not . This is extremely problematic, since this can result in our outputs for and being computed using different correlated sampling algorithms, and so these outputs are potentially uncorrelated (different) output sets, despite and being quite close. This results in stretch possibly as high as . To overcome this issue, we randomize our thresholds for items being large or small, and for buckets being heavy. As we show, this results in the extremely problematic event outlined above happening with probability at most . Therefore, the contribution to the stretch here is again only , and the final stretch is only . Our final desired stretch of follows by using this construction recursively, allowing us to plug in increasingly smaller values of .
3.1.2 Algorithm Description
Our recursive algorithm relies on the correlated sampling algorithms of Propositions 4 and 5, and another correlated-sampling algorithm for with stretch . This algorithm can be the algorithm from Proposition 5, in which case , or (as we use in general) another correlated-sampling algorithm – with a smaller – obtained by recursing this construction. (We later use this algorithm recursively so that in each level the stretch from decreases and the overall stretch achieved is reduced.) At a high level, we rely on the algorithm for with hashing to compress and map the input point to a point in a lower-dimensional polytope for some . If we successfully lowered the dimension of the point to round in an invertible manner, we then round this point using the [16] correlated-sampling algorithm from Proposition 5 for this lower dimension . When the compression does not succeed at some level of the recursion (due to hash collisions – this happens with small probability), we simply fall back to using algorithm on the original -dimensional input vector.
Our basic algorithm’s pseudocode is given in Algorithms 1, 2, and 3. On initialization (Algorithm 1) we initialize the randomness used later (in Algorithm 2) by the other correlated-sampling algorithms. In addition, we randomly hash the coordinates into some large many buckets. We then hash the coordinates and buckets into , and draw two random thresholds . In Algorithm 2, we call a coordinate small if , else we call it large. If any two buckets or large coordinates are hashed to the same value in (a hash collision), or if the small coordinates in any one bucket have -value summing to more than (an unusually heavy bucket), we simply run Algorithm on the input vector . Otherwise, we use Algorithm 3 to “compress” the small coordinates in each bucket (whose sum is less than one), using the algorithm of Proposition 4: we obtain a single coordinate called the representative, and have it “absorb” all the -value of the small coordinates in its bucket – by taking on their -values’ sum and nullifying all small coordinates’ -values in its bucket (by resetting those to zero). Finally, using the (bijective) mapping from the remaining non-zero coordinates to (with representatives using their buckets’ hash), we run the [16] algorithm on a vector of (smaller) dimension . We then invert the bijective mapping from the remaining non-zero coordinates in to to convert the output subset of to a subset of , and return this set.
3.1.3 First Observations
We note that Algorithm 2, which we denote henceforth by , outputs a set of cardinality at most , i.e., it satisfies Property P1.
Observation 7.
for all .
Proof.
Follows by Property P1 of , whose output may return in either Line 4 or 6, and by the same property of , since if returns in Line 9, then since and in this case, we have .
Similarly, we note that the output of Algorithm 2 contains each element with probability , i.e., it satisfies Property P2. In fact, we prove a slightly stronger property. Specifically, for the randomness used by Algorithm 1 in Lines 5–11, we show the following.
Observation 8.
For any realization of , element and vector
Consequently, by total probability,
Proof.
If implies that outputs a set in Lines 4 or 6, then , and so by Property P2 of ,
If implies that outputs a set in Lines 9 and that , then and by Property P2 of ,
Finally, if implies that outputs a set in Line 9 and that , then iff both and hold. By Property P2 of and , and since independently of (and generally is independent of ), we have that
The crux of the analysis is in bounding the algorithm’s stretch, i.e., quantifying Property P3.
3.2 Analyzing the Algorithm’s Stretch
Analysis overview
When rounding two vectors , we have three possible scenarios, named in accordance with their intuitively increasingly poor conditional stretch.
Definition 9.
The following observation and subsequent lemma motivate the above terminology.
Observation 10.
For vectors , the sets and satisfy
Proof.
The bound for the tragic event is trivial, since by Observation 7, and thus by triangle inequality, always. Next, conditioned on the bad event, we have and , so the bound follows by Property P3 of the -stretch correlated sampling algorithm .
Note that the conditional stretch for the tragic event is unbounded, since it holds for arbitrarily small , as opposed to the bounded stretch conditioned on a bad pair of runs. This justifies our choice of a more positive term for the latter event. We now justify the choice of best term for the good event (): we show that it contributes to the stretch, which is unless is already an algorithm with our target stretch of . As we show later in Lemma 14, we have that , and so this also implies that good runs have the smallest expected stretch of all three types of runs.
Lemma 11.
For vectors , the sets and satisfy
Proof (Sketch).
By Proposition 5, the output sets have distance conditioned on the fact that runs for and are good. Therefore we wish to bound in terms of . In the case that and are both small, or are both large, and differ by a single coordinate, hence . However if is large but is small, then . As is randomly chosen, this last event happens with probability , which then implies our desired bound by total expectation. See full version of the paper for details.
Given the preceding bounds on the expected contribution to the stretch of good runs, we wish to upper bound the probability of a pair of runs on vectors and being bad or tragic. To this end, we first upper bound the probability of Algorithm 2 running on the original input vector, by proving that the probability of a hash collision is low, conditioned on any realization of .
Lemma 12.
For any and possible realization of ,
Proof.
Since , the number of elements is at most , while the number of buckets is . The number of pairs of such is therefore at most . Since hashing is done uniformly, the probability of any pair colliding is . By union bound over all pairs and using , and so , the probability of a hash collision is at most
Next, we show that under the same conditioning, the probability of any bucket being heavier than is likewise small.
Lemma 13.
For any and possible realization of ,
Proof (Sketch).
We divide small items into tiny items, having value at most some , and little items. For some to have value of small items exceeding requires either the sum of -values of tiny items in to exceed its expectation by some constant, or at least some constant number of coarse items to belong to . Both events have probability polynomially small in , the former by the choice of and Chernoff bounds, and the latter by union bound over the (few) -tuples of the (somewhat few) little items. Union bounding over these events and over all then gives the lemma. See the full version for details.
Using the preceding lemmas, we can now upper bound the probabilities of the bad and tragic events.
Lemma 14.
The probability that a pair of runs of Algorithm 2 on and is bad or tragic satisfies
Proof (Sketch).
The first bound follows by the union bound and the previous two lemmas. In contrast, if a pair of runs is tragic, then Algorithm 2 terminates in Line 9 for one input, but terminates early (Lines 4 or 6) for the other, due to either a hash collision or a heavy bucket. All (three) cases causing such an event require one of the -probability events from the previous lemmas to occur, and the random thresholds for an item being large or for a bucket being full to fall in a range of width at most . But due to , any one of these three bad cases then occurs with probability . The upper bound on then follows by the union bound. See the full version for details.
With the above in place, we are now ready to bound the expected stretch of Algorithm 2.
Theorem 15.
For all , the sets and satisfy
Proof.
By Observation 6, we can assume that . By total expectation over the good, bad and tragic events, using Lemmas 11 and 14, we get:
where the last inequality follows from our choice of satisfying and .
Taking Algorithm in Algorithm 2 to be the -stretch algorithm of Proposition 5, Theorem 15 immediately implies an -stretch correlated sampling algorithm. We improve on this bound and obtain an stretch by recursing our construction. We start by describing the construction.
Our recursive construction.
For the base case, is the algorithm of Proposition 5. For all we let be Algorithm 2 with Algorithm in Lines 4 and 6 chosen to be .333We can also consider running in Line 9, but we focus on the simpler recurrence. We denote by the stretch of algorithm . By Proposition 5, . On the other hand, by Theorem 15, for general we have for some constant the recurrence
Using this recursive construction we obtain our claimed stretch, as follows.
Theorem 2. [Restated, see original statement.]
There exists an -stretch correlated sampling algorithm for for all .
Proof.
Let , and note that for all . Consequently, since is increasing for , we have that if , then . Moreover, if , then trivially . Combining the above we have that if then . Thus, since , for , Algorithm has stretch .
By the preceding proof, to get an stretch we only need a recursion depth of . In the following section we refine this bound and consider other computational aspects of implementations of Algorithm 2 and our derived recursive correlated sampling algorithm.
3.3 Computational Considerations
In our preceding proof of Theorem 2, we only used the fact that the stretch decreases by a constant factor until it is below some term. However, since the dependence on in the stretch of each algorithm is asymptotically logarithmic in the stretch of the preceding algorithm , we can show that the first iterations decrease the stretch significantly faster and so significantly fewer levels of recursion are necessary to attain stretch , which translates into speedups for our algorithm.
Lemma 16.
The -th algorithm for all has stretch
The proof, which is a simple inductive argument, is deferred to the full version. We also show there that after levels of recurrence, giving a stretch of , by the halving argument from our previous proof of Theorem 2, we then decrease the stretch by a further factor in only more levels of recursion, yielding the following.
Theorem 17.
For some , Algorithm has stretch .
Remark 18.
One can show that the more involved recurrence mentioned in Footnote 3 converges exponentially faster: it allows to double the number of iterated logarithms in each level, thus improving on Lemma 16, yielding a stretch for , and thus this number of recursive calls (asymptotically) suffices for a stretch of . For simplicity of exposition, we omit the details.
In the remainder of this section we discuss the computational ramifications of Theorem 17 in various computational models, the most immediate one being the classic centralized setting. In all the following theorems, we note that
Theorem 19 (Near-Input-Sparsity Sample Time).
There exists an -stretch correlated sampling algorithm for with sample time in the worst case.
Proof.
By Theorem 17, we can focus on implementing for some . Compression in each of the levels of the recurrence requires time, since we spend time proportional to each bucket’s vector, by Proposition 4. The final call to the rounding algorithm of Proposition 5 (for whichever dimension we end up using) takes a further time. Finally, returning from the recurrence and lifting the output subset to a larger universe requires time in each level, for a further time.
Our recurrence depth together with implementations of the basic correlated sampling algorithms (Propositions 4 and 5) also implies that our algorithm can be (i) parallelized (at the cost of increasing the sample time to be slightly superlinear in ), with depth near logarithmic. Similarly, and that it can (ii) be dynamized with the near-logarithmic same update time. (See the full version).
Theorem 20 (Parallel Implementation).
There exists an -stretch correlated sampling algorithm for with sampling time and depth .
Theorem 21 (Dynamic Implementation).
There exists an -stretch correlated sampling algorithm for with update time .
3.4 Submodular Dominance
Since correlated sampling algorithms preserve marginals (Property P2), they naturally preserve linear objectives. In this section we show that our rounding scheme also preserves subomdular objectives that capture the ubiquitous notion of diminishing returns. We recall some basic definitions.
3.4.1 Submodularity: Technical Background
Definition 22.
A set function is submodular if it satisfies the diminishing returns property, namely
where denotes the marginal value (measured by ) of adding to .
As we are interested in rounding-based algorithms, we need a way to extend (binary-valued) submodular functions to real vectors. We One natural such extension, corresponding to independent rounding, is the multilinear extension of [13].
Definition 23.
The multilinear extension of a set function is given by
The maximum multilinear objective subject to any solvable polytope (i.e., a polytope over which one can optimize linear objectives efficiently) can be -approximated in polynomial time [13]. This is optimal even subject to cardinality constraints, under standard complexity-theoretic assumptions [23] and information-theoretically given only value oracle access to [34, 33].
Given the above approximability of the multilinear extension, it is natural to wish to round vectors while preserving the given constraints, as well as preserving the multilinear objective. This is known to be achievable for matroid constraints and other constraints if is known [13, 15]. An objective-oblivious counterpart to the above is given by the following definition.
Definition 24.
A random vector satisfies submodular dominance if for any submodular function , we have that
It is known that tree-based pivotal sampling [38] (the core algorithm used by [16]) satisfies submodular dominance. This follows since tree-based pivotal sampling satisfies negative association (and more) [6, 19, 21, 12], and the latter is known to imply submodular dominance [35, 17]. We provide some relevant background on negative association here.
Definition 25.
A random vector is negatively associated (NA) if for any two increasing functions of disjoint variables in , we have
A simple example of the above is given by the so-called 0-1 lemma [20].
Proposition 26.
Any random vector with is NA.
It is well-known that NA is closed under products [27].
Proposition 27.
If independent vectors and are NA, then so is their concatenation, .
A more involved example of NA is the output of [16]. This follows since the latter is the output of pivotal sampling [38, 18] (albeit with correlated random seed) with a tree order (see the full version), whose output is known to satisfy NA [6, 12, 31].
Proposition 28.
The output of [16] is NA.
Proposition 29.
Let be a submodular function and an NA vector. Then, .
3.4.2 Submodular Dominance of Algorithm 2
In this section we show that the output of Algorithm 2 satisfies submodular dominance, using the connection of the latter to negative association.
Theorem 30.
The output of Algorithm 2 with and satisfying submodular dominance itself satisfies submodular dominance.
Proof.
Fix a realization of . This in particular fixes the definition of large and small items, the buckets and the mappings. If is such that we return a set in Lines 4 or 6, then our output is , which satisfies submodular dominance by Proposition 28, and so by Property P2 of ,
Otherwise, given , our Algorithm 2 outputs in Line 9 a set
To argue submodular dominance, we define the following auxiliary submodular function:
Since the output of is independent of , for any realization of we can imagine that (independently) for each , some is drawn from according to the discrete distribution , by Property P2 of .
Thus according to this sampling of . So, if we let , then taking total probability over , expanding , and using the subomdular dominance of ,
we have:
Fortunately, this unwieldy expression has a simple interpretation: this is precisely the subomdular objective obtained by sampling each large item independently with probability , and sampling at most one element per bucket with probability , independently of the large items and other buckets. But by Propositions 26 and 27, this distribution is NA, and since NA implies submodular dominance [17, 35], we obtain submodular dominance conditioned on . By Observation 8, this implies that . The subomdular dominance for the unconditional distribution then follows since by total expectation over .
4 Applications
Recall that correlated sampling algorithms for have found numerous varied applications. In this section we discuss three applications of our rounding scheme: (i) an application to rounding fractional online paging algorithms, which yields worse algorithms than known, yet is simple and hints at more applications in online settings, (ii) an application to metric multi-labeling via a framework of [16], improving their approximation from to , and (iii) a more complicated application to collusion-free and swift submodular welfare maximizing reallocation in dynamic settings. We conclude the latter with a discussion of combining dimension-free bounds with a simple rounding scheme to effectively obtain constant stretch, at the cost of only nearly achieving the marginals (Property P2), and hence incurring a loss in submodular objectives.
We emphasize that our main message here is the variety of the applications, which we believe hints at potential future wide-ranging applications of our more general correlated sampling machinery.
4.1 Online Paging
Recall that in the (online) paging problem, a cache of size is given, able to store any of pages. At each time a page is requested. If is not in the cache and the cache is full, this causes a cache miss and some other page must be evicted from the cache to make room for . The objective is to minimize the number of evictions (hence cache misses), compared to the hindsight-optimal solution, measured in terms of the (multiplicative) competitive ratio.
A natural LP (linear programming) relaxation of the problem, with decision variables corresponding to the extent to which page is in the cache at time , and the extent to which page is evicted at time , is as follows.
No fractional online algorithm is better than -competitive with respect to this LP, and this ratio can be attained using the online primal-dual method [8]. We show that our correlated rounding algorithms provide -competitive randomized integral algorithms. While better randomized algorithms with competitive ratio have been known since the ’90s [24], this hints at broader applicability of our correlated sampling algorithm for online problems.
Rounding fractional caches using correlated sampling.
To round fractional caching algorithms we use our -stretch correlated sampling Algorithm 2 for , abbreviated by . For , the fractional cache at time , our integral cache at time is simply . The random cache at each time is feasible, since (i) by Property P1, and (ii) by Property P2, thus implying that this cache contains page with probability one. On the other hand, the expected number of page misses at time is, by Property P3, at most . Therefore, by linearity of expectation, the obtained (feasible) online paging algorithm incurs at most evictions in expectation. Therefore, since the fractional online algorithm’s objective , the randomized algorithm is at most competitive.
4.2 Metric Multi-Labeling
Chen et al. [16] introduced the correlated sampling problem which we study. Their motivation comes from multi-label classification problems, in which labels need to be assigned to objects, e.g., news articles, given some observed data. They considered the case where multiple labels can be assigned to objects, called the metric multi-labeling problem. It arises in various settings, e.g., classification of textual data such as web pages, semantic tagging of images and videos, and functional genomics. The assignment of labels to objects should be done in a manner that is most consistent with the observed data, from which two important ingredients are derived. The first is an assignment cost for every (object,label) pair, reflecting a recommendation given by a local learning process which infers label preferences of objects. The second is similarity information on pairs of objects, giving rise to separation costs incurred once different label sets are assigned to a pair of similar objects. The goal is to find a labeling that minimizes a global cost function, while taking into account both local and pairwise information.
Chen et al. [16] considered the setting in which the number of labels that an object can receive is at most . They formulated the metric multi-labeling problem in this setting as a linear program that maps the objects into a set of (fractional) vectors , where the entry of vector indicates the fraction of label that object receives. The objective function minimizes the global cost function of the (fractional) labeling, i.e., the sum of the assignment costs and the separation costs. The following lemma is proved in [16].
Proposition 31.
If there is a polynomial-time -stretch correlated sampling algorithm for , then the metric multi-labeling problem admits a polynomial-time -approximation algorithm.
The proof of the lemma is based on the following observations: (1) the preservation of the marginals in the correlated sampling algorithm guarantees that assignment costs are preserved in expectation; and (2) the -stretch implies that separation costs are preserved in expectation with a loss of a factor . As discussed in detail above and in the full version of the paper, [16] provided a polynomial-time -stretch algorithm, and from this they obtain an -approximate algorithm for metric multi-labeling. Our main result that improves the stretch to then implies the same improved approximation ratio for this problem. The latter is an asymptotic improvement of interest, as is typically much smaller than for this problem.
4.3 Swift and Collusion-Free Reallocation
We now turn to our most involved application. Part of our arguments are inspired by and build upon recent unpublished work of [10]. They studied the problem of low-recourse cardinality-constrained submodular maximization in a dynamic setting with unknown future.
In contrast, we show how our correlated sampling can be used to provide similar guarantees that are history-independent, and therefore collusion-resistant, given a sequence of potential scenarios that might require swift reallocation. This application relies on all properties of our algorithm, including submodular dominance (Theorem 30), and dimension-free stretch . We show that the latter property combines nicely with a simple constant-stretch algorithm which approximately preserves marginals and submodular objectives up to an additional factor for the regime that (by simple concentration arguments): this combination results in -stretch at the cost of a loss in the objective, by running the appropriate (near-)correlated sampling algorithm depending on whether or not. We turn to describing the problem we study in this section.
Submodular welfare maximization.
In the basic submodular welfare (SWF) maximization problem, we have buyers and sellers. Each seller sells some number of homogeneous items from some universe . Each buyer in turn has a monotone submodular valuation function (i.e., for every ). The objective is to allocate these items, at most one of each, to the buyers, so as to maximize the social welfare, , for the set of items allocated to . We can encode the constraint that at most items sold by are allocated, at most one of which to each buyer, by requiring the (possibly fractional) allocation vector with to be a concatenation of points in hypersimplexes, with appropriate .
SWF is NP-hard to approximate within a factor of [29]. There are many approaches to attain this approximation factor in polynomial time. Most relevant to our subsequent dynamic SWF reallocation problem is the relax-and-round approach, as follows: the continuous greedy algorithm can be used to provide a -approximation to the maximum multilinear extension subject to any solvable LP constraints, such as the above linear constraints [13]. One can then round the vectors using Algorithm 2, whose output satisfies the hypersimplex constraints (Property P1, matches the marginals (Property P2) and satisfies submodular dominance (see Theorem 30) (see Proposition 28), applying this algorithm to each sub-vector with coordinates , corresponding to the cardinality constraint of for items sold by . By the algorithm’s properties it satisfies all constraints, and as shown in the full version of the paper, this also satisfies submodular dominance for the entire vector (with the target marginals), and so the obtained value is at least as high as the multilinear extension, which gives us a -approximation [13].
The dynamic problem.
Suppose now that we have possible scenarios, corresponding to some buyers or sellers leaving or entering the market. Let denote the optimal SWF of scenario . We wish to provide a good approximation of , while guaranteeing swift reallocation when switching from one scenario to the other. In particular, we wish to provide a approximation (to be chosen shortly) for each configuration, while minimizing the maximum number of items reallocated. This can be captured by the following LP constraints, where is the fractional allocation to buyer of items of seller under scenario :
| (MMD-LP) | |||||
The above formulation is still missing the SWF-approximation. Building on the approximate-or-separate method of [10] (as outlined in the full version), we can provide in polynomial-time a solution to the above constraint subject to the multilinear extension of the objective submodular function over (the fractional assignment for scenario ) being a -approximation of for each . The question remains: how do we round all these vectors in a way to obtain bona fide integral solutions with low movement cost? [10] provide an approach that results in movement cost (i.e., a constant-approximation of the optimal movement cost). Unfortunately, their algorithm is history dependent, which may incentivize buyers and sellers to time their arrivals and departures. Our correlated sampling algorithm, in contrast, is history-independent. Using our correlated sampling algorithm, which satisfies the hard cardinality constraints (Property P1), the target marginals (Property P2), stretch (Theorem 2) and submodular dominance (Theorem 30), we obtain an algorithm with -approximation, using movement cost , i.e., times that of an optimal algorithm.
4.4 Discussion: From Dimension-Free to Constant
The above stretch for collusion-free reallocation can in fact be decreased to a constant for any constant , and specifically to , albeit at the cost of a (negligible) deterioration in approximation, and losing the history independence. Since this is subsumed by the history-dependent -stretch rounding of [10], we only outline the idea here briefly.
By sampling a uniform threshold for each coordinate, we can decide which elements to take to our solution (i.e., which item to sell to which buyer), using stretch : when for i.i.d., , we add to the output. This yields the correct marginals independently, and so yields a set of expected value exactly equal to the multilinear extension, , and moreover results in a set of expected size . To make this a feasible set, we can scale down the value by a factor of , thus obtaining a set of expected size . By simple concentration arguments, the probability that this set exceeds size is polynomially small in , and by submodularity, one can show that taking only a subset of the sampled elements if more than are sampled will only incur an expected additive loss of . Combined with the multiplicative loss from scaling down, this is a multiplicative factor and additive factor, provided is sufficiently large. On the other hand, by only keeping a subset of cardinality of the sampled elements , it is easy to obtain stretch . Thus, we get a loss in objective (provided the target value is ) with stretch if is larger than some . Alternatively, if is smaller than , then by applying this paper’s main correlated sampling algorithm, we get no loss in the objective value, but stretch , i.e., constant for any constant . In either case, we incur a stretch no worse than a deterioration in approximation quality, and a constant stretch of . We believe this pattern will find future applications.
5 Summary and Open Questions
In this work we revisit the correlated sampling question for the hypersimplex, , and provide dimension-free stretch guarantees for the latter. We provide stretch using a recursive algorithm of depth .
We note that any dimension-dependent stretch should imply by similar approaches an stretch with levels of recurrence, where is “the iterated ”, defined using the iteration of , namely . However, better than logarithmic dependence on is as yet unknown. Is this inherent, and is the optimal stretch given Properties P1 and P2? We leave this as a tantalizing open question.
We presented a number of applications, to online paging, metric multi-labeling and swift and history-independent dynamic reallocation for approximate submodular welfare maximization. While we do not see any of these applications as particularly compelling on their own, the variety of applications hints at further applications of our correlated sampling machinery. In particular, we discussed in Section 4.4, the dimension-independent stretch can, for some applications, be combined with simple rounding schemes to obtain constant stretch (while only approximately preserving marginals). We are optimistic that similarly to correlated sampling for the probability simplex, such (dimension-free) correlated sampling for the hypersimplex will find broader applications. We leave the search for such applications as a direction for future research.
References
- [1] Nima Anari, Ruiquan Gao, and Aviad Rubinstein. Parallel sampling via counting. In Proceedings of the 56th Annual ACM Symposium on Theory of Computing, pages 537–548, 2024. doi:10.1145/3618260.3649744.
- [2] Omer Angel and Yinon Spinka. Pairwise optimal coupling of multiple random variables. arXiv preprint arXiv:1903.00632, 2019.
- [3] Ghazi Badih, Kumar Ravi, and Manurangsi Pasin. User-level private learning via correlated sampling. Advances in Neural Information Processing Systems, 2021.
- [4] Boaz Barak, Moritz Hardt, Ishay Haviv, Anup Rao, Oded Regev, and David Steurer. Rounding parallel repetitions of unique games. In 2008 49th Annual IEEE Symposium on Foundations of Computer Science, pages 374–383, 2008. doi:10.1109/FOCS.2008.55.
- [5] Mohammad Bavarian, Badih Ghazi, Elad Haramaty, Pritish Kamath, Ronald L Rivest, and Madhu Sudan. Optimality of correlated sampling strategies. Theory of Computing, 16(1), 2020. doi:10.4086/TOC.2020.V016A012.
- [6] Petter Brändén and Johan Jonasson. Negative dependence in sampling. Scandinavian Journal of Statistics, 39(4):830–838, 2012.
- [7] Andrei Z Broder. On the resemblance and containment of documents. In Proceedings. Compression and Complexity of SEQUENCES 1997 (Cat. No. 97TB100171), pages 21–29, 1997. doi:10.1109/SEQUEN.1997.666900.
- [8] Niv Buchbinder, Kamal Jain, and Joseph (Seffi) Naor. Online primal-dual algorithms for maximizing ad-auctions revenue. In Proceedings of the 15th Annual European Symposium on Algorithms (ESA), pages 253–264. 2007.
- [9] Niv Buchbinder, Joseph (Seffi) Naor, and Roy Schwartz. Simplex partitioning via exponential clocks and the multiway-cut problem. SIAM Journal on Computing (SICOMP), 47(4):1463–1482, 2018. doi:10.1137/15M1045521.
- [10] Niv Buchbinder, Joseph (Seffi) Naor, David Wajc, et al. Chasing submodular objectives, and submodular maximization via cutting planes. arXiv preprint arXiv:2511.13605, 2025.
- [11] Mark Bun, Marco Gaboardi, Max Hopkins, Russell Impagliazzo, Rex Lei, Toniann Pitassi, Satchit Sivakumar, and Jessica Sorrell. Stability is stable: Connections between replicability, privacy, and adaptive generalization. In Proceedings of the 55th Annual ACM Symposium on Theory of Computing, pages 520–527, 2023. doi:10.1145/3564246.3585246.
- [12] Jarosław Byrka, Piotr Skowron, and Krzysztof Sornat. Proportional approval voting, harmonic k-median, and negative association. In Proceedings of the 45th International Colloquium on Automata, Languages and Programming (ICALP), page 26, 2018.
- [13] Gruia Calinescu, Chandra Chekuri, Martin Pál, and Jan Vondrák. Maximizing a monotone submodular function subject to a matroid constraint. SIAM Journal on Computing (SICOMP), 40(6):1740–1766, 2011. doi:10.1137/080733991.
- [14] Moses S Charikar. Similarity estimation techniques from rounding algorithms. In Proceedings of the thiry-fourth annual ACM symposium on Theory of computing, pages 380–388, 2002. doi:10.1145/509907.509965.
- [15] Chandra Chekuri, Jan Vondrak, and Rico Zenklusen. Dependent randomized rounding via exchange properties of combinatorial structures. In Proceedings of the 51st Symposium on Foundations of Computer Science (FOCS), pages 575–584, 2010.
- [16] Shahar Chen, Dotan Di Castro, Zohar Karnin, Liane Lewin-Eytan, Joseph Seffi Naor, and Roy Schwartz. Correlated rounding of multiple uniform matroids and multi-label classification. In Proceedings of the 44th International Colloquium on Automata, Languages and Programming (ICALP), 2017.
- [17] Tasos C Christofides and Eutichia Vaggelatou. A connection between supermodular ordering and positive/negative association. Journal of Multivariate analysis, 88(1):138–151, 2004.
- [18] Jean-Claude Deville and Yves Tille. Unequal probability sampling without replacement through a splitting method. Biometrika, 85(1):89–101, 1998.
- [19] Devdatt Dubhashi, Johan Jonasson, and Desh Ranjan. Positive influence and negative dependence. Combinatorics, Probability and Computing, 16(01):29–41, 2007. doi:10.1017/S0963548306007772.
- [20] Devdatt Dubhashi and Desh Ranjan. Balls and bins: A study in negative dependence. Random Struct. Algorithms, 13(2):99–124, 1998. doi:10.1002/(SICI)1098-2418(199809)13:2\%3C99::AID-RSA1\%3E3.0.CO;2-M.
- [21] Devdatt P Dubhashi, Volker Priebe, and Desh Ranjan. Negative dependence through the FKG inequality. BRICS Report Series, 3(27), 1996.
- [22] Lawrence R Ernst. The maximization and minimization of sample overlap problems: a half century of results. In Bulletin of the International Statistical Institute, Proceedings, volume 58, pages 293–296, 1999.
- [23] Uriel Feige. A threshold of for approximating set cover. Journal of the ACM (JACM), 45(4):634–652, 1998. doi:10.1145/285055.285059.
- [24] Amos Fiat, Richard M Karp, Michael Luby, Lyle A McGeoch, Daniel D Sleator, and Neal E Young. Competitive paging algorithms. Journal of Algorithms, 12(4):685–699, 1991. doi:10.1016/0196-6774(91)90041-V.
- [25] Dongdong Ge, Simai He, Yinyu Ye, and Jiawei Zhang. Geometric rounding: a dependent randomized rounding scheme. Journal of combinatorial optimization, 22:699–725, 2011. doi:10.1007/S10878-010-9320-Z.
- [26] Thomas Holenstein. Parallel repetition: simplifications and the no-signaling case. In Proceedings of the 39th Annual ACM Symposium on Theory of Computing (STOC), pages 411–419, 2007. doi:10.1145/1250790.1250852.
- [27] Kumar Joag-Dev and Frank Proschan. Negative association of random variables with applications. The Annals of Statistics, pages 286–295, 1983.
- [28] Nathan Keyfitz. Sampling with probabilities proportional to size: adjustment for changes in the probabilities. Journal of the American Statistical Association, 46(253):105–109, 1951.
- [29] Subhash Khot, Richard J Lipton, Evangelos Markakis, and Aranyak Mehta. Inapproximability results for combinatorial auctions with submodular utility functions. In Proceedings of the 1st Conference on Web and Internet Economics (WINE), pages 92–101, 2005. doi:10.1007/11600930_10.
- [30] Jon Kleinberg and Éva Tardos. Approximation algorithms for classification problems with pairwise relationships: Metric labeling and Markov random fields. Journal of the ACM (JACM), 49(5):616–639, 2002. doi:10.1145/585265.585268.
- [31] Josh Brown Kramer, Jonathan Cutler, and AJ Radcliffe. Negative dependence and srinivasan’s sampling process. Combinatorics, Probability and Computing, 20(3):347–361, 2011. doi:10.1017/S0963548311000095.
- [32] Hongyang Liu and Yitong Yin. Simple parallel algorithms for single-site dynamics. In Proceedings of the 54th Annual ACM SIGACT Symposium on Theory of Computing, pages 1431–1444, 2022. doi:10.1145/3519935.3519999.
- [33] Vahab Mirrokni, Michael Schapira, and Jan Vondrák. Tight information-theoretic lower bounds for welfare maximization in combinatorial auctions. In Proceedings of the 9th ACM conference on Electronic commerce, pages 70–77, 2008. doi:10.1145/1386790.1386805.
- [34] George L Nemhauser and Laurence A Wolsey. Best algorithms for approximating the maximum of a submodular set function. Mathematics of Operations Research (Math of OR), 3(3):177–188, 1978. doi:10.1287/MOOR.3.3.177.
- [35] Frederick Qiu and Sahil Singla. Submodular dominance and applications. In Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques (APPROX/RANDOM), 2022.
- [36] Ronald L Rivest. Symmetric encryption via keyrings and ecc. In Northernmost Crypto Workshop, Longyearbyen, Norway, Midnight Lect, 2016.
- [37] Ankit Sharma and Jan Vondrák. Multiway cut, pairwise realizable distributions, and descending thresholds. In Proceedings of the forty-sixth annual ACM symposium on Theory of computing, pages 724–733, 2014. doi:10.1145/2591796.2591866.
- [38] Aravind Srinivasan. Distributions on level-sets with applications to approximation algorithms. In Proceedings of the 42nd Symposium on Foundations of Computer Science (FOCS), pages 588–597, 2001. doi:10.1109/SFCS.2001.959935.
