Distributed Arrays: Fundamentals & Applications

• Distributed arrays are systems that distribute storage, indices, or physical elements across multiple nodes while retaining a single global coherence.
• They enable scalable computing by partitioning data into local blocks, optimizing parallel processing and high memory bandwidth efficiency.
• In networked and adversarial environments, distributed arrays establish verifiable storage and communication protocols, ensuring robustness without majority reliance.

Distributed arrays are array-structured systems whose indices, storage, or physical elements are distributed across multiple computational processes, network nodes, or spatially separated devices while remaining coordinated as a single logical object or coherent physical aperture. In the cited literature, the term encompasses at least three major usages: distributed-memory numerical arrays for HPC and statistical computing, physically distributed sensing and communication arrays such as phased, antenna, and microphone arrays, and networked data structures that mimic arrays in adversarial or coded distributed systems. Across these usages, the central technical problem is the same in outline: to preserve global array semantics or coherent array behavior under locality, communication, synchronization, estimation, and robustness constraints.

1. Formal models and array semantics

A foundational formalization treats an $n$-dimensional array $A$ as a function

$A : I \rightarrow D \cup L,$

where $$I \subseteq I_1 \times I_2 \times \ldots \times I_n$$ is the index set, $D$ is the value domain, and $L$ captures undefined entries. On this basis, an array algebra has been proposed for distributed array processing, with projection $\pi_J(A)$, selection $\sigma_c(A)$, cross product $A_1 \times A_2$, union $A \cup B$, and bijective index transformations supporting augmentation, reduction, and reorganization of dimensions. The stated purpose is not to replace numerical kernels, but to provide a structural layer for re-arranging and distributing multi-dimensional array data in scientific processing (0812.4986).

Within distributed-memory computing, the dominant abstraction is a logically global array partitioned across processes or workers. One formulation describes an $A$0-element array split among multiple processes $A$1, each process storing and updating only its local portion $A$2, typically under an “owner computes” rule. Another emphasizes chunking: a large global $A$3 or $A$4 array is decomposed into smaller blocks that are stored and processed independently on different workers. These formulations are closely related to the Partitioned Global Address Space view and are explicitly motivated by preserving a single-array programming model while exposing locality to the runtime (Kepner et al., 24 Aug 2025, Travelletti et al., 2023).

This dual commitment to global semantics and local execution recurs in software interfaces. D2O defines a distributed_data_object whose global interface is similar to a numpy.ndarray, while each cluster node can directly access its local numpy.ndarray for custom high-performance modules. The design separates algorithm code from data-distribution logic and supports several distribution strategies, including 'equal', 'fftw', 'not', and 'freeform' (Steininger et al., 2016). DistStat.jl adopts the same pattern in Julia through MPIArray{T,N,AT}, a subtype of AbstractArray, with the local data exposed as localarray and the global interface aligned with standard Julia array semantics (Ko et al., 2020).

A recurring implication is that “distributed array” is not merely a storage format. It denotes a contract between semantics and placement: the programmer or protocol reasons globally, while execution is constrained locally.

2. Distributed arrays in high-performance numerical and statistical computing

In HPC, distributed arrays are primarily an abstraction for scaling memory-bound and linear-algebra-intensive workloads without abandoning high-level languages. One recent study argues that distributed arrays derive parallelism from data locality, which naturally leads to high memory bandwidth efficiency, and demonstrates scalable performance vertically within nodes, horizontally across nodes, and temporally across hardware generations using the STREAM benchmark. The reported horizontal scaling across multiple nodes was linear; the same work reports a 10x increase in CPU core bandwidth over 20 years, a 100x increase in CPU node bandwidth over 20 years, a 5x increase in GPU node bandwidth over 5 years, and sustained bandwidth $A$5 PB/s on hundreds of MIT SuperCloud nodes (Kepner et al., 24 Aug 2025).

D2O represents an earlier but already mature software realization of this idea. It is written in pure Python, relies on numpy and mpi4py for expensive operations and communication, and aims to achieve usability without losing numerical performance and scalability. Its performance is described as being on a par with numpy for serial applications and scaling well when moving to an MPI cluster. The package also makes the local data directly accessible, which is crucial when specialized C/C++/Fortran or FFT backends must operate on node-resident segments (Steininger et al., 2016).

DistStat.jl pushes the same abstraction into statistical computing across multi-node CPU clusters and multi-GPU environments. It provides transparent execution by changing the underlying array type, for example from Array to CuArray, while keeping the same high-level Julia code. The package is demonstrated on large-scale nonnegative matrix factorization, multidimensional scaling, and an $A$6-regularized Cox proportional hazards model on an 8-GPU workstation and a 720-CPU-core AWS virtual cluster; fitting a half-million-variate regression model for UK Biobank-scale data took less than 50 minutes on AWS (Ko et al., 2020).

Distributed arrays also alter algorithm design rather than merely accelerating existing kernels. In non-sequential Ensemble Kalman Filtering, the full localized covariance matrix is constructed and used in distributed memory so that all observations can be assimilated in a single batch rather than sequentially. The implementation uses Dask distributed arrays, randomized SVD, and chunk-wise linear algebra to overcome the memory bottlenecks of high-dimensional EnKF. Comparative assessments on synthetic and paleoclimatic reconstruction problems indicate that the non-sequential implementation outperforms the sequential one; the reported synthetic study reaches state sizes up to $A$7, assimilates up to 10,000 observations, improves RMSE or skill scores by 2–5%, and removes the 5% performance spread caused by observation-order dependence in sequential localized assimilation (Travelletti et al., 2023).

A common misconception is that distributed arrays are only a convenience layer over MPI. The cited work suggests a stronger claim: once the array itself becomes the unit of decomposition, algorithms that were previously considered impractical or theoretically compromised on single-node memory models—such as all-at-once EnKF—become implementable in a materially different form (Travelletti et al., 2023).

3. Synchronization and calibration in distributed antenna arrays

In distributed antenna and phased arrays, the term refers to spatially separated radiating or receiving elements that must behave as a coherent array. The principal challenge is electrical-state coordination: frequency, phase, and time must be aligned sufficiently tightly that distributed beamforming or coherent combining remains possible. A decentralized frequency-alignment model expresses the received field as

$A$8

with $A$9 capturing phase error induced by oscillator drift. In that framework, average consensus on node frequencies is shown to achieve tolerable errors for coherent gain greater than 90% of the ideal gain, provided the standard deviation of relative phase errors remains below approximately $A : I \rightarrow D \cup L,$0; the same study analyzes static topology, dynamic topology, and oscillator drift (Ouassal et al., 2019).

Subsequent work replaces plain consensus with richer local-message protocols. The MPAC algorithm performs decentralized frequency and phase synchronization via local broadcast of node electrical states and message passing over neighbors. Simulation results show residual phase errors reduced to about $A : I \rightarrow D \cup L,$1 degrees with only 20 moderately connected nodes, whereas the earlier DFPC-based result of $A : I \rightarrow D \cup L,$2 degrees had been obtained for arrays with at least 400 nodes and connectivity ratio $A : I \rightarrow D \cup L,$3. MPAC is also reported to converge faster than DFPC-based algorithms, particularly for larger arrays with moderate connectivity (Rashid et al., 2022).

Kalman-based fusion further deepens this trend. HA-DKF combines consensus on measurements, consensus on information, and consensus on estimates and error covariances within a distributed Kalman filtering architecture. Each node shares local measurements, innovation noise covariances, predicted information matrices and vectors, and updated estimates and error covariances with its neighbors. The stated result is improved electrical-state synchronization, fewer consensus iterations, and lower residual phase error than conventional DKF, KF-DFPC, and KF-HCMCI in simulated distributed phased arrays (Rashid et al., 2023).

Time synchronization imposes a parallel constraint. A two-tone two-way time-transfer scheme demonstrated wireless time synchronization over a 90 cm 5.8 GHz link with a timing precision of $A : I \rightarrow D \cup L,$4 ps using a single-pulse 40 MHz two-tone waveform, explicitly comparing the timing precision of the two-tone waveform with LFM and motivating the choice through the Cramér–Rao lower bound (Merlo et al., 2022). A later decentralized method for dynamic-connectivity arrays combines two-way time transfer with average consensus, supports decentralized synchronization with picosecond accuracy $A : I \rightarrow D \cup L,$5 ps), achieved under 3 ps precision for a fully connected frequency-syntonized network, and maintained convergence even when only one link connected two randomly chosen nodes at each iteration in a six-node software-defined-radio array (Shandi et al., 2024).

Calibration introduces a distinct but related problem. Reciprocity calibration requires only bidirectional measurements and does not require knowledge of the propagation delays $A : I \rightarrow D \cup L,$6, because

$A : I \rightarrow D \cup L,$7

Full calibration is stronger and requires knowledge of the coupling delays $A : I \rightarrow D \cup L,$8, which the cited work describes as generally infeasible in distributed arrays. To address joint calibration of two arrays that are individually F-calibrated, a dual-frequency over-the-air method is proposed in which measurements at two different frequencies resolve a $A : I \rightarrow D \cup L,$9-ambiguity and enable the combined array to become jointly F-calibrated (Larsson et al., 2023).

A recurring misconception is that decentralized operation implies loose synchronization or that over-the-air calibration is either trivial or impossible in all cases. The literature is more specific: decentralized consensus and message passing can reach picosecond time precision and extremely low residual phase error, while full over-the-air calibration is infeasible in the classical form but becomes possible under the dual-frequency joint-calibration construction (Shandi et al., 2024, Larsson et al., 2023).

4. Channel acquisition, precoding, power control, and mobile cooperation

Once synchronization is available, distributed arrays support more advanced inference and communication architectures. DPA-MIMO treats the transceiver as an array of sub-arrays whose partial spatial separation induces a partially coupled beam-domain channel with hidden structured sparsity. To exploit this, coordinated open-loop pilot beam pattern design reduces training overhead relative to orthogonal per-sub-array sounding, and two sparse recovery methods—JOMP and JSBL-$$I \subseteq I_1 \times I_2 \times \ldots \times I_n$$0—recover common and innovation supports in the beam-domain channel. Hybrid precoding is then performed through SIC-based sub-array grouping, decomposing RF beamformer design into interactive per-sub-array-group handling with satisfactory performance and low complexity (Zhang et al., 2019).

Distributed antenna arrays also alter downlink resource allocation. In massive MIMO networks where each base station consists of multiple antenna arrays deployed in arbitrary locations within a cell, the large-scale propagation effect differs from a user to different arrays in the same cell. Under correlated Rayleigh fading and MRT, a closed-form spectral-efficiency expression

$$I \subseteq I_1 \times I_2 \times \ldots \times I_n$$1

supports max-min downlink power control. The stated numerical result is that optimizing for max-min spectral efficiency improves the sum spectral efficiency of the network compared with equal power allocation; one detailed example reports 34.16 b/s/Hz versus 25.10 b/s/Hz, a 26.52% improvement (Akbar et al., 2018).

The same distributed-array logic extends to mobility. MD-MIMO generalizes conventional D-MIMO by replacing wired fronthaul with wireless fronthaul and allowing all radio network nodes, including the gNB and RUs, to be mobile. The architecture includes coherent and non-coherent modes, dynamic clustering, and optional RU roles for UEs. In an urban microcellular case study, the reported downlink capacity increase over a gNB-only baseline reaches 27.36-fold at 1 km range, while uplink receive-array operation with more RUs supports higher-order MCS and improved reliability (Said et al., 16 Apr 2025).

Phase-coherent distributed arrays also enable joint sensing and inference tasks rather than only communications. A study of radio stripes and ELAA architectures formulates joint estimation of UE location, clock offset, phase offset, and scatterer locations from sub-6 GHz uplink observations, derives the Fisher information and ML estimator, and proposes a three-step algorithm that first estimates phase offset from LoS carrier phase, then estimates UE position and clock offset using LoS and wall reflections, and finally maps scattering points via a null-space transformation. The stated benefit is that carrier phase exploitation in phase-coherent distributed arrays materially improves localization and mapping performance under different bandwidth regimes (Fascista et al., 2024).

These results suggest that distributed arrays are most powerful when geometry, inference, and coordination are treated jointly. Array distribution is not only a hardware layout; it changes the estimation problem, the pilot design, the sparsity model, and the feasible control architecture.

5. Distributed sensing and manipulation arrays beyond wireless communications

Distributed arrays also appear as large-scale sensing and actuation surfaces. In augmented listening, a cooperative source-separation and enhancement system combines wearable listening devices with fixed microphone arrays distributed around a room. The full distributed microphone array is used offline or with relaxed delay constraints to separate sound sources and estimate second-order statistics, while each listening device uses only its own local microphones for strict-latency real-time binaural enhancement. The experimental setup involved 10 speech sources and up to 160 microphones in a large reverberant room, and the central architectural claim is that only statistical parameters—not raw audio—need be sent to the wearable devices (Corey et al., 2019).

The signal model in that setting is explicitly local at run time,

$$I \subseteq I_1 \times I_2 \times \ldots \times I_n$$2

while the filter design uses globally estimated statistics such as $$I \subseteq I_1 \times I_2 \times \ldots \times I_n$$3, $$I \subseteq I_1 \times I_2 \times \ldots \times I_n$$4, and relative transfer functions $$I \subseteq I_1 \times I_2 \times \ldots \times I_n$$5. This partition of roles is critical: remote microphones improve separation and statistical estimation, but delay-constrained filtering remains local. Reported results include up to 25 dB SNR improvement for ideal MMSE separation with wearable arrays and a strong empirical relation in which every 1 dB of separation improvement yields about 1 dB in enhancement (Corey et al., 2019).

In robotics, delta arrays instantiate distributed arrays as compliant manipulation surfaces. One reported platform consists of 64 linearly-actuated delta robots with 3D-printed compliant linkages, for a total of 192 DoF, together supporting translation, alignment, prehensile squeezing, lifting, grasping, and other coordinated distributed manipulations. The work emphasizes the combination of modular array structure, distributed communication and control, and compliance that tolerates aggressive reinforcement-learning exploration without breaking end-effectors (Patil et al., 2022).

These two examples expose a broader design pattern. Distributed arrays can decouple global perception or task decomposition from local real-time action. In the microphone case, the decoupling is between room-scale statistical estimation and wearable low-latency filtering; in the robotic case, it is between global manipulation objectives and local inverse kinematics and compliance (Corey et al., 2019, Patil et al., 2022).

6. Robust distributed arrays in adversarial networks and coded distributed computing

A third major meaning of distributed arrays is explicitly data-structural. Robust distributed arrays are introduced as a networking layer for Data Availability Sampling in open, permissionless, synchronous networks. The interface is defined through iStore(h, i, x) and iGet(h, i), and robustness is formalized as a probabilistic guarantee that, for all but a small fraction of indices and except with total error probability at most $$I \subseteq I_1 \times I_2 \times \ldots \times I_n$$6, an honest getter retrieves the stored symbol after bounded delay. The construction uses a $$I \subseteq I_1 \times I_2 \times \ldots \times I_n$$7 matrix of subnetworks, random node assignment to cells, row and column cliques, and constant-latency store/get procedures. The cited storage cost per node is $$I \subseteq I_1 \times I_2 \times \ldots \times I_n$$8, peer degree is at most $$I \subseteq I_1 \times I_2 \times \ldots \times I_n$$9, and iGet returns after at most 2–3 rounds. Crucially, the security proof does not require an honest majority; it relies only on a minimal absolute number of honest nodes (Feist et al., 18 Apr 2025).

This directly contradicts the common assumption that robust distributed storage in adversarial networks must be majority-based. The example given in the cited work states that for $D$0 honest nodes, each storing $D$1 of the data $D$2 and each connected to $D$3 of nodes, more than 90% of data indices will always be available with overwhelming probability (Feist et al., 18 Apr 2025).

Combinatorial array constructions also encode distributed computation protocols. A wireless MapReduce array is an $D$4 array over $D$5 that succinctly represents the Map, Shuffle, and Reduce phases of a wireless coded distributed computing system. Every row has exactly $D$6 stars, each communication round label appears $D$7 times, and the row structure guarantees one-shot linear decodability in the wireless interference channel. The resulting normalized delivery time matches the optimal one-shot linear performance of earlier schemes but with the number of input files reduced from exponential in the number of nodes to the order of the number of nodes (Peter et al., 2024).

Coded Distributed Arrays extend the data-availability setting by combining 2D Reed–Solomon expansion with per-cell RLNC and homomorphic KZG commitments. Each extended cell is split into $D$8 pieces and coded as

$D$9

Compared with RDA, the reported evaluation shows a replication factor 5–5.7× lower, block propagation cost 2–2.3× lower, and synchronization cost 1.4–1.5× lower, while preserving Byzantine-tolerant sampling and direct structured retrieval (Minh et al., 15 Jun 2026).

Taken together, these works show that distributed arrays in networked systems are not merely passive layouts. They are protocol-bearing structures: the array indexes define storage, routing, coding, and verification semantics.

Distributed arrays therefore designate a family of abstractions rather than a single technique. In one branch, they expose locality for scalable numerical computing; in another, they turn spatially separated sensors or radiators into coherent apertures; in another, they provide structured, verifiable storage and communication patterns in open networks. The literature consistently ties their effectiveness to three mechanisms: locality-aware partitioning, bounded-information exchange, and an explicit model of what must remain globally coherent—numerical state, electrical phase, statistical summary, or data availability proof.