RCP-Merging: Techniques in Distributed Systems

• RCP-Merging is a framework encompassing diverse algorithms for merging independently evolved data, models, or system states in distributed environments.
• It employs layered merging strategies in collaborative systems, certified MRDTs, distributed convex optimization, consensus protocols, and LLM integration to guarantee convergence and constraint preservation.
• Empirical results demonstrate significant gains in latency, convergence speed, and output quality across applications such as document systems and domain-specific model merging.

RCP-Merging encompasses a spectrum of techniques and theoretical designs for merging independently evolved data, models, or system states in distributed and collaborative environments. The acronym "RCP" is context-dependent: in distributed optimization it denotes "Random Convex Program"; in LLM merging, it abbreviates "Reasoning Capability as Prior"; in replicated data types and consensus protocols, it refers to controlled or certified merging primitives. This article surveys RCP-Merging across its core application domains: collaborative document systems, formal verification of replicated data types, distributed optimization, consensus protocols, and LLM merging.

1. Formal Foundations of RCP-Merging in Collaborative Systems

In replicated collaborative document systems, RCP-Merging is a principled design for merging concurrent changes while ensuring eventual consistency and semantic correctness. Documents are modeled as compositions of state-based CRDTs (Conflict-free Replicated Data Types) with one or more functional "adaptation layers" atop the base replication substrate (Martin et al., 2012).

The architecture partitions responsibilities:

• Replication Layer: Ensures eventual consistency using commutative/associative/idempotent merge operations. For example, an "add-wins" set CRDT uses per-element timestamps to resolve add/remove conflicts on union.
• Adaptation Layers: Deterministic functions implementing structural, ordering, and domain-specific policy. These include:
  • Structural (connecting) layers: repair tree/path encodings, handle orphans via connection policies (skip, reappear, root, compact).
  • Ordering layers: maintain sibling ordering via position identifiers generated with dense orderings (e.g., Logoot).
  • Schema-repair layers: enforce syntactic/semantic document constraints (e.g., UNIQUENESS, acyclicity) by tree-transform or repair on lookup.

The core invariant is that adaptation layers are deterministic/pure and stateless (beyond locally-computable incremental buffers), so eventual consistency is a direct corollary of bottom-layer CRDT convergence. Constraint-preserving merges are implemented as sequential post-processes atop the commutative merge operation, and the merge algorithm composes these into a cascaded function pipeline.

Performance analysis demonstrates local-update latency (10–30 μs for layered-CRDTs), memory overhead well under 50 ms/operation, and tunable space complexity depending on identifier and metadata schemes.

2. Certified Merging of Replicated Data Types

The Peepul framework formalizes RCP-Merging as “three-way merge” for Mergeable Replicated Data Types (MRDTs), defining a certified, verifiable methodology for convergence and specification refinement (Soundarapandian et al., 2022). Each MRDT supports:

$$\mathsf{merge} : \Sigma \times \Sigma \times \Sigma \rightarrow \Sigma$$

where the arguments are (lowest common ancestor, left branch, right branch) and the result is the merged state incorporating all visible updates and resolving conflicts according to data-type policy.

Correctness is specified by three key properties:

• Commutativity and Idempotence: $$\mathsf{merge}(\sigma_{\mathrm{lca}}, \sigma_a, \sigma_b) = \mathsf{merge}(\sigma_{\mathrm{lca}}, \sigma_b, \sigma_a)$$ and $\mathsf{merge}(\sigma, \sigma, \sigma) = \sigma$.
• Store-wide Invariants: Timestamp consistency and LCA consistency, ensuring event visibility and absence of timestamp duplication.
• Replication-Aware Simulation: An explicit simulation relation $R_\mathrm{sim}$ is required to relate the abstract specification to the concrete implementation, with proof obligations discharged automatically in F* using SMT solvers.

This methodology enables automatic extraction of high-performance, verified OCaml code for MRDTs, directly applicable to systems such as Irmin, and yields merge operations with strict theoretical guarantees on convergence and correctness.

3. RCP-Merging for Distributed Convex Optimization

In distributed optimization, particularly for random convex programs (RCPs), RCP-Merging designates a class of distributed algorithms for aggregating constraints and solutions across a network of nodes (Carlone et al., 2012).

Key variants include:

• Active Constraints Consensus (ACC): Each node repeatedly solves its local subproblem, transmits only active/tight constraints at its current solution, and updates its working set from neighbors. ACC guarantees finite-time convergence to the centralized RCP solution, with per-iteration communication bounded by O($d$).
• Vertex Constraints Consensus (VCC): For scenario constraints jointly convex in the uncertain parameters, nodes communicate only convex hull vertices of the constraint set, yielding convergence in at most $\operatorname{diam}(G)$ rounds.
• Quantized VCC (qVCC): Restricts the per-iteration transmission to $m$ constraint indices, enabling operation under bandwidth constraints with a predictable slow-down.

These algorithms have been empirically shown to achieve significant performance gains (up to two orders of magnitude in wall-clock time for large-scale RCPs) compared to centralized approaches, with applications in estimation, classification, and sample-based model predictive control.

4. RCP-Merging in Consensus Protocols and Cluster Reconfiguration

RCP-Merging, in the context of distributed consensus protocols, refers to the merge transaction mechanism in multi-cluster Raft as implemented in the ReCraft system (Xiong et al., 21 Apr 2025). The merge protocol addresses correctness, liveness, and efficiency for merging independently running Raft clusters:

• Two-Phase Commit (2PC): Merging clusters reach agreement via a cluster-level 2PC for both prepare and commit, with explicit quorum overlap and epoch-term isolation.
• Log Isolation and Epochs: Extended term encoding prevents log entry confusion across configurations, enforcing strict state-machine safety.
• Snapshot-Based Data Exchange: After commit, all participating nodes install a union state via snapshot merging, followed by truncation of previous logs and resuming standard Raft operation.

This approach achieves minimal service blocking, eliminates the central coordinator, and preserves safety despite concurrent reconfigurations or cluster failures. Experimental results demonstrate up to 20× better merge latency compared to coordinator-based methods.

5. RCP-Merging for LLM Weight Integration

In LLMs, RCP-Merging refers to a principled framework for integrating a reasoning-capable model (with strong multi-step chain-of-thought capabilities) with a domain-specific model, such that the resulting merged model achieves dual competence without catastrophic degradation of either competence (Yang et al., 5 Aug 2025).

The method consists of:

• Reasoning Capability Indicator: A Fisher Information–based penalty is computed for each parameter, signaling the risk of impairing reasoning ability by overwriting with domain-specialized weights.
• Domain Sensitivity Score: Computed from first-order Taylor expansion of the domain loss, indicating which weights are critical for domain task performance.
• Conflict Score and Masking: The combined per-weight score $C^t_{i,k} = S^t_{i,k} + \lambda_r p^i_{r,t}$ is thresholded by majority vote to form a binary mask selecting which weights to merge.

The merged parameter vector is given by:

$$\theta_\mathrm{merged} = \theta_\mathrm{pre} + \delta_r + \lambda_t \delta_t^\mathrm{filt}$$

where $\delta_t^\mathrm{filt}$ is the task vector filtered according to the mask. Experimental results on Qwen2.5-7B, Llama3.1-8B in BioMedicine and Finance domains demonstrate 9.5% and 9.2% gains over prior methods with no significant loss of reasoning performance and improved output quality (as measured by low “gibberish rate”).

The method is derived from a Maximum-A-Posteriori optimization with a reasoning prior and is not reliant on further fine-tuning, offering substantial computational savings.

6. Comparative Summary and Application Domains

Domain/Context	Model Object	Merge Mechanism	Key Properties
Collaborative systems	Document/CRDT + Adaptation	Commutative + layers	Eventual consistency + constraint enforcement (Martin et al., 2012)
Certified MRDTs	Replicated data structures	Three-way merge	Verified commutativity, invariants (Soundarapandian et al., 2022)
Distributed optimization	CVX program variables	Constraints exchange	Finite-time global optima, minimal comm (Carlone et al., 2012)
Consensus/sharding	Raft cluster logs/states	2PC + snapshot merge	State machine safety, minimal blocking (Xiong et al., 21 Apr 2025)
LLM integration	Model parameter vector	Weighted selective	Reasoning preservation, domain adaptation (Yang et al., 5 Aug 2025)

RCP-Merging unifies a family of merging protocols and algorithms, each tailored to ensure both consistency (eventual or strong) and respect for domain-specific or reasoning-critical invariants, via explicit control at each layer of the architecture or merge step. Across domains, the commonality is the principled separation of convergence from policy/constraint layers, yielding robust, scalable, and extensible merge mechanisms with strong theoretical and empirical validation.