--- title: 'Merge: Combining Structured Artifacts in Research' url: https://www.emergentmind.com/topics/merge type: topic --- # Merge: Combining Structured Artifacts in Research Merge denotes the operation of combining multiple structured artifacts into a single artifact while preserving domain-specific invariants such as sorted order, syntactic well-formedness, task performance, or distributed consistency. In contemporary research the term spans three-way reconciliation of source-code revisions, fusion of fine-tuned neural checkpoints, partitioned merging of sorted sequences, and data-structure operations on interleaved ordered sets. It also appears as an acronym for named datasets and systems, notably the bimodal music-emotion dataset MERGE and the vision-language grounding system MERGE for human-robot interaction [2507.19687] [2412.10416] [1406.2628] [1002.4248] [2407.06060] [2603.18988]. ## 1. Formal problem classes The formal object being merged varies substantially across domains. In generic structured source-code merging, a merge scenario is a triple of files $(F_B,F_L,F_R)$ consisting of a common base and two revisions, and LastMerge defines a merge operator by parsing, matching, amalgamating, and pretty-printing: $$ \mathit{merge}(F_B,F_L,F_R) =\pi\bigl(\rho(\tau(F_B),\tau(F_L),\tau(F_R),\mu_{B,L},\mu_{B,R},\mu_{L,R})\bigr). $$ Its parsing stage produces a Concrete Syntax Tree via Tree Sitter; matching computes three pairwise matchings; and amalgamation synthesizes a merged tree by depth-first traversal [2507.19687]. In ordered-set data structures, Mergeable Dictionary defines merge as an abstract data-type operation on disjoint sets of totally ordered data. Given distinct sets $A$ and $B$, the operation $$ C \leftarrow \mathrm{Merge}(A,B) $$ removes $A$ and $B$ and inserts $C=A\cup B$, with no requirement that $\max(A)<\min(B)$ or vice versa. The sets may be arbitrarily interleaved in keyspace, and the data structure supports Predecessor-Search, Split, and Merge in $O(\log n)$ amortized time [1002.4248]. In parallel sequence processing, Merge Path models the serial merge of two sorted arrays as a monotonic path from $(0,0)$ to $(m,n)$ on an $m\times n$ grid. The $k$-th element in the merged output lies on the cross-diagonal $i+j=k$, and diagonal intersections determine balanced, contiguous subproblems for independent processors. This yields a synchronization-free partition of the merge into per-processor submerges, each writing to a disjoint output interval [1406.2628]. These formalizations show that “merge” is not a single algorithmic primitive but a family of constrained composition operators. A plausible implication is that the central research question is usually not whether combination is possible, but which invariants are preserved: syntactic structure, output order, storage complexity, numerical behavior, or convergence under asynchronous communication. ## 2. Neural network model merging as checkpoint composition In neural network research, model merging is the composition of pre-trained or fine-tuned checkpoints without full retraining. A standard formulation considers two source models with weights $W_A,W_B\in\mathbb{R}^d$ and a merged model $$ W(\alpha)=(1-\alpha)W_A+\alpha W_B, $$ with either a scalar or vector-valued fusion coefficient $\alpha$. This formulation is extended to multi-objective optimization by searching for Pareto-optimal trade-offs across validation losses, and the automated framework of “Fine, I’ll Merge It Myself” searches these spaces with SMAC, Hyperband, and ParEGO through layerwise fusion search and depth-wise integration search [2502.04030]. SuperMerge specializes the problem to fine-tuned models derived from a common pre-trained base $\theta_p$. For models $A$ and $B$, it defines task vectors $\Delta_A=\theta_A-\theta_p$ and $\Delta_B=\theta_B-\theta_p$. A naïve task-arithmetic merge uses $$ \theta_{\mathrm{merge}}=\theta_p+\lambda(\Delta_A+\Delta_B), $$ but SuperMerge instead learns per-layer coefficients: $$ \theta_{\mathrm{merge}}(j)=\theta_p(j)+\tanh(w_{A,j})\Delta_A(j)+\tanh(w_{B,j})\Delta_B(j). $$ The trainable scalars are optimized by minimizing validation loss on the union of held-out task sets. The method tunes only $2{,}112$ weights and uses $352$ validation examples in the reported generative NLP setting. On 11 in-domain tasks, SuperMerge reaches $69.6\%$ average accuracy and the hierarchical variant $69.4\%$, compared with $57$–$66\%$ for Task-Arithmetic, DARE, and TIES; on 8 held-out tasks it reports $69.0\%$ and $69.1\%$, compared with $42$–$62\%$ for those baselines [2412.10416]. “Model Merging by Output-Space Projection” replaces heuristic coefficient selection with a convex quadratic programme over residual updates. For a calibration set, the squared-output loss can be written as $$ J(d)=\sum_{j\in\mathcal K}\|A_j d+b_j\|_2^2 =d^\top H d+g^\top d+\mathrm{const}, $$ optionally with box constraints $0\le d\le 1$. In that framework, task arithmetic, model soups, TIES, and DARE are treated as restricted points or subspaces of the same optimization problem, and the paper introduces the fraction of residual energy captured by a chosen basis as a closed-form diagnostic of merge quality [2605.29101]. Empirically, automated search can find effective merges with limited compute. The multi-fidelity framework reports GSM8K improvement of $+4.24\%$ absolute, from $64.22\to68.46$, within less than $500$ trials using only $17\%$ full-budget evaluations; it also reports MBPP improvement of $+1.42\%$ Pass@1 and MMLU improvement of $+1.88\%$ accuracy. This suggests that checkpoint merging has moved from a manually tuned heuristic to an optimization problem over structured search spaces, calibration losses, and resource budgets [2502.04030]. ## 3. Memory, alignment, storage, and distributed constraints in model merging Several recent works treat merge quality as only one objective among multiple deployment constraints. SuperMerge introduces a hierarchical strategy for the case $k\gg 2$, grouping models into pairs or small clusters and repeatedly merging intermediate models. The stated space comparison is $O(k\cdot|\theta|)$ for naïve all-at-once merging versus $O(2\cdot|\theta|)$ peak for hierarchical merging, and the reported peak memory drops from $130.4$ GB to $32.7$ GB with identical accuracy to the flat merge [2412.10416]. CRDTMergeState addresses a different constraint: conflict-free distributed operation. Across 26 tested neural network merge strategies, including weight averaging, SLERP, TIES, DARE, Fisher merging, and evolutionary approaches, the paper states that all fail the algebraic properties of commutativity, associativity, and idempotency required for CRDTs. It proposes a two-layer architecture in which Layer 1 manages contributions through OR-Set semantics and Layer 2 applies a deterministic pure merge function to a canonically ordered contribution set with randomness seeded from the Merkle root. The paper proves Strong Eventual Consistency and reports CRDT overhead below $0.5$ ms, with downstream performance identical by construction and confirmed via byte-identical output verification [2605.19373]. AlignMerge makes alignment an explicit invariant rather than a post hoc evaluation criterion. Around an aligned anchor $\theta_0$, it defines a Fisher-geodesic term $L_{\mathrm{geo}}$, an alignment-subspace penalty $L_{\mathrm{align}}$, and a soft alignment budget $L_{\mathrm{bud}}$, combined as $$ L_{\mathrm{AlignMerge}}(\theta) = L_{\mathrm{geo}} +\lambda_{\mathrm{align}}L_{\mathrm{align}} +\lambda_{\mathrm{bud}}L_{\mathrm{bud}}. $$ The alignment functional is the decoding-invariant Alignment Quality Index, computed from latent-space separation of safe and unsafe behaviors. Across LLaMA-3 8B, Mistral 7B, Qwen 7B, Phi-3.5, and Gemma 2 9B, the paper reports average AQI of $\sim0.75$ for AlignMerge versus $\sim0.72$ for SafeMerge or MergeAlign and $\sim0.65$ for a naive Fisher-weighted merge, while task utility remains within $1\%$ of the best expert on helpfulness [2512.16245]. A further constraint is storage-efficient reusability. MERGE, expanded as Modular Expert Recombination for fine-Grained mErging, decomposes models into functional components and formulates component-wise merging as a Pareto problem over validation performance and storage cost. A surrogate-assisted NSGA-II search builds a reusable Modular Expert Library, and a lightweight routing network assembles input-specific models from modular experts at inference time. Reported results include $G_1$ solutions requiring approximately $30\%$ storage of static or dynamic baselines while outperforming them, and $G_3$ solutions reducing the gap to individual task models to less than $1$–$2\%$ with less than $1.8\times$ storage [2602.06552]. A common misconception is that “model merge” denotes a single flat averaging operator. The recent literature instead treats merge as a design space involving calibration, memory, distributed convergence, safety geometry, routing, and storage. ## 4. Program and version-control merging In software engineering, merge traditionally refers to the reconciliation of divergent revisions in version control. Line-based tools such as diff3 are language-agnostic and fast, but they report spurious conflicts when non-interfering edits occur on the same line and may miss semantic conflicts that do not overlap textually. Structured merge tools operate on ASTs or CSTs and use syntax-aware matching and amalgamation to avoid false positives and detect conflicts overlooked by text-based methods [2507.19687]. Spork is a structured merge tool for Java with formatting preservation. It performs a full three-way AST merge, preserves original source text for fragments stemming strictly from one revision, and falls back to lower-fidelity printing only for mixed fragments. On $1{,}740$ real-world Java file merges from $119$ open-source projects, Spork cuts the number of merge conflict hunks by $40\%$ relative to JDime, reduces conflicting lines by $63\%$ compared to AutoMergePTM, runs in a median of $1.17$ s per file merge, and never exceeds $12$ s, whereas the comparators sometimes time out at $300$ s [2202.05329]. LastMerge generalizes structured merge through a thin interface based on Tree Sitter grammars, declarative unordered-node sets, identifier extraction queries, and optional parsing handlers. On $5{,}229$ Java merge scenarios comprising $13{,}675$ mutually changed files from $1{,}116$ open-source projects, it shows no evidence that generic structured merge significantly impacts merge accuracy. The paper reports that LastMerge has $130$ added false positives versus $153$ for jDime, or $15\%$ fewer false positives, while Mergiraf misses $42\%$ fewer false negatives than Spork [2507.19687]. Learned program-merge systems replace or supplement symbolic merge logic. DeepMerge learns to resolve JavaScript conflicts by constructing resolutions from input segments using an edit-aware embedding and a pointer-network-style decoder. Its curated dataset contains $8{,}719$ non-trivial resolutions, and it reports $36.5\%$ top-1 exact-match accuracy on the full held-out test set and $78.4\%$ on merges where the two variants together comprise at most 3 lines [2105.07569]. Merge-Bench extends learning-based merge resolution to large language models and reinforcement learning. The dataset contains $7{,}938$ real-world merge conflict hunks from $1{,}439$ GitHub repositories across 11 programming languages, with developer-committed resolutions as ground truth and no manual labeling. LLMergeJ, trained with Group Relative Policy Optimization on Java data, achieves $48.8\%$ exact textual match and $58.9\%$ code-normalized match on the $806$-hunk Java test set, outperforming three commercial LLMs and trailing only Gemini 2.5 Pro. The paper also states that the best models correctly resolve less than $60\%$ of merge conflicts, indicating that real-world merge resolution remains challenging [2605.25890]. ## 5. Merge as a core algorithmic primitive in sorting and ordered sets In sorting, merge is a costed primitive over adjacent monotone runs. “Strategies for Stable Merge Sorting” models the merge of two adjacent runs $A$ and $B$ with cost $|A|+|B|$, and studies upper and lower bounds of the form $c\,n\log m$ and $c\,n\log n$. It introduces 2-merge sort and $\alpha$-merge sort as 3-aware natural merge-sort policies operating on a stack of runs. For 2-merge sort, the paper proves matching upper and lower bounds with leading constant $$ c_2=\frac{3}{\log(27/4)}\approx1.089, $$ while Timsort has a lower bound of $(1.5-o(1))\,n\log n$ [1801.04641]. The same work argues that 2-merge and $\alpha$-merge are conceptually simpler than Timsort, require only 3-aware tests, and perform better in experiments. On synthetic run-length distributions, powersort has the best normalized merge cost, while $\alpha$-merge with $\alpha\approx1.62$ slightly outperforms Timsort and 2-merge and exhibits less oscillation than adaptive Shivers [1801.04641]. Merge Path addresses parallel merging of two sorted arrays. It defines the diagonal intersection conditions for a split point $(i,j)$ on diagonal $d$ by $$ i+j=d,\qquad A[i-1]\le B[j],\qquad B[j-1]