Merge: Combining Structured Artifacts in Research

• Merge is the operation of combining multiple structured artifacts while preserving domain-specific invariants like order, syntax, or consistency.
• It spans diverse applications including source-code version reconciliation, neural checkpoint fusion with optimized calibration, and parallel merging in sorting.
• Advanced merge strategies incorporate hierarchical, CRDT-based, and multi-modal methods to enhance performance, memory efficiency, and conflict resolution.

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 (Duarte et al., 25 Jul 2025, Yang et al., 2024, Green et al., 2014, Iacono et al., 2010, Louro et al., 2024, Deigmoeller et al., 19 Mar 2026).

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 (Duarte et al., 25 Jul 2025).

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 (Iacono et al., 2010).

In parallel sequence processing, Merge Path models the serial merge of two sorted arrays as a monotonic path from $$\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).$$0 to $$\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).$$1 on an $$\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).$$2 grid. The $$\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).$$3-th element in the merged output lies on the cross-diagonal $$\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).$$4, 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 (Green et al., 2014).

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 $$\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).$$5 and a merged model

$$\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).$$6

with either a scalar or vector-valued fusion coefficient $$\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).$$7. 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 (Su et al., 6 Feb 2025).

SuperMerge specializes the problem to fine-tuned models derived from a common pre-trained base $$\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).$$8. For models $$\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).$$9 and $A$0, it defines task vectors $A$1 and $A$2. A naïve task-arithmetic merge uses

$A$3

but SuperMerge instead learns per-layer coefficients:

$A$4

The trainable scalars are optimized by minimizing validation loss on the union of held-out task sets. The method tunes only $A$5 weights and uses $A$6 validation examples in the reported generative NLP setting. On 11 in-domain tasks, SuperMerge reaches $A$7 average accuracy and the hierarchical variant $A$8, compared with $A$9–$B$0 for Task-Arithmetic, DARE, and TIES; on 8 held-out tasks it reports $B$1 and $B$2, compared with $B$3–$B$4 for those baselines (Yang et al., 2024).

“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

$B$5

optionally with box constraints $B$6. 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 (Evans et al., 27 May 2026).

Empirically, automated search can find effective merges with limited compute. The multi-fidelity framework reports GSM8K improvement of $B$7 absolute, from $B$8, within less than $B$9 trials using only $C \leftarrow \mathrm{Merge}(A,B)$0 full-budget evaluations; it also reports MBPP improvement of $C \leftarrow \mathrm{Merge}(A,B)$1 Pass@1 and MMLU improvement of $C \leftarrow \mathrm{Merge}(A,B)$2 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 (Su et al., 6 Feb 2025).

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 $C \leftarrow \mathrm{Merge}(A,B)$3, grouping models into pairs or small clusters and repeatedly merging intermediate models. The stated space comparison is $C \leftarrow \mathrm{Merge}(A,B)$4 for naïve all-at-once merging versus $C \leftarrow \mathrm{Merge}(A,B)$5 peak for hierarchical merging, and the reported peak memory drops from $C \leftarrow \mathrm{Merge}(A,B)$6 GB to $C \leftarrow \mathrm{Merge}(A,B)$7 GB with identical accuracy to the flat merge (Yang et al., 2024).

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 $C \leftarrow \mathrm{Merge}(A,B)$8 ms, with downstream performance identical by construction and confirmed via byte-identical output verification (Gillespie, 16 May 2026).

AlignMerge makes alignment an explicit invariant rather than a post hoc evaluation criterion. Around an aligned anchor $C \leftarrow \mathrm{Merge}(A,B)$9, it defines a Fisher-geodesic term $A$0, an alignment-subspace penalty $A$1, and a soft alignment budget $A$2, combined as

$A$3

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 $A$4 for AlignMerge versus $A$5 for SafeMerge or MergeAlign and $A$6 for a naive Fisher-weighted merge, while task utility remains within $A$7 of the best expert on helpfulness (Roy et al., 18 Dec 2025).

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 $A$8 solutions requiring approximately $A$9 storage of static or dynamic baselines while outperforming them, and $B$0 solutions reducing the gap to individual task models to less than $B$1–$B$2 with less than $B$3 storage (Qiu et al., 6 Feb 2026).

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 (Duarte et al., 25 Jul 2025).

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 $B$4 real-world Java file merges from $B$5 open-source projects, Spork cuts the number of merge conflict hunks by $B$6 relative to JDime, reduces conflicting lines by $B$7 compared to AutoMergePTM, runs in a median of $B$8 s per file merge, and never exceeds $B$9 s, whereas the comparators sometimes time out at $C=A\cup B$0 s (Larsén et al., 2022).

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 $C=A\cup B$1 Java merge scenarios comprising $C=A\cup B$2 mutually changed files from $C=A\cup B$3 open-source projects, it shows no evidence that generic structured merge significantly impacts merge accuracy. The paper reports that LastMerge has $C=A\cup B$4 added false positives versus $C=A\cup B$5 for jDime, or $C=A\cup B$6 fewer false positives, while Mergiraf misses $C=A\cup B$7 fewer false negatives than Spork (Duarte et al., 25 Jul 2025).

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 $C=A\cup B$8 non-trivial resolutions, and it reports $C=A\cup B$9 top-1 exact-match accuracy on the full held-out test set and $\max(A)<\min(B)$0 on merges where the two variants together comprise at most 3 lines (Dinella et al., 2021).

Merge-Bench extends learning-based merge resolution to LLMs and reinforcement learning. The dataset contains $\max(A)<\min(B)$1 real-world merge conflict hunks from $\max(A)<\min(B)$2 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 $\max(A)<\min(B)$3 exact textual match and $\max(A)<\min(B)$4 code-normalized match on the $\max(A)<\min(B)$5-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 $\max(A)<\min(B)$6 of merge conflicts, indicating that real-world merge resolution remains challenging (Schesch et al., 25 May 2026).

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 $\max(A)<\min(B)$7 and $\max(A)<\min(B)$8 with cost $\max(A)<\min(B)$9, and studies upper and lower bounds of the form $O(\log n)$0 and $O(\log n)$1. It introduces 2-merge sort and $O(\log n)$2-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

$O(\log n)$3

while Timsort has a lower bound of $O(\log n)$4 (Buss et al., 2018).

The same work argues that 2-merge and $O(\log n)$5-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 $O(\log n)$6-merge with $O(\log n)$7 slightly outperforms Timsort and 2-merge and exhibits less oscillation than adaptive Shivers (Buss et al., 2018).

Merge Path addresses parallel merging of two sorted arrays. It defines the diagonal intersection conditions for a split point $O(\log n)$8 on diagonal $O(\log n)$9 by

$$\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).$$00

A binary search along the diagonal finds the unique crossing in $$\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).$$01, after which each processor merges contiguous subranges of $$\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).$$02 and $$\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).$$03 into a contiguous output segment. The reported per-processor complexity is $$\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).$$04, with work $$\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).$$05 and no inter-thread synchronization beyond boundary determination (Green et al., 2014).

Mergeable Dictionary shows that merge need not be restricted to disjoint key intervals. By storing each set in an extended biased skip list and using finger split, finger join, and reweight operations, it supports arbitrary interleaved Merge together with Split and Predecessor-Search in $$\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).$$06 amortized time. This improves on prior structures that required $$\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).$$07 amortized time when Split was allowed, or degraded to $$\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).$$08 under certain restrictions (Iacono et al., 2010).

These algorithmic literatures treat merge not as a secondary implementation detail but as the central cost object. A plausible implication is that, in classical algorithms, the main questions are optimal partitioning and amortized complexity, whereas in modern ML and software engineering the main questions are preservation of behavior, semantics, and deployment constraints.

6. MERGE as a named dataset or system

MERGE is also used as a title or acronym for domain-specific artifacts. In music information retrieval, “MERGE — A Bimodal Audio-Lyrics Dataset for Static Music Emotion Recognition” introduces three new audio, lyrics, and bimodal MER datasets constructed through a semi-automatic pipeline. The data are organized by Russell’s four valence–arousal quadrants, with balanced subsets of $$\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).$$09 audio tracks, $$\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).$$10 lyrics samples, and $$\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).$$11 bimodal examples. The abstract reports a best overall result of $$\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).$$12 F1-score for bimodal classification, while the detailed baseline summary reports $$\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).$$13 F1 for late-fusion deep learning on the $$\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).$$14–$$\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).$$15–$$\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).$$16 split (Louro et al., 2024).

In human-robot interaction, MERGE denotes “Guided Vision-LLMs for Multi-Actor Event Reasoning and Grounding in Human-Robot Interaction.” The system combines a lightweight streaming perception module, persistent memory for actors and objects, and selective VLM invocation triggered by action changes. Events are represented as tuples $$\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).$$17 over actor, action, object, spatial relation, timestamp, and robot participation. On the GROUND benchmark, MERGE improves the average grounding score by a factor of 2 compared to VLM-only baselines, including GPT-4o, GPT-5, and Gemini 2.5 Flash, while reducing run-time by a factor of 4 (Deigmoeller et al., 19 Mar 2026).

The recurrence of “MERGE” as an acronym across unrelated subfields is terminological rather than methodological. Nevertheless, these works retain the core semantic intuition of the word: integrating complementary information sources into a single representation, whether the sources are audio and lyrics, tracked actors and objects, model checkpoints, or divergent program revisions.