Partitioned Set Reconciliation (PSR)

• Partitioned Set Reconciliation is a divide-and-conquer method that splits large set differences into smaller partitions, enabling efficient local reconciliation.
• PSR leverages recursive partitioning using techniques like range-based fingerprints, characteristic polynomials, or IBLTs to achieve near-linear communication cost and parallel decoding.
• Enhanced variants such as EPSR reuse parent summaries to nearly halve communication overhead while maintaining similar decoding complexity.

Searching arXiv for recent and foundational papers on partitioned set reconciliation. Partitioned Set Reconciliation (PSR) is a family of set reconciliation methods in which two parties holding similar sets reconcile their symmetric difference by decomposing the problem into smaller subproblems over partitions, rather than decoding the entire difference in one step. In the formulation studied in "Tree algorithms for set reconciliation" (Lázaro et al., 2 Sep 2025), PSR is a divide-and-conquer strategy in which sets are successively partitioned until each partition contains at most a predetermined number of differences that can be decoded by a local set-representation primitive. In "Range-Based Set Reconciliation" (Meyer, 2022), the same paradigm is described more generically as recursively partitioning an ordered key space and comparing compact fingerprints on subranges, descending only where discrepancies are detected. In IBLT-oriented formulations, PSR similarly stripes or buckets the universe into independent partitions, sketches each partition, and decodes them in parallel (Belazzougui et al., 2024). Across these variants, the defining feature is that reconciliation cost is driven by the distribution of differences across partitions rather than by a monolithic global decode.

1. Definitions and problem setting

In the two-party setting formalized in (Lázaro et al., 2 Sep 2025), node $A$ and node $B$ hold finite sets $S_A \subseteq U$ and $S_B \subseteq U$ over a universe $U$ of $n$ elements, with $m_A = |S_A|$ and $m_B = |S_B|$. The reconciliation objective is the symmetric difference

$D = S_A \oplus S_B,\qquad k = |D|,$

so that $A$ learns $B$0 with minimal communication from $B$1 (Lázaro et al., 2 Sep 2025). In this communication model, $B$2 sends summaries of its partitions to $B$3, $B$4 may send short requests or feedback, only $B$5 bits are counted toward communication cost, links are reliable, and the algorithms are multi-round (Lázaro et al., 2 Sep 2025).

A broader formulation appears in range-based PSR, where the universe is endowed with a total order and reconciliation proceeds over ordered subranges rather than arbitrary hash buckets (Meyer, 2022). There, PSR is the general paradigm of reconciling remotely held sets by recursively partitioning an ordered key space, comparing compact fingerprints on each partition, and descending only into subranges whose fingerprints disagree (Meyer, 2022). The range from $B$6 to $B$7 is defined as

$B$8

This formulation emphasizes PSR as a recursion on a $B$9-ary partition tree whose internal nodes are partitions and whose leaves are regions resolved either by matching fingerprints or by explicit item transfer (Meyer, 2022).

Another formulation, used in probabilistic sketching work, treats PSR as striping or bucketing into $S_A \subseteq U$0 independent partitions, maintaining one sketch per partition, and decoding each partition separately (Belazzougui et al., 2024). This version is motivated by reduced variance in decoding time, localized failures, and parallelism while keeping total sketch size near-linear in the number of differences (Belazzougui et al., 2024).

These descriptions are compatible rather than contradictory. This suggests that PSR is best understood as a design pattern: partition first, decode locally, recurse or retry only where local evidence indicates unresolved disagreement.

2. Core mechanics of PSR

In the characteristic-polynomial-based formulation of (Lázaro et al., 2 Sep 2025), both PSR and its enhanced variant use a set representation primitive $S_A \subseteq U$1 with parameters $S_A \subseteq U$2, $S_A \subseteq U$3, and $S_A \subseteq U$4. Here, $S_A \subseteq U$5 is the threshold for guaranteed successful recovery, $S_A \subseteq U$6 controls false success probability, and $S_A \subseteq U$7 is a tunable parameter that further reduces false success probability (Lázaro et al., 2 Sep 2025). The false success probability when attempting recovery from an SR holding $S_A \subseteq U$8 elements is

$S_A \subseteq U$9

and the transmitted SR size is

$S_B \subseteq U$0

bits (Lázaro et al., 2 Sep 2025). The dominant SR operation is recovery, with complexity $S_B \subseteq U$1 (Lázaro et al., 2 Sep 2025).

Classical PSR in this setting proceeds as follows. If recovery on the whole universe succeeds, then the symmetric difference has size at most $S_B \subseteq U$2 and the protocol terminates. Otherwise, the current partition is split into $S_B \subseteq U$3 child partitions, each child is reconciled independently in parallel, and the results are unioned; recursion stops in a partition once its differences are at most $S_B \subseteq U$4 (Lázaro et al., 2 Sep 2025). A $S_B \subseteq U$5-ary partition may be fair, with $S_B \subseteq U$6, or nonuniform, with arbitrary probabilities $S_B \subseteq U$7 (Lázaro et al., 2 Sep 2025).

Range-based PSR has the same recursive structure but substitutes fingerprints over ordered subranges for local decoders (Meyer, 2022). One party sends a range fingerprint for a partition; if the fingerprints match, that partition is reconciled. If they differ, the receiving party expands the partition into up to $S_B \subseteq U$8 child subranges chosen so that its own set has roughly equal counts in each subrange, and then either sends child fingerprints or, when a subrange is sufficiently small or the peer’s fingerprint is empty, sends the explicit items in the subrange (Meyer, 2022). The recursion tree terminates where fingerprints match or item exchange completes the local reconciliation (Meyer, 2022).

IBLT-based PSR follows the same high-level workflow at the sketch level. A standard workflow is to choose $S_B \subseteq U$9 hash functions and $U$0 buckets per partition, maintain an IBLT with only a keysum field per partition, XOR sketches to form a difference digest, and decode each partition by peeling buckets that look pure until the partition either empties or leaves a 2-core (Belazzougui et al., 2024). The desired properties in that setting are sketch size near-linear in $U$1, near-linear or sublinear decoding time with low variance, low failure probability, and the ability to label each element in the symmetric difference by origin set (Belazzougui et al., 2024).

3. Analytical structure and complexity

The explicit finite-length analysis in (Lázaro et al., 2 Sep 2025) treats PSR as a random partition tree under the assumptions that elements are uniform over the universe, partitioning is hash-based and uniform when intended, and the $U$2 differences are independently assigned across children according to a multinomial distribution. If $U$3 denotes the number of recovery calls of PSR given $U$4 differences, then for arbitrary $U$5-ary partition probabilities $U$6,

$U$7

For fair partitioning with $U$8, this simplifies to a recursion depending only on $U$9, $n$0, and $n$1, and a known asymptotic upper bound is

$n$2

(Lázaro et al., 2 Sep 2025).

From this, communication cost in the SR-based model is

$n$3

time is approximately

$n$4

and expected round complexity scales as

$n$5

Under fair partitioning this reduces to $n$6 (Lázaro et al., 2 Sep 2025).

Range-based PSR yields analogous, though differently parameterized, bounds. The number of fingerprint comparisons is bounded by the number of explored nodes in the recursion tree, which is $n$7, and the protocol failure probability due to fingerprint collisions is bounded by $n$8 under independent-collision modeling (Meyer, 2022). Communication is $n$9 bits, and the number of rounds is

$m_A = |S_A|$0

(Meyer, 2022). Local computation per round can be reduced to

$m_A = |S_A|$1

when received ranges are processed in ascending order, by a single left-to-right tree traversal (Meyer, 2022).

A common misconception is that PSR inherently implies one specific sketch family or one exact asymptotic profile. The literature instead presents several PSR instantiations whose costs depend on the local sketch primitive: characteristic-polynomial SRs emphasize bounded local decoding (Lázaro et al., 2 Sep 2025), range fingerprints emphasize ordered composability and cryptographic options (Meyer, 2022), and IBLT variants emphasize near-linear expected decoding with probabilistic failure control (Belazzougui et al., 2024).

4. Enhanced Partitioned Set Reconciliation and tree-algorithm reuse

The principal refinement in (Lázaro et al., 2 Sep 2025) is enhanced partitioned set reconciliation (EPSR), which borrows techniques from tree algorithms for random-access protocols. Its key idea is to reuse the SR of a parent partition so that, after transmitting one child SR, the receiver can subtract that child from the parent and obtain the SR of the union of the remaining children. Consequently, only $m_A = |S_A|$2 children may require transmission, while the last child is obtained "for free" by subtraction (Lázaro et al., 2 Sep 2025).

Architecturally, EPSR differs from PSR in three respects: it maintains the parent SR for reuse, it transmits child SRs only up to an index $m_A = |S_A|$3, and the last child is always skipped for transmission and recursed into with a skip flag (Lázaro et al., 2 Sep 2025). The index $m_A = |S_A|$4 is defined by

$m_A = |S_A|$5

where $m_A = |S_A|$6 is the number of differences in child $m_A = |S_A|$7 (Lázaro et al., 2 Sep 2025).

The analysis distinguishes the number of SR transmissions $m_A = |S_A|$8 from the number of recovery calls $m_A = |S_A|$9. For $m_B = |S_B|$0, both satisfy expectation 1. For larger $m_B = |S_B|$1, the recursions for $m_B = |S_B|$2 and $m_B = |S_B|$3 each combine multinomial occupancy terms with additional correction terms arising from reuse of the parent SR and the sequential child-elimination process (Lázaro et al., 2 Sep 2025). Communication cost is

$m_B = |S_B|$4

and the comparison ratio is

$m_B = |S_B|$5

Under binary fair partitioning, $m_B = |S_B|$6 and $m_B = |S_B|$7, numerical and analytical results show $m_B = |S_B|$8 across a wide range, so EPSR nearly halves the communication cost relative to PSR while preserving other complexities (Lázaro et al., 2 Sep 2025).

EPSR’s round complexity is analyzed by viewing each $m_B = |S_B|$9-ary split as a chain of $D = S_A \oplus S_B,\qquad k = |D|,$0 binary splits. If $D = S_A \oplus S_B,\qquad k = |D|,$1, $D = S_A \oplus S_B,\qquad k = |D|,$2, $D = S_A \oplus S_B,\qquad k = |D|,$3, and $D = S_A \oplus S_B,\qquad k = |D|,$4, then

$D = S_A \oplus S_B,\qquad k = |D|,$5

(Lázaro et al., 2 Sep 2025). Minimizing rounds requires $D = S_A \oplus S_B,\qquad k = |D|,$6 for all $D = S_A \oplus S_B,\qquad k = |D|,$7, achieved by the unequal schedule

$D = S_A \oplus S_B,\qquad k = |D|,$8

under which $D = S_A \oplus S_B,\qquad k = |D|,$9, independent of $A$0 and equal to binary PSR’s round complexity (Lázaro et al., 2 Sep 2025).

This does not imply that EPSR reduces computation proportionally. The paper reports that EPSR’s time is dominated by recovery calls and that, in the recommended binary setup, $A$1; the practical advantage is therefore principally in $A$2 transmissions rather than in recovery-call counts (Lázaro et al., 2 Sep 2025).

5. Variants, sketch primitives, and relation to other reconciliation methods

PSR is not tied to a single sketch primitive. The literature explicitly places it alongside characteristic-polynomial methods, IBLTs, BCH-based reconciliation, probabilistic filters, and set-of-sets encodings.

In (Lázaro et al., 2 Sep 2025), PSR and EPSR use characteristic-polynomial-based summaries locally, leveraging the fact that CPI-like decoding is practical when constrained to partitions whose difference count is at most $A$3. The paper contrasts this with one-shot CPI and PinSketch methods, which have near-optimal communication of approximately $A$4 but high computational cost, specifically CPI time $A$5 and PinSketch time $A$6, and are therefore best when $A$7 is small, on the order of hundreds (Lázaro et al., 2 Sep 2025).

In (Belazzougui et al., 2024), a different PSR line uses IBLTs per partition. That work proposes a hybrid scheme combining an extremely compact and fast IBLT with a BCH-based stash and a small control checksum, yielding exponentially decreasing failure probability while preserving near-linear sketch size and near-linear expected decoding time (Belazzougui et al., 2024). For $A$8 hash functions, the IBLT size per partition is

$A$9

the baseline IBLT failure probability without stash is $B$00, and the hybrid construction achieves end-to-end success probability $B$01 with sketch size

$B$02

and expected decoding time $B$03 (Belazzougui et al., 2024). The paper explicitly states that PSR stripes or buckets the universe into $B$04 independent partitions, builds or merges a sketch per partition, and decodes in parallel, and that this is useful because it reduces variance in decoding time, localizes failures, and enables parallelism (Belazzougui et al., 2024).

A related but structurally broader perspective appears in "Reconciling Graphs and Sets of Sets" (Mitzenmacher et al., 2017), where PSR is treated as a special case of reconciling a parent set of child sets. In this view, partitions or buckets are child sets, and PSR corresponds to the case where labels are often known and consistent so that matching overhead is low (Mitzenmacher et al., 2017). The paper develops naive atomization, IBLTs of IBLTs, cascading IBLTs, and multi-round estimator-assisted protocols for this generalized setting, with communication and time costs parameterized by the number of buckets $B$05, maximum bucket size $B$06, total item differences $B$07, and universe size $B$08 (Mitzenmacher et al., 2017).

Range-based PSR adds a different axis: fingerprint design. It characterizes fingerprints via a monoid $B$09 and a per-item fingerprint $B$10, lifting $B$11 to sets in sorted order so that disjoint adjacent subranges compose homomorphically (Meyer, 2022). The paper surveys additive, multiplicative-group, ECMH, lattice-based, non-commutative, and Merkle-style constructions, and emphasizes that PSR can be instantiated with cryptographically secure fingerprinting schemes rather than only with algebraic reconciliation sketches (Meyer, 2022).

A plausible implication is that PSR should be regarded less as a competitor to a specific one-shot primitive and more as a systems strategy for turning expensive global decoding into many bounded local decoding tasks.

6. Practical behavior, parameter trade-offs, and applications

The practical findings in (Lázaro et al., 2 Sep 2025) center on redundancy, normalized complexity, and wall-clock behavior under simulated network and compute conditions. Redundancy is defined as total bits divided by $B$12, so that

$B$13

and normalized complexity is the expected number of recovery calls divided by $B$14 (Lázaro et al., 2 Sep 2025). Under binary fair partitioning with $B$15, $B$16, and $B$17, redundancy oscillates around approximately 3 for PSR and approximately 1.5 for EPSR, while normalized complexity is essentially identical for the two methods (Lázaro et al., 2 Sep 2025).

The same paper reports event-driven simulations in SimPy under three scenarios with latency 10 ms, element size 32 bytes, $B$18, $B$19, and binary fair partitioning. In a latency-limited scenario with 100 Mbps and recovery 12.3 ms, PSR and EPSR have essentially the same total reconciliation time, and more cores reduce time almost proportionally. In a compute-limited scenario with 100 Mbps and recovery 615 ms, their times remain essentially the same, again with significant gains from more cores. In a bandwidth-limited scenario with 10 kbps and recovery 12.3 ms, EPSR’s total reconciliation time is approximately half of PSR’s because SR transmission time dominates and EPSR halves the number of transmitted SRs (Lázaro et al., 2 Sep 2025).

Parameter trade-offs are explicit. Larger $B$20 lowers communication overhead by reducing splits but increases recovery time as $B$21; $B$22 in $B$23 is recommended as a practical balance (Lázaro et al., 2 Sep 2025). The false success probability is controlled by choosing $B$24 and possibly small $B$25, often $B$26, so that $B$27 (Lázaro et al., 2 Sep 2025). For EPSR, the unequal schedule $B$28 for $B$29 and $B$30 minimizes rounds, but the paper also notes that in practice one can choose $B$31 for simplicity without sacrificing performance because redundancy and normalized complexity become nearly independent of $B$32 under the optimal schedule (Lázaro et al., 2 Sep 2025).

Range-based PSR exposes different knobs: branching factor $B$33, anchor threshold $B$34, fingerprint length $B$35, and the choice between secure monoid fingerprints and Merkle-style range commitments (Meyer, 2022). The paper recommends $B$36 to $B$37, $B$38 or $B$39, and choosing $B$40 from the target collision budget using

$B$41

(Meyer, 2022). It also highlights an implementation improvement: when many ranges are processed in a round, a single ascending traversal of an augmented ordered index reduces local computation by a logarithmic factor relative to naive per-range $B$42 processing (Meyer, 2022).

The application domain stated for EPSR includes low-bandwidth networks and client-server architectures where server-to-client transmissions are the bottleneck, including distributed storage synchronization, P2P or blockchain gossip, and remote file sync (Lázaro et al., 2 Sep 2025). The set-of-sets perspective extends PSR-like methods to graph reconciliation, forests of rooted trees, databases with binary columns, and collections of documents represented by shingles (Mitzenmacher et al., 2017). These are not identical tasks, but they share the same operational principle: exploit structural partitioning so that most work occurs only where differences are concentrated.

Open problems stated in (Lázaro et al., 2 Sep 2025) include tight nonasymptotic bounds for $B$43, $B$44, and $B$45 under arbitrary partition schedules, robustness under adversarial element distributions and adaptive partitioning strategies, and extensions to multi-party reconciliation and server-side bandwidth constraints with many concurrent clients. Related limitations in (Meyer, 2022) concern cryptographically secure homomorphic fingerprints, DoS-resistant unique tree representations for Merkle-style range fingerprints, and the broader challenge of balancing security, composability, and computational cost.

Taken together, these works present PSR as a broad reconciliation paradigm rather than a single protocol. Its common promise is that exact or near-exact set reconciliation can be organized around partitions whose local discrepancy is small, thereby trading monolithic computation for bounded local decoding, parallelism, localized failure handling, and, in the case of EPSR, substantially reduced communication overhead (Lázaro et al., 2 Sep 2025).