Algorithmic Locality: Principles and Applications

• Algorithmic Locality is the principle that confines computation and decisions to bounded neighborhoods, enabling efficient local processing in varied systems.
• It unifies theoretical frameworks across graph algorithms, memory systems, tensor networks, and online methodologies, providing a common language for locality.
• Its study reveals fundamental trade-offs between local information access and global performance, impacting complexity, robustness, and optimality in computations.

Algorithmic locality is the principle that computation, decision, or update at a point should depend primarily on a bounded neighborhood in some underlying domain—graph distance, time, address space, process topology, code coordinates, or tensor-network support. Across the literature, the term is used for several related but non-identical notions: locality radii in distributed and online graph algorithms, bounded temporal horizons in online decision rules, reuse-based metrics in memory systems, locality-aware communication schedules, coding-theoretic recoverability, and exponentially decaying response of tensor-network belief propagation to local perturbations (Akbari et al., 2021, Pacut et al., 2021, Yuan et al., 2018, Rudow et al., 2020, Midha et al., 23 Apr 2026). In each setting, locality turns a global problem into one governed by constrained neighborhoods, and the main technical questions concern what information is visible locally, what can be decided from it, and how locality changes complexity, robustness, or performance.

1. Conceptual foundations

In graph algorithms, locality is formalized through neighborhoods such as $B(v,T)$, the induced radius-$T$ neighborhood around a node $v$. An algorithm solves a problem with locality $T(n)$ if its decisions depend only on the information allowed within that radius; the paper on distributed, sequential, dynamic, and online graph algorithms uses the terms locality and time interchangeably, including round complexity in distributed models (Akbari et al., 2021). In temporal models, locality is expressed by a bounded horizon: a regular time-local online algorithm uses a single rule $A:(X\cup\{\bot\})^T\to Y$ and outputs

$y_i = A(x_{i-T},\ldots,x_{i-1}),$

while a clocked time-local algorithm allows the rule to vary with $i$ but still only inspects the last $T$ inputs (Pacut et al., 2021).

In memory-system analysis, locality is treated as a measurable property of an execution trace. The measurement-theoretic formulation includes reuse time, reuse distance, working set, footprint, and miss ratio, and it distinguishes sequence metrics from histogram metrics. Reuse distance is the number of distinct data accessed since the last access to the same datum, and footprint $F(x)$ is the average working-set size over windows of length $x$ (Yuan et al., 2018). In coded computation, locality becomes a recoverability parameter: for a function class $T$0, computational locality $T$1 is defined through the associated code and equals the minimum number of workers needed to recover $T$2 outputs despite $T$3 stragglers (Rudow et al., 2020).

A different but closely related usage appears in tensor networks. For projected entangled pair states satisfying strong injectivity, tensor-network belief propagation exhibits what the authors call algorithmic locality: local perturbations affect the belief-propagation fixed point with influence decaying rapidly with graph distance, and this locality extends to observables via cluster corrections (Midha et al., 23 Apr 2026). Taken together, these formulations show that algorithmic locality is not a single metric but a family of bounded-dependence principles adapted to different computational objects.

2. Graph, distributed, and online locality

A central unifying framework for graph problems compares four models: LOCAL, SLOCAL, dynamic-LOCAL, and online-LOCAL. In LOCAL, each node outputs based on its radius-$T$4 view; in SLOCAL, nodes are processed sequentially with access to radius-$T$5 memories of previously processed nodes; in dynamic-LOCAL, only nodes within distance $T$6 of an update may change labels; and in online-LOCAL, nodes are revealed one by one, but the algorithm can inspect the revealed radius-$T$7 subgraph before irrevocably labeling the new node (Akbari et al., 2021). The inclusions

$T$8

and

$T$9

place LOCAL as the weakest and online-LOCAL as the strongest of the four models, while SLOCAL and dynamic-LOCAL are incomparable in general (Akbari et al., 2021).

For locally checkable labeling problems, this hierarchy collapses on restricted graph families. On paths and cycles, the locality classes in LOCAL and online-LOCAL coincide and are exactly $v$0, $v$1, and $v$2. On rooted regular trees, the classes $v$3, $v$4, and $v$5 coincide across LOCAL, SLOCAL, dynamic-LOCAL, and online-LOCAL (Akbari et al., 2021). This allows lower bounds and decidability results established in LOCAL to transfer to the other three models on those families.

The equivalence fails on more general graphs. A sharp counterexample is $v$6-coloring in bipartite graphs: there is an online-LOCAL algorithm with locality $v$7, whereas the same problem has locality $v$8 in LOCAL and $v$9 in SLOCAL on grids (Akbari et al., 2021). The gap comes from spatial lookaround: in the online-LOCAL model, the algorithm can inspect a bounded-radius neighborhood before committing, and the specific $T(n)$0-coloring construction uses group merges, parity flips, and a barrier color to keep the required visible radius at $T(n)$1 (Akbari et al., 2021).

3. Temporal locality, local computation, and probabilistic locality

Temporal locality in online algorithms restricts dependence to a bounded suffix of the input stream. The regular model is clock-oblivious, while the clocked model allows $T(n)$2 to depend on time $T(n)$3 but not on older history beyond the last $T(n)$4 inputs (Pacut et al., 2021). Deterministic regular time-local algorithms have an immediate distributed interpretation: if multiple machines observe the same input stream but start at different times, then after at most $T(n)$5 steps they produce identical outputs, so the system is self-stabilizing in $T(n)$6 steps without communication (Pacut et al., 2021).

The same work establishes a close correspondence with local distributed graph algorithms on paths. Regular $T(n)$7-local algorithms coincide with $T(n)$8-round deterministic algorithms in the port-numbering model on directed paths, while clocked $T(n)$9-local algorithms coincide with a numbered LOCAL variant in which nodes know their position (Pacut et al., 2021). This correspondence supports both positive and negative transfers. On the positive side, for bounded monotone minimization games, any deterministic $A:(X\cup\{\bot\})^T\to Y$0-competitive online algorithm can be simulated by a clocked $A:(X\cup\{\bot\})^T\to Y$1-time-local algorithm with competitive ratio $A:(X\cup\{\bot\})^T\to Y$2 for some constant $A:(X\cup\{\bot\})^T\to Y$3 (Pacut et al., 2021). On the negative side, time locality does impose hard limits: for caching, any deterministic time-local algorithm with horizon $A:(X\cup\{\bot\})^T\to Y$4 has worst-case cost at least $A:(X\cup\{\bot\})^T\to Y$5, even though $A:(X\cup\{\bot\})^T\to Y$6 on those instances (Pacut et al., 2021). For online file migration, however, time-locality can still be strong: there exists a $A:(X\cup\{\bot\})^T\to Y$7-competitive regular time-local algorithm with horizon $A:(X\cup\{\bot\})^T\to Y$8 for two nodes and unit migration costs, and the same paper gives a $A:(X\cup\{\bot\})^T\to Y$9-competitive deterministic and a $y_i = A(x_{i-T},\ldots,x_{i-1}),$0-competitive randomized time-local algorithm for any migration cost $y_i = A(x_{i-T},\ldots,x_{i-1}),$1 (Pacut et al., 2021).

Local computation algorithms push locality to the query model. An LCA does not construct a full output $y_i = A(x_{i-T},\ldots,x_{i-1}),$2; it answers location queries $y_i = A(x_{i-T},\ldots,x_{i-1}),$3 while remaining consistent with at least one legal global solution (Rubinfeld et al., 2011). The model is explicitly local in time and space complexity: a $y_i = A(x_{i-T},\ldots,x_{i-1}),$4-LCA answers each query in time $y_i = A(x_{i-T},\ldots,x_{i-1}),$5, using space $y_i = A(x_{i-T},\ldots,x_{i-1}),$6, with failure probability at most $y_i = A(x_{i-T},\ldots,x_{i-1}),$7. The framework supports polylogarithmic local access for problems such as maximal independent set, radio-broadcast scheduling, hypergraph coloring, and $y_i = A(x_{i-T},\ldots,x_{i-1}),$8-SAT under appropriate dependency conditions (Rubinfeld et al., 2011). For example, there is a $y_i = A(x_{i-T},\ldots,x_{i-1}),$9-LCA for deciding whether a queried vertex belongs to a maximal independent set in a bounded-degree graph (Rubinfeld et al., 2011).

A more recent probabilistic refinement appears in locality analysis for resampling-based Lovász Local Lemma algorithms. Under the polynomial criterion $i$0 with $i$1, most events’ variable assignments are determined by $i$2-radius neighborhoods in the dependency graph, and the events that may still require resampling can be identified from the same neighborhoods (Davies-Peck, 17 Feb 2025). This yields a LOCAL algorithm with $i$3 node-averaged complexity, LCA and VOLUME algorithms with $i$4 probes per query, and $i$5-round algorithms for CONGESTED CLIQUE and related MPC models (Davies-Peck, 17 Feb 2025). Here locality is not just a bound on visible information; it is a theorem that most of the computation is already fixed by very small neighborhoods.

4. Measurement theory and architecture-independent locality

In program execution, locality is often measured rather than prescribed. A measurement-theoretic account defines reuse time, reuse distance, working set, footprint, and cache miss ratio on a trace $i$6 and proves precise relations among them (Yuan et al., 2018). The footprint

$i$7

is the average working-set size over windows of length $i$8, and Denning–Schwartz working-set theory is shown to compute the steady-state footprint exactly: $i$9 The same theory proves that miss ratio can be obtained by footprint differentiation,

$T$0

and it distinguishes sequence-level equivalences from histogram-level non-equivalences: reuse-time and reuse-distance sequences are constructively related, but their histograms do not determine the original trace (Yuan et al., 2018).

A complementary abstraction treats locality as a cost function on access sequences. The locality-of-reference model assigns a cost to each access based on spatial distance or spatio-temporal distance, using nonnegative, nondecreasing, concave locality functions in the memoryless case and bidimensional locality functions in the spatio-temporal case (Afshani et al., 2019). Under this framework, cache-oblivious algorithms that are asymptotically optimal in the ideal-cache model are also asymptotically optimal for any “reasonable” system that rewards locality of reference, provided the problem is $T$1-stable and the usual cache-oblivious assumptions, including tall cache, hold (Afshani et al., 2019). This result links ideal-cache optimality to a much broader class of architectures, including systems whose behavior reflects not only caches but also prefetching, TLBs, and storage locality.

These two lines of work are complementary. The measurement theory supplies a precise vocabulary for describing locality in traces, while the locality-of-reference framework states when asymptotically locality-optimal access patterns are robust across architectures (Yuan et al., 2018, Afshani et al., 2019). Together they turn locality from an informal intuition into a formal object with transformations, equivalences, and optimality statements.

5. Program transformations and hardware-aware locality optimization

One major research direction treats locality as a property that can be synthesized by program transformation. In array-oriented data-parallel programs, Parakeet introduces TiledMap, TiledReduce, and TiledScan, together with an automatic tiling transformation that applies once for cache tiling and again for register tiling (Hielscher et al., 2013). Cache-tile sizes are left unspecified until runtime and selected by autotuning, while register tiles use a compile-time heuristic based on available registers. On matrix multiplication, the tiled implementation is reported as $T$2–$T$3 faster than untiled code when varying the number of rows in the left-hand matrix and $T$4–$T$5 faster when varying row lengths; on the evaluated workloads, register tiling accounts for about $T$6 of the tiling speedups (Hielscher et al., 2013).

At the microarchitectural level, semantic locality treats memory-access regularity as a function of program context rather than purely address-stream regularity. The neural network prefetcher built around this idea uses a 128-bit context-state vector, predicts future deltas rather than absolute addresses, and trains online via an association queue and a small multilayer perceptron (Peled et al., 2018). The reported performance is an average speedup of about $T$7 on SPEC2006, with certain phases reaching about $T$8, and up to $T$9 over kernels (Peled et al., 2018). Here locality is not extracted from address adjacency; it is learned from correlations between current context and future accesses.

In iterative machine-learning kernels, locality can also be induced by algebraic restructuring. PL-NMF rewrites FAST-HALS non-negative matrix factorization so that the matrix-vector-heavy inner loop becomes a three-phase tiled schedule dominated by matrix-matrix operations, raising arithmetic intensity and reducing data movement (Moon et al., 2019). On the reported datasets, PL-NMF-cpu achieves per-iteration speedups of $F(x)$0, $F(x)$1, $F(x)$2, $F(x)$3, and $F(x)$4 over planc-HALS-cpu at $F(x)$5 (Moon et al., 2019).

Spatial accelerators make physical distance itself part of the cost model. Low-depth spatial tree algorithms place tree vertices on a two-dimensional mesh so that most communication occurs over short Manhattan distances, obtaining $F(x)$6 energy and poly-logarithmic depth for treefix sum and lowest common ancestor preprocessing with high probability (Baumann et al., 2024). AutoLALA extends the same concern to symbolic loop analysis: it lowers affine loop programs to polyhedral sets and maps, computes symbolic reuse distance as the image of the reuse interval under the access map, and produces closed-form data-movement formulas through the DMD framework (Zhu et al., 6 Apr 2026). A plausible implication is that locality has become not only a target of optimization but also a symbolic program property that can be derived before execution.

6. Domain-specific extensions

In coded computation, locality appears as recoverability under stragglers. For a function class $F(x)$7, computational locality $F(x)$8 is defined through the associated code and satisfies the exact equivalence

$F(x)$9

where $x$0 is the minimum worker threshold for recovering $x$1 desired outputs in the presence of $x$2 stragglers (Rudow et al., 2020). For multivariate polynomials of total degree $x$3,

$x$4

and the same locality viewpoint yields adaptive schemes that exploit linear dependencies among the specific inputs, requiring fewer workers than the lower bound in existing input-oblivious coded-computation frameworks (Rudow et al., 2020).

In tensor networks, belief propagation on strongly injective PEPS provides a mathematically explicit locality law. If $x$5, the BP fixed point is unique and the iterative message update is a contraction with factor

$x$6

Under a local tensor perturbation supported on $x$7, the fixed-point messages obey

$x$8

where $x$9 is the graph distance from the edge to $T$00, and local observables satisfy

$T$01

with $T$02 (Midha et al., 23 Apr 2026). The same paper gives a localized recomputation procedure whose runtime is polynomial in the target accuracy and independent of the global system size outside the affected neighborhood (Midha et al., 23 Apr 2026). This suggests a particularly strong form of algorithmic locality: perturbative changes can be repaired without re-solving the entire instance.

Learned retrieval and entity resolution use locality in a different sense. NLSHBlock trains a language-model encoder with an LSH-inspired loss

$T$03

so that similar records collide in a learned embedding space even when the operative similarity notion is task-specific rather than Jaccard or cosine (Wang et al., 2024). On the reported entity-resolution benchmarks, NLSHBlock achieves the best or tied-best $T$04 on all datasets and consistently the smallest candidate sets, with reductions of up to $T$05 relative to the best baseline at the same recall target (Wang et al., 2024). Here locality is not an analytic property of a fixed metric; it is a learned approximation to a domain-specific neighborhood structure.

A normative use of locality appears in audits of political search. For locality-specific government domains, correct targeting is defined by the condition $T$06, where $T$07 is the geographic coverage region of domain $T$08 and $T$09 is the search location (Perreault et al., 2024). In the 2022 US midterm election audit, the overall mistargeting rate for non-federal government sources is $T$10, with $T$11 at the state level, $T$12 at the county level, and $T$13 at the local level; correctly targeted sources have median rank $T$14, while mistargeted ones have median rank $T$15 (Perreault et al., 2024). In this usage, algorithmic locality is not a speed or complexity metric but a correctness condition for jurisdiction-sensitive retrieval.

7. Limits, separations, and structural boundaries

The literature also emphasizes that locality is a strong restriction, not merely a benign efficiency device. In graph algorithms, the four local models are distinct in general, and problems such as component-wise leader election, weak reconstruction, cycle detection, and nested orientation separate them sharply (Akbari et al., 2021). The collapse on paths, cycles, and rooted trees is therefore exceptional rather than universal.

A particularly strong negative result appears in static fast rerouting. The model allows only pre-installed, purely local forwarding rules without global recomputation or header state, and asks whether packets can still be delivered under adversarial link failures whenever the surviving graph remains connected (Foerster et al., 2022). The paper proves that for every $T$16, $T$17 admits no $T$18-tolerant forwarding pattern even in the source–destination model, although the post-failure graph can retain

$T$19

edge-disjoint $T$20-$T$21 paths (Foerster et al., 2022). More structurally, perfect touring is possible if and only if the graph is outerplanar, while the destination-only and source–destination models have sharp minor thresholds such as $T$22, $T$23, $T$24, and $T$25 on the impossibility side, and $T$26, $T$27, $T$28, and $T$29 on the positive side depending on the model (Foerster et al., 2022). These results make the “price of locality” literal: even linear post-failure connectivity can be invisible to purely local rules.

The same tension appears in time-local online computation. The bounded horizon grants restart tolerance and consistency, but it can destroy competitiveness for problems such as paging, where the additive term grows with the input length, and it imposes lower bounds such as $T$30 for randomized clocked $T$31-time-local algorithms in file migration when $T$32 (Pacut et al., 2021). Search mistargeting supplies another boundary case: when locality is jurisdictional rather than metric, a system may surface authoritative sources yet still fail locality as a relevance criterion because the sources belong to the wrong region (Perreault et al., 2024).

Taken together, these results show that algorithmic locality has a dual role. It is a productive design principle that yields transfer theorems, symbolic analyses, and practical speedups, but it is also a structural constraint that induces impossibility theorems, hierarchy separations, and correctness failures when the underlying problem fundamentally requires more than local information.