Conflict-Free Replicated Data Type (CRDT)

The foundational guarantee of all CRDTs. When replicas have received the same set of updates—regardless of delivery order—they converge to the same state. Unlike Operational Transformation (OT) , which requires a central server to serialize operations, CRDTs allow peers to exchange raw edits directly. This eliminates the single bottleneck and point of failure, making the system resilient to network partitions.

• Convergence: All replicas that have seen the same updates are identical.
• Commutativity: Operations can be applied in any order and yield the same result.
• No Consensus Required: Peers do not need to coordinate or vote on the final state.

Convergent Replicated Data Types propagate their entire local state to other replicas. A receiving replica merges this remote state with its own using a monotonic join function that is associative, commutative, and idempotent. This design is bandwidth-intensive but simple to reason about.

• Gossip Protocol Friendly: States can be spread epidemically without reliable broadcast.
• Immutable State: Old states are never mutated; new states are computed via merge.
• Example: A G-Counter (Grow-only Counter) where the value is a map of replica IDs to local counts; the merge takes the element-wise maximum.

Commutative Replicated Data Types propagate only the operation that was performed, not the full state. The sender must use a reliable broadcast channel to ensure every operation is delivered exactly once to all replicas. This is far more network-efficient than state-based designs.

• Thin Messages: Only the delta of change is transmitted.
• Causal Broadcast Requirement: Operations must be delivered in causal order or be designed to commute out of order.
• Example: An Add-Wins Set where adding an element and removing an element are distinct operations tagged with unique timestamps to resolve concurrent add/remove conflicts deterministically.

CRDTs rely on the mathematical property of monotonicity. A join-semilattice ensures that the merge of two states always moves 'upward' in a partial order. Once an effect is applied, it can never be undone by a merge; information is only ever added.

• Inflationary Merge: The result of a merge is always greater than or equal to both inputs.
• No Rollback: Deletes are often modeled as 'tombstones' (added information) rather than true erasures.
• Proof of Convergence: The system's eventual consistency is formally provable using order theory, not just empirically observed.

CRDTs do not 'detect' conflicts; they are designed so that conflicts cannot logically occur. The data type's internal logic pre-determines the outcome of any concurrent edit. For a collaborative text editor, this means no user ever sees a 'merge conflict' marker.

• LWW-Register (Last-Writer-Wins): Uses timestamps to pick a single value; simple but may lose data.
• MV-Register (Multi-Value): Retains all concurrent assignments, pushing resolution to the application or user.
• RGA/Logoot for Text: Algorithms that assign globally unique, ordered identifiers to each character so that concurrent insertions at the same index are placed deterministically.

Because CRDTs do not require a central coordinating server, they are the gold standard for offline-first and local-first software. A user can make an arbitrary number of edits while disconnected, and the local changes will seamlessly merge with the server or other peers upon reconnection.

• Partition Tolerance: The system remains fully available for writes during a network split.
• Edge Replication: Data can live on a user's device, a cloud replica, and a backup server simultaneously.
• Use Case: A legal document comparison engine using CRDTs allows multiple attorneys to redline a contract on a plane, with all changes merging deterministically once they land.

A version control operation that combines two divergent document branches by analyzing their changes against a common base ancestor. The algorithm identifies three versions: the base (original), 'ours' (local changes), and 'theirs' (remote changes). When both branches modify the same clause, a conflict is raised requiring manual resolution. This is the foundational merge strategy in Git and legal document comparison systems where multiple negotiators work on separate redlines simultaneously.

A programmatic rule set that automatically reconciles overlapping edits made by different parties to the same section of a document. Strategies include:

• Last-writer-wins (LWW): The most recent timestamp prevails
• Multi-value register: All conflicting values are preserved for manual selection
• Operational priority: Edits from specific roles (e.g., senior partner) override others In CRDT-based systems, these algorithms are deterministic, ensuring all replicas converge to the identical state without communication.

A quantitative metric measuring the minimum number of single-character operations (insertions, deletions, substitutions) required to transform one text string into another. For example, transforming 'contract' to 'contact' has an edit distance of 1 (insert 'a'). This metric is foundational to diff algorithms and is used in fuzzy matching to identify near-duplicate clauses. The Damerau-Levenshtein variant adds transposition operations, catching common typing errors like 'recieve' vs 'receive'.

A semantic comparison method that converts text chunks into high-dimensional mathematical vectors and measures the cosine distance between them to identify meaning-level changes. Unlike traditional text diffs, this approach detects when a clause has been reworded but retains identical legal effect, or conversely, when a minor textual change fundamentally alters an obligation. This technique is critical for Material Adverse Change (MAC) clause analysis, where surface-level edits may mask significant risk shifts.