Enhanced Partitioned Set Reconciliation

• The paper demonstrates that EPSR nearly halves the number of SR transmissions compared to PSR while preserving the same linear time and round complexity.
• EPSR refines classic partitioned set reconciliation by reusing parent summaries through successive interference cancellation, significantly reducing bandwidth usage.
• The method maintains the standard number of recovery calls and computational complexity, making it especially beneficial in low-throughput network scenarios.

Searching arXiv for EPSR and closely related set-reconciliation work to ground the article with current references. Enhanced Partitioned Set Reconciliation (EPSR) is an interactive set reconciliation protocol that refines classic Partitioned Set Reconciliation (PSR) by importing ideas from tree algorithms with successive interference cancellation (SIC) in random-access protocols. In the formal setting, two nodes $A$ and $B$ hold sets $S_A$ and $S_B$ of $\ell$-bit elements from a finite universe $\mathcal U$, with symmetric difference $D = S_A \ominus S_B$ and cardinality $\delta = |D|$. The goal is for node $A$ to learn $D$ while minimizing $B$0 communication. EPSR preserves PSR’s linear time and communication-round complexity while reducing communication overhead; the defining paper states that it “nearly halves the communication cost of PSR while maintaining the same time complexity” (Lázaro et al., 2 Sep 2025).

1. Origins in partitioned set reconciliation

Partitioned Set Reconciliation is a divide-and-conquer strategy in which the sets to be reconciled are successively partitioned until they contain a number of differences below some predetermined value. In the formulation used for EPSR, node $B$1 is the transmitter and $B$2 is the receiver; a round consists of one or more short requests from $B$3 and the requested data structures from $B$4. Performance is measured by communication complexity in bits, counting only $B$5 traffic, by time complexity in terms of expensive recovery calls, and by the number of communication rounds (Lázaro et al., 2 Sep 2025).

The underlying probabilistic model assumes that the elements of $B$6 and $B$7 are chosen uniformly at random from $B$8. When a partition $B$9 is split into $S_A$0 disjoint subsets $S_A$1, the number of differences in the child partitions is multinomial with parameters $S_A$2, where $S_A$3. This analysis makes explicit that PSR and EPSR are tree processes: each node of the recursion tree corresponds to a partition, and the total work depends on how differences distribute across descendants (Lázaro et al., 2 Sep 2025).

Within this lineage, EPSR is best understood as a communication-efficient refinement of PSR rather than a replacement of its recursion model. It preserves the same partition tree semantics and the same stopping threshold $S_A$4, but changes how summaries are transmitted and reused. A plausible implication is that EPSR is not primarily a new partition policy; it is a new reuse rule for summaries already produced during recursive descent.

2. SR data structure and the PSR baseline

Both PSR and EPSR are built on a generic set representation data structure $S_A$5 that supports initialization, insertion of elements and sets, subtraction of two summaries, and a recovery routine

$S_A$6

The paper instantiates $S_A$7 via Characteristic Polynomial Interpolation (CPI), parameterized by a capacity $S_A$8 and a parameter $S_A$9 controlling false success probability. Recovery always succeeds if $S_B$0, and if $S_B$1 it may fail or produce a false success. The false success probability for a represented set of size $S_B$2 is

$S_B$3

with $S_B$4 typically $S_B$5 or $S_B$6, under $S_B$7 (Lázaro et al., 2 Sep 2025).

The transmitted size of one SR summary is

$S_B$8

Its operation costs are asymmetric: init, insert_el, and subtract are $S_B$9, whereas recovery is

$\ell$0

For moderate or large $\ell$1, protocol time is therefore dominated by the number of recovery calls (Lázaro et al., 2 Sep 2025).

PSR applies this primitive recursively. For a partition $\ell$2, node $\ell$3 summarizes $\ell$4, requests the corresponding summary of $\ell$5, subtracts them, and invokes recovery. If recovery succeeds, the differences in that partition are resolved. If it fails, $\ell$6 is split into $\ell$7 child partitions and PSR recurses on each. Every PSR call therefore incurs exactly one SR transmission from $\ell$8 and one recovery call at $\ell$9 (Lázaro et al., 2 Sep 2025).

This structure gives PSR linear expected communication and time in $\mathcal U$0 for fixed $\mathcal U$1, but it is communication-suboptimal. The paper states that even with optimal CPI, PSR’s communication cost is “at best, roughly three times greater” than CPI’s one-shot optimal solution, because PSR sends an SR for each partition, including many partitions where recovery fails and further splitting is required (Lázaro et al., 2 Sep 2025).

3. EPSR algorithm and the SIC mechanism

EPSR’s central observation is that when a partition $\mathcal U$2 is split into children $\mathcal U$3, the parent SR already summarizes all differences in $\mathcal U$4. Once one child’s difference summary is known, it can be subtracted from the parent to derive a summary of the remaining children without requesting another SR over the network. The protocol therefore reuses parent summaries through subtraction, analogously to successive interference cancellation in tree random-access algorithms (Lázaro et al., 2 Sep 2025).

At the top level, $\mathcal U$5 builds $\mathcal U$6 for $\mathcal U$7, requests $\mathcal U$8 for $\mathcal U$9, computes

$D = S_A \ominus S_B$0

and invokes the recursive routine $D = S_A \ominus S_B$1. The recursive routine takes an already constructed SR $D = S_A \ominus S_B$2 for the current partition and a skip flag. If skip=false, it first attempts recovery on $D = S_A \ominus S_B$3. If recovery succeeds, it returns. Otherwise, the partition is split into $D = S_A \ominus S_B$4 children (Lázaro et al., 2 Sep 2025).

For child indices $D = S_A \ominus S_B$5, EPSR explicitly requests the child summary $D = S_A \ominus S_B$6, computes

$D = S_A \ominus S_B$7

and recursively processes $D = S_A \ominus S_B$8. After obtaining $D = S_A \ominus S_B$9, it updates the parent summary by

$\delta = |D|$0

so that $\delta = |D|$1 now summarizes the remaining child partitions. It then immediately attempts recovery on this updated $\delta = |D|$2. If that recovery succeeds, the remaining differences are decoded from the cleaned parent SR, and recursion stops without ever requesting the final child summary from $\delta = |D|$3. If the loop finishes without success, the residual $\delta = |D|$4 corresponds exactly to the last child $\delta = |D|$5, and EPSR recurses on that child with skip=true, thereby avoiding both an additional SR request and an additional initial recovery attempt (Lázaro et al., 2 Sep 2025).

The practical effect is precise: for each internal partition split, EPSR requests only $\delta = |D|$6 child SRs, while the remaining child is represented by the updated parent SR. The paper’s binary example with $\delta = |D|$7 and $\delta = |D|$8 shows that PSR uses 11 SR transmissions and 11 recovery calls on the same tree, whereas EPSR uses only 6 SR transmissions but still 11 recovery calls. This is the core invariance of EPSR: fewer transmissions, same recovery count, same tree structure (Lázaro et al., 2 Sep 2025).

4. Tree-algorithm interpretation and analytical guarantees

EPSR is explicitly connected to tree algorithms for random-access channels with SIC. In that analogy, users correspond to individual differences, a collision signal corresponds to an SR summary $\delta = |D|$9, decoding a subset corresponds to recovering one child partition, and subtracting interference corresponds to subtract(Z,Z_i). This viewpoint is not merely mnemonic; the recursive equations for communication and recovery counts are analyzed with the same probability-generating-function and and-or-tree methods used for $A$0-ary tree random-access algorithms (Lázaro et al., 2 Sep 2025).

Let $A$1 denote the number of SR data structures transmitted by EPSR when there are $A$2 differences. For $A$3,

$A$4

For $A$5, the expected number of transmissions satisfies

$A$6

where $A$7. The first term parallels PSR’s recursion, while the second subtracts transmissions that are skipped because they are derived from the parent SR by subtraction rather than transmitted over the network (Lázaro et al., 2 Sep 2025).

Let $A$8 be the number of recovery calls. Again $A$9 for $D$0, and for $D$1,

$D$2

Each recovery has cost $D$3, so EPSR’s computational complexity remains $D$4 (Lázaro et al., 2 Sep 2025).

For round complexity, the analysis maps a $D$5-ary EPSR split into a chain of binary splits with conditional probabilities

$D$6

and

$D$7

The expected number of communication rounds is

$D$8

A distinguished schedule,

$D$9

yields $B$00, hence $B$01, and therefore

$B$02

independent of $B$03 (Lázaro et al., 2 Sep 2025).

5. Redundancy, parameter choices, and simulated performance

EPSR’s communication is evaluated through redundancy, defined as communication normalized by the information-theoretic baseline $B$04. For PSR,

$B$05

and for EPSR,

$B$06

Normalized complexity is defined as the expected number of recovery calls per $B$07 differences; its ideal value is 1, meaning each recovery retrieves exactly $B$08 differences (Lázaro et al., 2 Sep 2025).

For binary, fair partitioning with $B$09, $B$10, and parameters $B$11, $B$12, $B$13, the paper reports that $B$14 oscillates around $B$15, while $B$16 oscillates around $B$17. The normalized complexity curves for PSR and EPSR are essentially identical, confirming the central claim that EPSR removes roughly half the communication overhead of PSR without increasing computational overhead (Lázaro et al., 2 Sep 2025).

The recommended partition probability schedule is the geometric rule above. Figure-based evidence in the paper shows that redundancy and normalized complexity are essentially identical for $B$18 under that schedule, so the authors use binary partitioning in most numerical comparisons. For the recovery threshold $B$19, increasing $B$20 reduces mean redundancy but increases computational cost because recovery scales as $B$21. The suggested practical compromise is a moderate $B$22, such as 25 or 50 (Lázaro et al., 2 Sep 2025).

The paper also validates its recursions by Monte Carlo simulation. For a nonuniform 5-ary partitioning with $B$23, $B$24, and $B$25, $B$26, $B$27, $B$28, $B$29, 10,000 independent random partitions per $B$30 produce excellent agreement between analytical and simulated curves for PSR and EPSR transmission and recovery counts (Lázaro et al., 2 Sep 2025).

6. Practical significance and relations to adjacent reconciliation schemes

At the network level, EPSR is most advantageous when bandwidth, rather than latency or local computation, is the bottleneck. In a discrete-event simulator with one-way latency 10 ms, finite $B$31 throughput, precomputed SR structures at $B$32, and a recovery runtime corresponding to $B$33, the paper reports three regimes. In high-throughput, high-CPU and high-throughput, low-CPU scenarios, PSR and EPSR have essentially identical reconciliation time because they share the same round complexity and the same number of recoveries. In a low-throughput scenario, EPSR is clearly faster: PSR’s reconciliation time is nearly double that of EPSR for fixed core count, because SR transmission dominates and EPSR halves the number of SR transmissions (Lázaro et al., 2 Sep 2025).

This places EPSR within a broader design space of partitioned and near-partitioned reconciliation methods. Range-based reconciliation recursively partitions an ordered universe into ranges, compares fingerprints, and descends only on disagreeing ranges; its communication is $B$34 bits with $B$35 ideal-message rounds, and it provides an algebraic fingerprinting framework that is structurally close to partition-based recursion (Meyer, 2022). Set-of-sets reconciliation generalizes the partition concept further, treating each child set as a partition and reconciling parent sets of child sketches; one-round cascading IBLT constructions achieve

$B$36

bits for that hierarchical setting (Mitzenmacher et al., 2017).

Other work uses the EPSR label more loosely or only by analogy. The rateless IBLT paper explicitly states that “Enhanced Partitioned Set Reconciliation” is not defined there, but argues that Rateless IBLT supplies useful building blocks for a partitioned architecture through universality, linearity, and incremental decoding without per-partition parameter tuning (Yang et al., 2024). A different line of work describes a hybrid IBLT-plus-stash construction as an “Enhanced Partitioned Set Reconciliation” framework in a conceptual sense, where the symmetric difference is partitioned into a fast probabilistic layer and a small exact residual layer, yielding failure probability $B$37 with expected decoding time $B$38 (Belazzougui et al., 2024). Earlier adaptive reconciliation without prior knowledge of difference size also appears in CS-IBLT, where compressed sensing is used to recover a sparse IBLT difference with communication on the order of

$B$39

measurements, suggesting another route to partition-adaptive behavior (Kung et al., 2012).

These adjacent results do not redefine EPSR as formalized in the tree-algorithm paper. They instead suggest that EPSR belongs to a larger family of reconciliation methods that trade one-shot optimality for recursive structure, summary reuse, or adaptivity. The formal contribution of EPSR itself is narrower and sharper: it is a SIC-enhanced PSR that keeps the same recursion tree and the same order of time and round complexity, while substantially reducing communication by reusing parent SR summaries rather than retransmitting redundant child summaries (Lázaro et al., 2 Sep 2025).