Counting-to-Sampling Reduction

• Counting-to-sampling reduction is an algorithmic transformation that converts counting information into randomized sampling protocols through recursive decomposition of the sample space.
• It employs both exact and approximate counts, using methods like rejection sampling and hashing to correct for errors and achieve uniform or near-uniform distributions.
• The approach is applied in areas such as structured graph sampling, trace languages, constrained SAT, and oracle-based witness extraction in complex combinatorial settings.

Searching arXiv for the cited papers and related work on counting-to-sampling reductions. Searching arXiv for "(Dell et al., 2019) Approximately counting and sampling small witnesses colourful independence oracle". A counting-to-sampling reduction is an algorithmic transformation that uses exact counts, approximate counts, or counting-style oracle access on conditioned subinstances to generate a random element of a target set. In its exact form, the reduction recursively decomposes a finite set $\Omega$ into disjoint pieces and chooses each branch with probability equal to the ratio of its subcount to the parent count. In its approximate form, the same idea is supplemented by rejection, correction, or hashing so that the output distribution is uniform or close to uniform despite count error. This paradigm appears in oracle-based witness extraction, recursive generation of structured graph classes, trace languages, constrained SAT, and even arbitrary distributions over $[q]^n$ accessed through counting queries (Dell et al., 2019, Hebert-Johnson et al., 2023, Anari et al., 2024).

1. Formal scheme and canonical guarantees

The exact template is explicit in recursive samplers for combinatorial classes. If $\Omega=\biguplus_{i\in I}\Omega_i$ and the counts $C_i=|\Omega_i|$ are available, then selecting

$$P(i)=\frac{C_i}{\sum_{j\in I}C_j}=\frac{|\Omega_i|}{|\Omega|}$$

and recursing into $\Omega_i$ yields a uniform draw from $\Omega$. In the chordal-graph setting, this principle is implemented by decomposing the class by the size of the connected component containing vertex $1$, then by evaporation time, then by the size of the final simplicial block, and then by further recursive splittings; because every branch is weighted by an exact integer count from the dynamic program, the output distribution is provably uniform (Hebert-Johnson et al., 2023).

Approximate variants replace exact subcounts by estimators. In the colourful-independence-oracle model for a $k$-hypergraph $G=(V,E)$, an $[q]^n$0-approximate count of $[q]^n$1 is a number $[q]^n$2 satisfying $[q]^n$3, while an $[q]^n$4-approximate sampler is a randomized procedure that, with probability at least $[q]^n$5, outputs an edge $[q]^n$6 and satisfies

$[q]^n$7

for every $[q]^n$8. The core difficulty is that branch probabilities computed from approximate counts do not automatically preserve uniformity; the reduction must control error accumulation across recursive or filtering steps (Dell et al., 2019).

A broader formulation replaces explicit counting by oracle access to marginals. For an arbitrary distribution $[q]^n$9 on $\Omega=\biguplus_{i\in I}\Omega_i$0, a counting query $\Omega=\biguplus_{i\in I}\Omega_i$1 determines conditional marginals by division, and these marginals can be used to sample exactly from $\Omega=\biguplus_{i\in I}\Omega_i$2. In that setting, counting information is not merely an aid to sampling but the primitive from which sampling is constructed (Anari et al., 2024).

2. Exact reductions through recursive decomposition

The cleanest exact reductions are based on self-reducibility. In the labeled chordal-graph problem, exact preprocessing computes counters such as $\Omega=\biguplus_{i\in I}\Omega_i$3 for all $\Omega=\biguplus_{i\in I}\Omega_i$4-colorable labeled chordal graphs on $\Omega=\biguplus_{i\in I}\Omega_i$5 vertices, $\Omega=\biguplus_{i\in I}\Omega_i$6 for connected ones, and intermediate quantities $\Omega=\biguplus_{i\in I}\Omega_i$7, $\Omega=\biguplus_{i\in I}\Omega_i$8, and $\Omega=\biguplus_{i\in I}\Omega_i$9. Sampling then mirrors the dynamic-programming recurrences: choose the size $C_i=|\Omega_i|$0 of the connected component of vertex $C_i=|\Omega_i|$1 with probability

$C_i=|\Omega_i|$2

sample the component recursively, sample the remainder recursively, relabel, and take the union. Subsequent recursive calls choose evaporation times and block sizes using analogous exact ratios. No approximation appears in the sampler itself, and after the $C_i=|\Omega_i|$3 preprocessing the paper states that one complete sample runs in $C_i=|\Omega_i|$4 arithmetic steps, or more precisely $C_i=|\Omega_i|$5 bit-operations when each integer has $C_i=|\Omega_i|$6 bits (Hebert-Johnson et al., 2023).

A classical exact reduction also appears for arborescences. Given a counting oracle, one processes edges in a fixed order. At each step one computes $C_i=|\Omega_i|$7, the total weight of all rooted arborescences in the current graph, and $C_i=|\Omega_i|$8, the total weight of those including the next edge. The edge is included with probability $C_i=|\Omega_i|$9, after which the graph is updated by contraction or deletion. Correctness follows by induction on the conditional distribution of completions. The same source emphasizes the principal limitation: each iteration must await the outcome of the previous coin flip, because that outcome changes the graph on which future counts are performed. Even when each count is a determinant and hence lies in NC, the reduction itself is inherently sequential and therefore not in NC (Anari et al., 2020).

These exact constructions illustrate the core algebra of counting-to-sampling. Exact subcounts do not merely estimate relative mass; they define the exact conditional law of the next recursive choice. The resulting sampler is often transparent to analyze, but its efficiency depends on whether the underlying combinatorial class admits tractable exact conditioning counts.

3. Approximate counts, rejection, and almost-uniformity

When only approximate counts are available, the reduction typically combines approximate branch weighting with a bias-correction mechanism. In the $$P(i)=\frac{C_i}{\sum_{j\in I}C_j}=\frac{|\Omega_i|}{|\Omega|}$$0-hypergraph witness problem, the algorithm generates nested subsets

$$P(i)=\frac{C_i}{\sum_{j\in I}C_j}=\frac{|\Omega_i|}{|\Omega|}$$1

each half the size of the previous one, until $$P(i)=\frac{C_i}{\sum_{j\in I}C_j}=\frac{|\Omega_i|}{|\Omega|}$$2. If $$P(i)=\frac{C_i}{\sum_{j\in I}C_j}=\frac{|\Omega_i|}{|\Omega|}$$3 is a $$P(i)=\frac{C_i}{\sum_{j\in I}C_j}=\frac{|\Omega_i|}{|\Omega|}$$4 approximation to $$P(i)=\frac{C_i}{\sum_{j\in I}C_j}=\frac{|\Omega_i|}{|\Omega|}$$5, the algorithm proposes a random half-subset $$P(i)=\frac{C_i}{\sum_{j\in I}C_j}=\frac{|\Omega_i|}{|\Omega|}$$6 and accepts it with probability $$P(i)=\frac{C_i}{\sum_{j\in I}C_j}=\frac{|\Omega_i|}{|\Omega|}$$7; otherwise it resamples. After the final stage, it enumerates $$P(i)=\frac{C_i}{\sum_{j\in I}C_j}=\frac{|\Omega_i|}{|\Omega|}$$8 exactly using $$P(i)=\frac{C_i}{\sum_{j\in I}C_j}=\frac{|\Omega_i|}{|\Omega|}$$9 calls to the colourful independence oracle and returns a uniform edge from that residual instance. The analysis shows that if all counts are within multiplicative $\Omega_i$0, then the final edge is within $\Omega_i$1 in total-variation distance of uniform; choosing $\Omega_i$2 and boosting confidence yields overall failure at most $\Omega_i$3 (Dell et al., 2019).

The trace-language setting uses a different approximate mechanism. To sample a Mazurkiewicz trace touching the $\Omega_i$4th slice of a regular language, the sampler generates the lexicographically smallest representative letter by letter. For a current normal-form prefix $\Omega_i$5, it estimates the number $\Omega_i$6 of completions whose normal form begins with $\Omega_i$7, and for each valid extension $\Omega_i$8 it estimates $\Omega_i$9 by calling the FPRAS on a prefix-validator automaton intersected with the original automaton. The next symbol is chosen with probability proportional to the estimated $\Omega$0. A final rejection-accept step then makes the conditional distribution exactly uniform over all normal forms of traces, and $\Omega$1 independent trials reduce the total-variation distance of the output distribution to at most $\Omega$2 (Colnet et al., 29 Nov 2025).

Hashing-based constrained sampling provides a third pattern. ApproxMC2 approximately counts satisfying assignments by partitioning the solution set with random XOR constraints into cells of manageable size. UniGen then uses the approximate count $\Omega$3 to choose the number of hash constraints so that the expected cell size is about $\Omega$4, repeatedly samples a random cell, enumerates the solutions if the cell size falls in the accepted interval, and chooses one uniformly from that cell. The resulting distribution has total-variation distance at most $\Omega$5 from uniform over $\Omega$6 (Meel, 2018).

Across these examples, approximate counting does not eliminate the need for sampling design; it shifts the design problem to controlling distortion introduced by inexact ratios. Rejection sampling, end-of-run correction, and careful cell-size calibration are the standard remedies.

4. Oracle models, self-reducibility, and representative domains

The reduction is rarely “counting-only” in an unstructured sense. It usually relies on a problem-specific oracle model or self-reducible representation that makes conditioned counts meaningful and computable.

Domain	Counting access used by the reduction	Sampling guarantee
Small witnesses in $\Omega$7-hypergraphs	CountOracle plus colourful independence oracle $\Omega$8	$\Omega$9-approximately uniform edge (Dell et al., 2019)
$1$0-colorable labeled chordal graphs	Exact DP tables $1$1, $1$2, $1$3, $1$4, $1$5, $1$6	Provably uniform output (Hebert-Johnson et al., 2023)
Mazurkiewicz traces of regular languages	FPRAS on prefix-validator automata $1$7	TV distance at most $1$8 (Colnet et al., 29 Nov 2025)
CNF solutions	ApproxMC2 counts on random XOR cells	$1$9 (Meel, 2018)
Arbitrary $k$0 on $k$1	COUNT or conditional-marginal oracle MARG	Output has exactly law $k$2 (Anari et al., 2024)

In the colourful-independence model, the hypergraph is not given explicitly; it is accessed only through calls to

$k$3

which reports whether the induced $k$4-partite subhypergraph contains a colourful edge. The counting-to-sampling reduction is therefore a black-box transformation relative to that oracle interface and a randomized CountOracle (Dell et al., 2019).

In chordal graphs, the oracle is not external but precomputed: after $k$5 preprocessing, the sampler has constant-time access to all dynamic-programming counters. The reduction is exact because every recursive decomposition case has an exact stored count (Hebert-Johnson et al., 2023).

In trace languages, the needed counting queries are themselves language-recognition tasks: one must count traces whose normal form extends a given prefix. That is why the reduction depends on prefix-validator DFAs and predictive membership for traces (Colnet et al., 29 Nov 2025).

For arbitrary distributions on product spaces, the oracle abstraction is even more explicit. COUNT answers probabilities of cylinder events, and MARG returns conditional marginals. The reduction no longer navigates a preexisting combinatorial decomposition; it constructs a sample directly from conditional laws derived from counting queries (Anari et al., 2024).

5. Sequentiality, parallelization, and distributed variants

A common misconception is that counting-to-sampling reductions are intrinsically sequential because they condition variable by variable or edge by edge. Some classical constructions are indeed sequential. The arborescence reduction updates the instance after every inclusion or exclusion decision, and that dependency chain is the reason the classical method is not in NC (Anari et al., 2020).

However, richer oracle access can substantially change the parallel depth. For arbitrary distributions on $k$6, a parallel algorithm randomizes the coordinate ordering, performs a “guess” phase and a “verify” phase using a universal coupler, and advances the frontier to the first mismatch. The output has exactly the same law $k$7, the algorithm terminates in at most $k$8 rounds, and its expected round complexity is

$k$9

The same work proves a lower bound of $G=(V,E)$0 rounds for any parallel sampling algorithm making at most $G=(V,E)$1 counting-oracle queries per round, even for $G=(V,E)$2 (Anari et al., 2024).

A related phenomenon appears in the LOCAL model of distributed computing. For self-reducible classes of instances, approximate inference and approximate sampling are computationally equivalent up to polylogarithmic factors. More precisely, approximate inference in $G=(V,E)$3 rounds implies approximate sampling in

$G=(V,E)$4

rounds, approximate sampling implies approximate inference in the same round complexity, and for local Gibbs distributions a multiplicative-error inference oracle yields an exact LOCAL sampler in

$G=(V,E)$5

rounds (Feng et al., 2018).

These results show that the obstacle is not counting-to-sampling per se, but the structure of the conditioning interface. Edge-by-edge self-reduction can be inherently sequential; parallel counting or marginal queries can support sublinear-depth or distributed sampling.

6. Scope, applications, and conceptual boundaries

Counting-to-sampling reductions are used where exact or approximate enumeration is algorithmically easier than direct random generation. In the oracle-based witness framework, the reduction turns certain kinds of decision algorithms into approximate counting and sampling algorithms with little overhead, with applications to fine-grained problems such as $G=(V,E)$6-SUM, $G=(V,E)$7-OV, and weighted $G=(V,E)$8-Clique, and to parameterized problems such as induced subgraphs of size $G=(V,E)$9 or weight-$[q]^n$00 solutions to CSPs (Dell et al., 2019). In trace languages, the motivating applications are bounded model checking with partial-order reduction and testing methods for concurrent programs that use partial-order-aware random exploration (Colnet et al., 29 Nov 2025). In constrained SAT and SMT, the cited applications include network reliability, privacy, probabilistic reasoning, and constrained-random verification (Meel, 2018).

Two conceptual boundaries recur throughout the literature. First, approximate counting does not by itself imply nearly uniform sampling. The sampler must compensate for multiplicative error by rejection or an equivalent correction step; this is explicit in oracle-based witness sampling, in trace sampling, and in hashing-based constrained sampling (Dell et al., 2019, Colnet et al., 29 Nov 2025, Meel, 2018). Second, counting-to-sampling is only one direction in a broader equivalence. Other works study the reverse reduction, namely counting via sampling, through simulated annealing and related telescoping-product estimators, including adaptive schedules, one-round parallel reductions, and two-round adaptive algorithms [0612058], (Liu et al., 2024, Harris et al., 1 Apr 2026). This suggests that “counting-to-sampling reduction” is best understood not as a single algorithm, but as one half of a family of transformations linking conditional enumeration, inference, and random generation.

In that broader view, the central design question is always the same: which conditioned quantities can be counted accurately enough, cheaply enough, and in a sufficiently compositional way to support random generation? Exact dynamic programs, approximate subcounts, marginal oracles, and universal hashing provide different answers, but they all instantiate the same principle: sampling becomes feasible once the mass of every local choice can be quantified.