Locally Correct Interleavings

• Locally correct interleavings are defined as structural and semantic properties that ensure optimal and valid behavior under local restrictions in varied systems.
• They are applied across domains like concurrency, merge trees, and transactional memory, using techniques such as two-thread reductions and residual interleaving distances.
• Algorithmic methods, including dynamic programming and conflict graph analysis, enable scalable verification and modular reasoning in highly non-deterministic executions.

A locally correct interleaving is a structural and semantic property of execution traces, matchings, or states in concurrent and topological systems such that, under local restrictions (e.g., fixing partial executions, state constraints, or pointwise matchings), the induced behavior or correspondence remains “optimal,” “valid,” or “correct” with respect to the system’s specification or distance metric. The concept arises independently across concurrency theory, topological data analysis, transactional memory, and program verification, motivated by scalable reasoning about highly non-deterministic executions and fine-grained similarity between structured objects.

1. Formal Definitions Across Domains

Locally correct interleavings receive distinct but structurally analogous definitions in concurrency, state-based system models, merge trees (topological data structures), and persistent homology. Core motifs include:

• Concurrent systems: An interleaving is locally correct if, for any partial execution or “scenario,” the correctness or linearizability proof can be reduced to local, typically two-thread, conditions or local invariants, without requiring a global view of all possible interactions (Feldman et al., 2020, Enea et al., 2023).
• Merge trees and interleaving distance: A locally correct interleaving between two merge trees is a matching (two maps satisfying ancestor relations and shift bounds) such that for any fixed subset of the correspondence, the restriction is itself optimally interleaved with respect to the residual interleaving distance (Beurskens et al., 18 Dec 2025).
• Poset models of concurrency: Interleaving-consistency (a poset-theoretic analogue of local correctness) stipulates that one can always advance a single process at a time without violating causal constraints, formalized via width-antichain and single-step update properties (Chauhan et al., 2014).
• Transaction systems: Local correctness demands that each transaction’s serializability or opacity be checked only against the history up to its last committed predecessor, making local linearization independent of future or aborted transactions (Kuznetsov et al., 2012).

2. Locally Correct Interleavings in Concurrent Structures

In highly-concurrent search data structures, unsynchronized traversals induce complex interleavings due to simultaneous reads and writes. Feldman et al. formalize correctness by introducing two mechanisms (Feldman et al., 2020):

1. Single-step compatibility: A pure sequential property ensuring that, from any location $ℓ$ satisfying a reachability predicate $R$, the next traversal step (as dictated by the deterministic decision relation $\mathrm{extend}_p$) moves to a location also satisfying $R$.
2. Write forepassedness: A property of each write operation, stating either that $R$-reachability is not diminished, or if it is diminished, future writes preserve the requisite reachability for subsequent navigation steps.

The main theorem establishes that if both properties hold, then any traversal is "locally correct," i.e., each location reached during the traversal was $R$-reachable at some point in the recent past, and thus traversals can be linearized at past states without global interleaving analysis.

Instances include logical-order AVL trees (where node deletion induces immutability, making forepassedness trivial) and contention-friendly BSTs (where pointer updates via rotations or marking as deleted preserve compatibility and enable local reasoning).

3. Locally Correct Interleavings in Topological Matching

In topological data analysis, the interleaving distance between merge trees measures global structural similarity but can fail to capture local agreement, as bottleneck optimality may induce excessive shifts for some correspondences. Beurskens et al. introduce locally correct interleavings (Beurskens et al., 18 Dec 2025) via:

• Residual interleaving distance $d_P$: For a partial interleaving $P$ (a fixed subset of matched points), $d_P$ quantifies the minimal additional shift needed to extend $P$ to a global interleaving, disregarding shift cost along the "fan" (all ancestors of pre-fixed pairs).
• Definition of locally correct: An interleaving is locally correct if, for every restriction $R$ (fixing part of the total matching), the induced shift equals the residual interleaving distance $d_R$. This ensures local optimality on every subtree or restriction.

The main theorem shows existence of locally correct interleavings for any pair of finite merge trees, constructively via a sequence of minimal augmentations that progressively enforce local optimality without violating dominance.

4. State-Based Models and Interleaving-Consistency

Kumar and Mattern provide a poset-theoretic completion of the locally correct interleaving idea by characterizing state-based models of asynchronous concurrent computations (Chauhan et al., 2014):

• Interleaving-consistency: For every width-antichain $W$ (a global cut with one state per process), there exists a neighboring width-antichain $W'>W$ obtained by advancing exactly one process. Violation (e.g., impossible advancement without simultaneity) precludes modeling as an asynchronous computation.
• Single-step property ($\psi$): No two process chains simultaneously demand mutual prior advancement; i.e., never both $[i,s-1]<[j,t]$ and $[j,t-1]<[i,s]$.
• Characterization theorem: $(S,<)$ is realizable as the state model of an asynchronous run if and only if it is both width-extensible and interleaving-consistent.

This formalism connects local advancement properties in execution to the existence of globally consistent, but locally independent, interleavings.

5. Local Correctness in Transactional Memory and Program Logic

In transactional memory and logical concurrency control:

• Local opacity and non-interference: Local correctness (e.g., local opacity) allows each transaction to be serialized only against past committed transactions, circumventing the impossibility of non-interference in global opacity. Permissive, non-interfering implementations follow, in which transactions are aborted only when strictly necessary based on their own local serializability graph (Kuznetsov et al., 2012).
• Concurrency control from sequential proofs: Local correctness is enforced by associating logical locks with atomic predicates in program invariants and ensuring each concurrent execution step preserves the sequential proof's local assertions. This "basis-preserving" discipline ensures every intermediate state satisfies the correctness conditions for each thread, ruling out assertion failures in all possible interleavings (Deshmukh et al., 2011).

6. Quotient and Scenario-Based Local Correctness in Proofs

In the scenario-based approach to linearizability proofs, Enea et al. reduce the verification of concurrent objects to reasoning about a canonical set of locally correct interleavings or scenarios (Enea et al., 2023):

• Commutativity quotient: The set of execution traces quotiented by commutativity of independent steps, such that every trace is equivalent (by local swaps) to some canonical trace.
• Layer expressions and two-thread reduction: All interleavings are represented as regular or context-free compositions of local and write layers; global correctness reduces to case analysis on a finite set of two-thread scenarios.
• Soundness: Verifying linearizability or other correctness criteria for the quotient scenarios suffices to ensure global correctness for arbitrary interleavings.

This methodology captures the intuition underlying locally correct interleavings: all global executions can be decomposed, up to commutativity, into compositions of locally analyzable scenarios.

7. Algorithmic Techniques and Applications

Algorithmic aspects of constructing, recognizing, or enforcing locally correct interleavings include:

• Dynamic programming with constraints: For merge trees, locally correct interleavings are constructed iteratively, augmenting the partial matching at each step by solving a constrained interleaving-distance problem and adding a minimal set of critical matching pairs to enforce local optimality (Beurskens et al., 18 Dec 2025).
• Automated selector logic: For concurrency logic, program verification tools synthesize logical locks and control acquisition/release points based on invariant-predicate dependencies, reducing deadlock and ensuring local assertion maintenance (Deshmukh et al., 2011).
• Conflict graph analysis: In transactional systems, local serialization and conflict graphs underpin the efficient detection of abort conditions and enable non-interference guarantees (Kuznetsov et al., 2012).
• Scenario automata: Quotient-based methods employ automata encoding the finite set of base scenarios; all global interleavings decompose into these via commutativity (Enea et al., 2023).

Significance: The adoption of locally correct interleavings decreases proof complexity, fosters modular reasoning, and broadens the range of systems where scalable correctness, stability, or distance guarantees can be obtained. These results unify approaches across concurrency, distributed systems, persistent topological structures, and program logic, supporting both practical verification and foundational theory.