Probabilistic Subset Construction

• Probabilistic Subset Construction is a family of techniques that use randomized rules to generate and analyze subsets, balancing the trade-offs between efficiency and exhaustive search.
• Methods such as subset sampling, randomized halving, and hash-based selection provide both theoretical insights and practical performance gains in dynamic and static settings.
• Derandomization strategies through bisectors, splitters, and universal sets demonstrate applications in complexity theory, graph mining, and reliability analysis.

Probabilistic subset construction denotes a family of techniques in which subsets are generated, filtered, or enumerated by probabilistic rules and then analyzed either directly or through explicit derandomization. In one canonical formulation, a hidden subset $S\subseteq[n]$ of size $k$ is sought by repeatedly deleting half of the universe; a round succeeds with probability $2^{-k}$, so $E[\#\mathrm{rounds}]=2^k$, and if each round costs $O(n)$ time, the total expected time is $O(n\cdot 2^k)$ (Burjons et al., 13 May 2025). In another canonical formulation, subset sampling draws $T\subseteq S$ so that each $x_i$ is independently included with probability $p_i$, with distribution

$$\Pr[T=\tau]=\prod_{x_i\in\tau}p_i\;\times\;\prod_{x_j\notin\tau}(1-p_j),$$

and expected output size $k$0 (Yi et al., 2023). Related literatures use probabilistic constructions to obtain $k$1-biased sets of size $k$2, to define consistent samplers for $k$3-subsets, and to build Kakeya-type sets by sticky maps and Bernoulli percolation (Moore et al., 2012, Kutzkov et al., 2014, Hagelstein et al., 2024).

1. Formal models and baseline randomized procedures

A central formal model is subset sampling on a finite set $k$4, where each event $k$5 has an associated inclusion probability $k$6, and a query returns a subset $k$7 in which every $k$8 is included independently with probability $k$9. The dynamic setting further allows four operations to interleave with sampling: $2^{-k}$0, $2^{-k}$1, $2^{-k}$2, and $2^{-k}$3. The target complexity is $2^{-k}$4 expected sampling time and $2^{-k}$5 worst-case update time, where $2^{-k}$6 is the expected output size (Yi et al., 2023).

A distinct but related baseline is randomized halving-and-search. Here an unknown hidden subset $2^{-k}$7 with $2^{-k}$8 is isolated by choosing a random subset $2^{-k}$9 of size $E[\#\mathrm{rounds}]=2^k$0, checking whether $E[\#\mathrm{rounds}]=2^k$1, and, if successful, recursing on $E[\#\mathrm{rounds}]=2^k$2. Since each of the $E[\#\mathrm{rounds}]=2^k$3 hidden elements must survive the half-subsample, the success probability in one round is $E[\#\mathrm{rounds}]=2^k$4, hence the expected number of rounds is $E[\#\mathrm{rounds}]=2^k$5. This model exposes the basic tension between probabilistic restriction and exhaustive search: randomness gives a very simple subset construction, but its success probability decays exponentially in $E[\#\mathrm{rounds}]=2^k$6 (Burjons et al., 13 May 2025).

The lower-bound theory for dynamic subset sampling formalizes output sensitivity. At least $E[\#\mathrm{rounds}]=2^k$7 time is needed to write down an expected $E[\#\mathrm{rounds}]=2^k$8 output elements, and an information-theoretic argument yields an $E[\#\mathrm{rounds}]=2^k$9 query lower bound. In the cell-probe model, any single update must cost $O(n)$0. Formally, in the dynamic subset-sampling problem any data structure with $O(n)$1 expected query time and $O(n)$2 update time must satisfy

$O(n)$3

(Yi et al., 2023). This lower-bound regime is the benchmark against which optimal constructions are evaluated.

2. Derandomizing random restriction: bisectors, splitters, and universal sets

The most explicit derandomization of probabilistic subset construction in the supplied literature is the theory of bisectors. A family $O(n)$4 of functions $O(n)$5 is an $O(n)$6-bisector if, for every $O(n)$7, exactly half of the points are mapped to $O(n)$8 and half to $O(n)$9, and for every $O(n\cdot 2^k)$0-subset $O(n\cdot 2^k)$1 there exists some $O(n\cdot 2^k)$2 with $O(n\cdot 2^k)$3 for all $O(n\cdot 2^k)$4. Equivalently, $O(n\cdot 2^k)$5 derandomizes the “survive the half” test: by exhaustively trying all $O(n\cdot 2^k)$6, one guarantees that one of them keeps all $O(n\cdot 2^k)$7 hidden points (Burjons et al., 13 May 2025).

The main existence and construction results replace the randomized $O(n\cdot 2^k)$8-round process by explicit deterministic families of essentially the same exponential order.

Object	Requirement	Size bound
$O(n\cdot 2^k)$9-bisector	Exact half mapped to $T\subseteq S$0, every $T\subseteq S$1-set survives in some $T\subseteq S$2	$T\subseteq S$3
$T\subseteq S$4-bisector	Exact $T\subseteq S$5 ones	$T\subseteq S$6
Uniform $T\subseteq S$7-universal set	Correctly maps every ordered bipartition $T\subseteq S$8 and has exact $T\subseteq S$9 ones	$x_i$0

The explicit bisector construction proceeds in three stages. First, it builds a small bisector on universe size $x_i$1: by enumeration plus a greedy “cover argument” there is a family $x_i$2 of size $x_i$3 which is a $x_i$4-bisector. Second, it lifts from $x_i$5 to $x_i$6 by a uniform $x_i$7-splitter and a Chinese Remainder argument, using a splitter $x_i$8 of size $x_i$9 so that every $p_i$0-set is injectively colored in some $p_i$1. Third, it amplifies the zero-fraction to exactly $p_i$2 by an iterated product construction. All steps run in time linear in $p_i$3 plus a $p_i$4-time brute-force subroutine on $p_i$5, so the overall time is $p_i$6 (Burjons et al., 13 May 2025).

Uniform universal sets generalize classical universal sets by imposing an exact Hamming-weight constraint at the same time. For $p_i$7, both the bisector and uniform universal-set constructions yield $p_i$8, which is nearly optimal up to the $p_i$9 lower bound. The applications given include derandomization of reductions between average-case complexity classes, parallel black-box search, secret-sharing, circuit-testing, subgraph isomorphism, and color-coding (Burjons et al., 13 May 2025).

3. Output-sensitive subset sampling and dynamic data structures

The dynamic subset-sampling line seeks exact independent-inclusion sampling with query time proportional to expected output size. ODSS is presented as the first optimal dynamic subset sampling algorithm: its expected query time and update time are both optimal, matching the lower bounds of the subset sampling problem. The construction uses a hierarchy of levels $$\Pr[T=\tau]=\prod_{x_i\in\tau}p_i\;\times\;\prod_{x_j\notin\tau}(1-p_j),$$0. Level $$\Pr[T=\tau]=\prod_{x_i\in\tau}p_i\;\times\;\prod_{x_j\notin\tau}(1-p_j),$$1 partitions $$\Pr[T=\tau]=\prod_{x_i\in\tau}p_i\;\times\;\prod_{x_j\notin\tau}(1-p_j),$$2 into buckets

$$\Pr[T=\tau]=\prod_{x_i\in\tau}p_i\;\times\;\prod_{x_j\notin\tau}(1-p_j),$$3

defines one level-$$\Pr[T=\tau]=\prod_{x_i\in\tau}p_i\;\times\;\prod_{x_j\notin\tau}(1-p_j),$$4 element $$\Pr[T=\tau]=\prod_{x_i\in\tau}p_i\;\times\;\prod_{x_j\notin\tau}(1-p_j),$$5 per bucket with probability

$$\Pr[T=\tau]=\prod_{x_i\in\tau}p_i\;\times\;\prod_{x_j\notin\tau}(1-p_j),$$6

and then repeats the same reduction from level $$\Pr[T=\tau]=\prod_{x_i\in\tau}p_i\;\times\;\prod_{x_j\notin\tau}(1-p_j),$$7 to level $$\Pr[T=\tau]=\prod_{x_i\in\tau}p_i\;\times\;\prod_{x_j\notin\tau}(1-p_j),$$8. Since $$\Pr[T=\tau]=\prod_{x_i\in\tau}p_i\;\times\;\prod_{x_j\notin\tau}(1-p_j),$$9, level $k$00 can be handled by a precomputed table of size $k$01, where $k$02. Sampling combines table lookup with rejection and “SampleWithinBucket”, which generates geometric spacings at rate $k$03 and rejects each candidate $k$04 with probability $k$05 (Yi et al., 2023).

Updates are localized because each bucket is stored as a dynamic array, each element carries pointers into its bucket, and insertion, deletion, or probability change touches only $k$06 buckets across the three levels. ODSS therefore achieves $k$07 expected query time and $k$08 update time, and its concrete application to influence maximization uses dynamic subset sampling inside RR-sketch generation on evolving social networks. In the reported experiments, query time scales as $k$09, update time is constant for ODSS, and plugging ODSS into influence-maximization pipelines yields $k$10 speed-ups over previous dynamic replacements of BringmannSS (Yi et al., 2023).

A closely related framework provides a dynamic in-memory data structure with $k$11 space, $k$12 expected query time, and $k$13 amortized expected update, insert, and delete time. Its basic ingredients are geometric-gap “jumping to the next sample”, bucketing by probability magnitude into

$k$14

and repeated size-reduction until the top-level instance has size $k$15, where a table-lookup method applies. The same work also gives a static external-memory algorithm with

$k$16

amortized expected I/Os using $k$17 space, and a dynamic range-subset-sampling structure with $k$18 space, $k$19 expected query time, and $k$20 amortized expected update, insert, and delete time (Huang et al., 2023).

4. Hash-based subset selection, sketching, and consistent sampling

Hash-based constructions supply another major interpretation of probabilistic subset construction. In bottom-$k$21 sampling, a sample $k$22 consists of the $k$23 elements of $k$24 with smallest hash values. For a subset $k$25 with frequency $k$26, the estimator

$k$27

is unbiased. For Jaccard similarity, bottom-$k$28 is mergeable: $k$29 With only $k$30-independent hashing, bottom-$k$31 retains expected relative error $k$32, and for weighted sets, priority sampling defines priorities $k$33, uses the $k$34-st largest priority as threshold $k$35, and reports $k$36 on sampled items, yielding unbiased subset-sum estimation (Thorup, 2013).

Consistent subset sampling generalizes single-item consistent sampling to size-$k$37 subsets occurring inside a set of size at most $k$38. The naive approach tests all $k$39-subsets in $k$40 time. Using a carefully designed hash function, the expected time improves to

$k$41

with space usage

$k$42

The construction takes a $k$43-wise independent hash $k$44, defines the subset hash by summing item hashes modulo $k$45, and includes a $k$46-subset when the hash of its first half equals the hash of its second half. Distinct inclusion events are pairwise independent, so the sample size has variance at most its mean, and applications include estimating the number of frequent $k$47-itemsets in a transaction stream, estimating the number of bipartite cliques in an incidence-stream graph, parallel or distributed frequent itemset mining, and graph stream mining (Kutzkov et al., 2014).

These hash-based techniques differ from dynamic subset-sampling structures in implementation, but they share the same governing idea: a compact probabilistic rule specifies a subset, and limited independence is often enough to preserve unbiasedness and concentration.

5. Subset construction over implicit and structured domains

When the target set is defined implicitly rather than explicitly, subset construction must be fused with an indexing scheme. Subset sampling over joins studies the problem of drawing a Poisson sample from the result of an acyclic relational join without materializing the full join result. If $k$48 is an acyclic join and each join tuple $k$49 receives probability

$k$50

for a decomposable aggregator such as product, sum, min, or max, then the goal is to sample each join tuple independently with probability $k$51. The expected sample size is

$k$52

(Esmailpour et al., 18 Dec 2025).

The static-index solution uses “bucket-and-reject”. It assigns each tuple a score

$k$53

partitions the join result into buckets $k$54, and treats each bucket as approximately uniform. The index stores only combinatorial statistics $k$55 and $k$56, computed bottom-up over the join tree, together with prefix-sum trees. A recursive $k$57 routine extracts the $k$58-th tuple of score $k$59 in lexicographic order in $k$60 time. The resulting static index has preprocess time $k$61, space $k$62, and per-sample expected time $k$63. The one-shot algorithm replaces heavy pre-indexing by batched access and runs in

$k$64

expected time, plus the one-time statistics build. The dynamic index supports insertions with $k$65 amortized update time, $k$66 space, and unchanged $k$67 sampling time (Esmailpour et al., 18 Dec 2025).

This line extends probabilistic subset construction from arrays and explicit sets to relationally defined combinatorial spaces. A plausible implication is that the same bucket-and-reject principle is robust across explicit, hierarchical, and implicit representations, provided one can maintain an access structure that exposes approximate uniformity at the right scale.

6. Pseudorandom, geometric, and decision-theoretic variants

In pseudorandomness, probabilistic subset construction appears in the construction of $k$68-biased sets in $k$69. A fully random construction chooses $k$70 independent uniform vectors and yields an $k$71-biased set of size $k$72, but it uses $k$73 random bits. Two partial derandomizations preserve the same asymptotic size while sharply reducing randomness: one uses Nisan’s space-bounded pseudorandom generator and requires $k$74 random bits, and the other adds randomness to a Legendre symbol construction and uses Weil sums to bound high moments of the bias, requiring $k$75 random bits (Moore et al., 2012).

In geometric analysis, Kakeya-type sets are built by probabilistic thinning of a dyadic tree of tubes. After fixing an $k$76-separated subtree $k$77, one chooses a sticky map $k$78 from the full binary tree to $k$79, performs independent Bernoulli$k$80 percolation on the non-root vertices, and keeps the tubes associated with surviving leaves. If the height is $k$81, then a fixed leaf survives with probability $k$82, the random subtree has in expectation $k$83 leaves, and the expected measure satisfies $k$84. Under the stated separation hypothesis on $k$85, the associated directional maximal operator $k$86 is unbounded on $k$87 for every $k$88 (Hagelstein et al., 2024).

A separate but related use of subset structure appears in cost-sensitive feature acquisition. VOILA organizes only the irreducible subsets

$k$89

into a directed acyclic graph ordered by inclusion, computes the expected value of information

$k$90

and maximizes $k$91. VOILA exploits d-separation, bound propagation, and inference caching, and empirical evaluation on five medical datasets shows that the greedy strategy is often reluctant to acquire features, as it cannot forecast the benefit of acquiring multiple features in combination (Bilgic et al., 2014).

In structural reliability, Subset Simulation is a Markov chain Monte Carlo method for computing small failure probabilities by iteratively sampling from nested subsets in the input space of a performance function. “Niching Subset Simulation” augments this method with niching from evolutionary multimodal optimization, dynamically partitions the input space using support vector machines, and introduces a community-detection-based niching technique designed for high-dimensional problems; it is reported to be robust against ergodicity problems and to offer additional insight into the topology of challenging reliability problems (Kinnear et al., 2022).

Taken together, these variants indicate that probabilistic subset construction is not confined to one algorithmic primitive. The supplied research instead shows a recurrent pattern: randomized subset rules, often extremely simple in their baseline form, are refined by bucketing, hashing, splitters, percolation, or probabilistic independence so as to obtain exactness, derandomization, output-sensitive complexity, or structural insight in domains ranging from average-case complexity to data streams, joins, reliability, geometry, and cost-sensitive inference.