Coded Random Access (CRA)

• Coded Random Access (CRA) is a design paradigm that treats random access patterns as sparse bipartite graphs, enabling collision signals to be decoded through successive interference cancellation.
• CRA employs repetition-based and component-code schemes that iteratively recover packets, lifting throughput from 1/e to nearly one packet per slot in advanced designs.
• Physical-layer enhancements such as massive MIMO, compressive sensing, and non-orthogonal transmissions further improve CRA by enabling robust signal recovery in complex interference environments.

Coded Random Access (CRA) is a design paradigm for random-access protocols in which the access pattern itself is treated as a code on a graph and collisions are exploited through successive interference cancellation (SIC) rather than discarded. In contrast to legacy ALOHA-style collision models, CRA stores collision slots, uses replicas or coded segments placed across slots according to designed degree distributions, and decodes iteratively on a bipartite graph analogous to decoding over the binary erasure channel (Paolini et al., 2014). The paradigm includes repetition-based schemes such as CRDSA and IRSA, packet-segmentation and component-code schemes such as CSA, and refinements such as Shifted Coded Slotted ALOHA (SCSA), where time shifts and zigzag decoding exploit partial overlaps at word level (Emoto et al., 2018).

1. From collision channels to coded access graphs

Classical ALOHA and Slotted ALOHA assume that a slot containing two or more packets is useless. In the collision channel without feedback adopted in foundational CRA work, the receiver classifies a slot as idle, singleton, or collision; singleton packets are always decoded correctly; and SIC is assumed ideal (Paolini et al., 2014). Under this model, the well-known asymptotic maximum throughput of slotted ALOHA is $T_{\max} = 1/e \approx 0.37$ packets/slot, which makes the protocol structurally inadequate for massive uncoordinated access.

CRA changes the interpretation of a collision. If a receiver stores the received signal in collision slots and can reconstruct and subtract already decoded packets, then a collision becomes a structured observation rather than a pure loss. This is the key step from classical random access to a coding-theoretic design space: users choose multiple transmission opportunities according to a prescribed random law, the induced access pattern forms a sparse bipartite graph, and SIC implements iterative graph decoding (Paolini et al., 2014).

This coding viewpoint explains why CRA is not a single protocol but a family. Repetition-based schemes use simple replicas; higher-rate schemes encode packet segments with short component codes; frameless schemes adapt the contention duration; spatially coupled schemes replicate across coupled contention periods; and physical-layer-enhanced variants replace the ideal collision channel abstraction with richer multiuser detection or modulation structures. A common misconception is that CRA merely means “sending duplicates.” In the broader literature, repetition is only the simplest local code; the central object is the graph-induced code on user-to-resource incidences.

2. Core system model and graph representation

In basic coded slotted ALOHA, a contention period is organized into a frame of $M$ slots. Out of a population of $N$ users, only a subset $N_{\mathsf a}$ is active in a frame. Each active user chooses a repetition rate $d$ according to a user-degree distribution

$\Lambda(x) = \sum_d \Lambda_d x^d,$

and places its $d$ replicas in uniformly random distinct slots among the $M$ slots (Paolini et al., 2014). The corresponding load quantities are

$$G = \frac{\bar N_{\mathsf a}}{M}, \qquad G_{\mathsf{phy}} = G \cdot \bar d, \qquad \bar d = \sum_d d \Lambda_d,$$

with repetition-based CSA rate

$R = \frac{1}{\bar d}.$

Here $M$0 is the logical load, whereas $M$1 counts all replicas.

The access structure is represented by a bipartite graph. User nodes correspond to active users; slot nodes correspond to slots; an edge connects a user node to a slot node when a replica is placed in that slot. The user-node degree equals the number of replicas or coded segments transmitted by that user, and the slot-node degree equals the number of users colliding in the slot. This is structurally identical to Tanner graphs used for LDPC, LT, and LDGM codes, and it is the basis for density-evolution and EXIT-chart analyses of CRA (Paolini et al., 2014).

High-rate CSA generalizes repetition by splitting a packet into $M$2 segments and encoding them with a local $M$3 linear block code before scattering the $M$4 encoded segments across $M$5 segment slots. In the SCSA model, each slot is further divided into $M$6 slices, a user splits its packet into $M$7 data segments of length $M$8 words, encodes them with a local code $M$9, and transmits the resulting encoded segments in randomly selected slices (Emoto et al., 2018). This generalization is what links CRA to doubly generalized LDPC constructions: user nodes impose local code constraints rather than mere repetition.

3. Iterative decoding, SIC, and threshold behavior

The canonical CRA receiver performs a peeling-like iterative procedure. In repetition-based CSA, the receiver first finds singleton slot nodes, decodes the corresponding packets, uses replica-location information embedded in the packet to identify all other slots containing replicas of the same user, subtracts those waveforms from the stored collision slots, and repeats the process until no further singleton slot emerges (Paolini et al., 2014). On the graph, this is exactly iterative erasure decoding: unknown user nodes become known when attached to degree-1 slot nodes, and SIC removes their edges.

For high-rate CSA, the same logic is augmented by local erasure decoding at user nodes. A user packet is split into $N$0 segments, encoded into $N$1 coded segments, and some of these coded segments may be recovered directly from singleton segment slots. The receiver then applies MAP erasure decoding of the chosen component code $N$2 to infer additional erased segments, after which SIC is performed on the segment slots (Emoto et al., 2018). The decoding schedule therefore alternates between user-node decoding and slot-node interference cancellation.

In the large-system limit $N$3, $N$4 with fixed $N$5, CRA exhibits threshold behavior. There exists a threshold $N$6 such that, for $N$7, almost all active users are recovered with high probability, whereas for $N$8, a non-zero unresolved fraction remains (Paolini et al., 2014). For repetition-based CSA with rate $N$9, an upper bound on the threshold is given by the positive solution of

$N_{\mathsf a}$0

This relation is one of the reasons CRA is routinely analyzed with the same asymptotic tools used for sparse-graph codes.

The protocol family then differentiates itself by how it improves the threshold or the finite-length waterfall. Simple degree-2 repetition already lifts asymptotic throughput from $N_{\mathsf a}$1 to about $N_{\mathsf a}$2 packets/slot, while more advanced irregular or high-rate designs can approach $N_{\mathsf a}$3 packet/slot in the collision-channel model (Paolini et al., 2014). Spatially coupled CSA transfers the spatial-coupling idea from LDPC coding: early low-load contention periods seed a decoding wave, and the iterative threshold reaches the MAP threshold of the uncoupled block scheme (Paolini et al., 2014). Frameless CSA imports the rateless-coding viewpoint: users decide slot by slot whether to transmit, while the base station stops contention adaptively when throughput or recovery fraction reaches a target (Paolini et al., 2014).

4. Major protocol families and representative variants

IRSA is the repetition-only branch of CRA: each user repeats its packet a random number of times according to $N_{\mathsf a}$4, and SIC proceeds slot by slot. CSA generalizes IRSA by replacing repetition with short component codes over packet segments. From the coding viewpoint, IRSA corresponds to irregular repetition, whereas CSA corresponds to a higher-rate generalized sparse-graph ensemble (Paolini et al., 2014).

SCSA is a representative refinement because it enriches the local-code CRA model with a time-shift dimension. In SCSA, a frame has duration $N_{\mathsf a}$5, each frame contains $N_{\mathsf a}$6 slots of duration $N_{\mathsf a}$7, and each slot is divided into $N_{\mathsf a}$8 slices of duration $N_{\mathsf a}$9. Time shifting is performed word-wise: a shift of $d$0 delays a segment by $d$1 words within its slice. The shift amount is drawn from

$d$2

with the numerical examples using the uniform distribution

$d$3

Decoding has two phases: a CSA-like segment-level phase, followed by a word-level zigzag phase that exploits partly clean slices created by different shifts. In the reported simulations with $d$4, $d$5, $d$6 and $d$7, and $d$8, both PLR and SLR decrease monotonically as $d$9 increases, while the peak throughput also increases (Emoto et al., 2018).

The asynchronous literature uses a different but related naming convention. There, CRA can denote Contention Resolution ALOHA, the asynchronous counterpart of CRDSA, where frames are not slotted internally, packets are transmitted as multiple burst copies in continuous time, and interference cancellation exploits partial overlaps (Meloni et al., 2015). Enhanced CRA (ECRA) further combines the least-interfered portions of different replicas into a synthetic packet; the reported throughput increment over CRA is about $\Lambda(x) = \sum_d \Lambda_d x^d,$0 under Shannon-bound decoding and about $\Lambda(x) = \sum_d \Lambda_d x^d,$1 under the random coding bound in the simulated scenarios (Clazzer et al., 2012). This terminological bifurcation is historically important: “CRA” may refer either to the broad coded-random-access paradigm or to the specific asynchronous Contention Resolution ALOHA lineage.

5. Physical-layer enrichments and joint PHY–MAC designs

A major development in CRA has been the replacement of the ideal collision channel with structured physical-layer models. One line combines frameless ALOHA with compressive-sensing multi-user detection (CS-MUD): packets are spread with user-specific signatures, slot observations become underdetermined sparse linear systems, and capture probabilities are characterized numerically and then embedded into and-or tree analysis (Ji et al., 2014). A related line uses non-orthogonal spreading and power-domain NOMA, forming layered CRA with Gaussian spreading and variational or MAP-style activity detection (Choi, 2018).

Massive MIMO has become a particularly influential CRA substrate. In framed grant-free uplink with many antennas, users randomly choose pilots in each slot, and the base station combines pilot-based channel estimates with SIC across replicas. Joint PHY–MAC density evolution has been developed for such systems, so that slot-node update rules incorporate fading, pilot collisions, BCH decoding, and realistic interference rather than a binary collision abstraction (Valentini et al., 2022). Subsequent work analyzed how imperfect channel estimation degrades SIC and proposed payload-aided subtraction algorithms that explicitly re-estimate replica channels from decoded payloads (Valentini et al., 2022). Further enhancements introduced pilot mixtures and a nested inner/outer SIC architecture, where intra-slot SIC across orthogonal pilot components feeds the outer cross-slot CRA decoder (Valentini et al., 2023). Signal-processing refinements of this kind were later shown to materially affect the overall CRA operating region in grant-free massive-MIMO systems (Valentini et al., 2023).

Other recent extensions move CRA into new propagation and modulation regimes. In doubly selective channels, Zak-OTFS-based CRA replaces OFDM so that the effective delay–Doppler channel remains predictable across slots, which stabilizes inter-slot SIC; the reported simulations over the Veh-A channel show significantly lower packet loss rates than an OFDM-based CRA baseline under high mobility and user density (Mirri et al., 29 Jul 2025). In near-field communications with extremely large aperture arrays, CRA has been reformulated as coded spatial random access, where the coded resources are near-field communication modes rather than only time slots or frequency channels (Testi et al., 21 Aug 2025). These developments show that the graph/SIC principle is robust, but the physical-layer realization is increasingly protocol-defining.

6. Metrics, applications, limitations, and theoretical frontiers

CRA is primarily motivated by machine-to-machine communications, IoT, and grant-free uplink access, where device populations are very large, activity is sporadic, packets are short, and the overhead of grant-based scheduling is disproportionately expensive (Paolini et al., 2014). Standard performance metrics are the logical load $\Lambda(x) = \sum_d \Lambda_d x^d,$2, packet or segment loss rate, throughput, and delay. In SCSA, for example, the paper defines

$\Lambda(x) = \sum_d \Lambda_d x^d,$3

and

$\Lambda(x) = \sum_d \Lambda_d x^d,$4

with the load normalized to include shift-padding and control overhead (Emoto et al., 2018).

The principal limitations are also well established. Much of the analytical CRA literature assumes ideal SIC, perfect slot-state discrimination, and often perfect channel estimation. Under practical fading channels, residual interference, channel-estimation errors, and pilot collisions change the effective slot-decoding law and may invalidate collision-channel-optimized degree distributions (Valentini et al., 2022). Other recurring issues are estimation of the active-user population, downlink feedback timing in frameless operation, synchronization requirements, and the memory and processing burden of repeated SIC at the base station (Paolini et al., 2014).

An information-theoretic frontier recasts CRA as a random access channel (RAC) with an unknown number of active transmitters. In that model, neither transmitters nor receiver know the active set a priori, all active users use the same encoder, and the receiver adapts decoding time to the estimated number of active users using scheduled single-bit feedback. The main achievability result shows that, for each active-user count $\Lambda(x) = \sum_d \Lambda_d x^d,$5,

$\Lambda(x) = \sum_d \Lambda_d x^d,$6

so the random-access scheme achieves the same first-order term and dispersion as a MAC with known $\Lambda(x) = \sum_d \Lambda_d x^d,$7 (Yavas et al., 2018). This suggests that CRA is not only a graph-based MAC design methodology but also a finite-blocklength multiuser coding problem.

A neighboring frontier is unsourced random access, where the receiver recovers a list of messages rather than user identities. In coded compressed sensing for URA, replacing the outer tree code with list-recoverable codes that correct $\Lambda(x) = \sum_d \Lambda_d x^d,$8 errors improves performance by $\Lambda(x) = \sum_d \Lambda_d x^d,$9–$d$0 dB over the tree-code-based scheme in the reported quasi-static Rayleigh fading experiments (Andreev et al., 2022). Although this line is usually presented under the unsourced-access label, it continues the central CRA theme: encode the access process itself, exploit sparsity or algebraic structure in collisions, and shift the design problem from collision avoidance to structured multiuser decoding.