Iterated Collect Model in Distributed Computing

• The iterated collect model is an asynchronous, wait-free shared-memory system where processes write to designated registers and asynchronously collect views round by round.
• It enables bounded registers to simulate full-information protocols by employing optimal encoding schemes to distinguish process states.
• The model exhibits a clear space-time trade-off, with round complexity scaling factorially and exponentially based on process count and bit limitations.

Searching arXiv for the primary paper and closely related distributed-computing context. The iterated collect model is an asynchronous, wait-free iterated shared-memory model in which computation proceeds in rounds over a stack of memory layers, each layer being an array of $n$ single-writer/multi-reader registers, one per process. In each round, every correct process writes to its own register in the current layer and then collects the layer by asynchronously reading all $n$ registers, one by one, in any order, thereby obtaining a view of the values written by any subset of the processes that wrote before it accessed their registers. In the context of bounded-memory simulations of full-information protocols, the model is notable because bounded $b$-bit registers can implement $r$ rounds of unbounded full-information with round complexity $\Theta((n!)^{r-1}\cdot 2^{n-b})$, preserving solvability up to isomorphism in the sense of the asynchronous computability theorem (Toyos-Marfurt et al., 16 Sep 2025).

1. Definition and execution semantics

Iterated collect is the simplest read-write access pattern in the family of iterated shared-memory models studied in "Space-Time Trade-off in Bounded Iterated Memory" (Toyos-Marfurt et al., 16 Sep 2025). Computation proceeds in rounds over a stack of memory layers; each layer is an array of $n$ single-writer/multi-reader registers, one per process. In each round $r$, every correct process writes to its own register in the current layer and then collects the layer by asynchronously reading all $n$ registers, one by one, in any order.

The model is asynchronous and wait-free: each non-faulty process must complete in a finite number of its own steps regardless of other processes’ speeds. The failure model is crash failures: processes may stop taking steps at arbitrary times. A collect therefore returns a view shaped by the interleaving of writes and reads, rather than by a single atomic read event. More precisely, a process obtains a view of the values written by any subset of the processes that wrote before it accessed their registers.

The paper formalizes bounded iterated algorithms through a generic structure called ITER. Shared memory is an array $M[R,|\Pi|]$ of $R$ layers, each an array of $n$0 SWMR entries initialized to $n$1. A process starts from a local state $n$2, and for rounds $n$3 performs a write of $n$4 into $n$5, reads all entries in $n$6 by collect, and updates its state via $n$7. The final decision is $n$8 (Toyos-Marfurt et al., 16 Sep 2025).

2. Position within iterated shared-memory models

The iterated collect model differs from snapshot-based iterated models in the strength of the read primitive. The comparison in the paper is explicit.

Model	Read primitive	Structural note
IAS	Atomic snapshot	Returns a single, instantaneous view of all $n$9 registers
IIS	Immediate snapshot	Write and snapshot are executed together as a single immediate operation
IC	Collect	A process reads registers one by one; views reflect the interleaving of writes and reads

For iterated atomic snapshot (IAS), reads are atomic snapshots that return a single, instantaneous view of all $b$0 registers. For iterated immediate snapshot (IIS), write and snapshot are executed together as a single immediate operation; the protocol complex is exactly the standard chromatic subdivision. For iterated collect (IC), a process reads registers one by one; views reflect the interleaving of writes and reads and include strictly more configurations than snapshots (Toyos-Marfurt et al., 16 Sep 2025).

The inclusion relation shown in the paper for $b$1 is

$b$2

This places IC as strictly richer than the snapshot-based variants at the level of reachable configurations. A plausible implication is that IC exposes more scheduling structure in the protocol complex than IAS or IIS, even though the bounded full-information construction ultimately shows that stronger read atomics do not asymptotically improve the lower bound.

3. Full-information protocols and protocol-complex structure

In the unbounded full-information protocol based on iterated collect, denoted FIIC, processes write their entire current local knowledge in every round, and update it to their read view; the state size grows round by round (Toyos-Marfurt et al., 16 Sep 2025). The reachable global configurations of a protocol from an input complex $b$3 are captured by a protocol map

$b$4

where $b$5 is a simplicial complex of process-labeled vertices, called the protocol complex.

A bounded protocol simulates the unbounded one “up to isomorphism” when $b$6 has the same simplicial complex structure as $b$7: there is a bijection between vertices that preserves colors and maps simplices to simplices. The set of reachable states and their adjacency relationships therefore coincide, so the same decision map $b$8 can be used, in the sense of ACT.

Two structural properties of full-information protocol maps are used repeatedly. The first is mesh-shrinking:

$b$9

No original input edge survives into the next-round protocol complex. The second is intersection preservation:

$r$0

for subcomplexes $r$1. The paper states that these properties play the role of an intersection-preserving property of subdivisions and are crucial in the distinguishability arguments (Toyos-Marfurt et al., 16 Sep 2025).

4. Bounded encodings and distinguishability

Bounded-memory simulation cannot write the entire local state in a register. Instead, a process writes an encoding $r$2 using at most $r$3 distinct non-$r$4 values per round. The central notion is distinguishability of vertices and faces in the input complex (Toyos-Marfurt et al., 16 Sep 2025).

Given an encoding $r$5, a colored vertex $r$6 is distinguishable if no neighbor $r$7 of $r$8 has a neighbor $r$9 of the same color as $\Theta((n!)^{r-1}\cdot 2^{n-b})$0 with $\Theta((n!)^{r-1}\cdot 2^{n-b})$1. A face $\Theta((n!)^{r-1}\cdot 2^{n-b})$2 is distinguishable if all its vertices are distinguishable under $\Theta((n!)^{r-1}\cdot 2^{n-b})$3. A bounded algorithm $\Theta((n!)^{r-1}\cdot 2^{n-b})$4 is specified by a sequence of round-specific encoding functions $\Theta((n!)^{r-1}\cdot 2^{n-b})$5 and next-state functions $\Theta((n!)^{r-1}\cdot 2^{n-b})$6.

The main necessary condition is Theorem 1 of the paper:

$\Theta((n!)^{r-1}\cdot 2^{n-b})$7

Equivalently, if the distinguishable subcomplex induced by the encoding sequence is defined by

$\Theta((n!)^{r-1}\cdot 2^{n-b})$8

then $\Theta((n!)^{r-1}\cdot 2^{n-b})$9 implies $n$0.

The paper also proves that constructing a shortest sequence of encodings with this property is NP-hard by reduction from Set Cover. With only one-bit encodings, distinguishing stars of vertices corresponds to covering the complex with disjoint stars. This places the synthesis of optimal bounded encodings in a combinatorially hard regime even before the asymptotic bounds are invoked (Toyos-Marfurt et al., 16 Sep 2025).

5. Space-time trade-off and asymptotic lower bounds

The asymptotic lower bound is driven by the degree growth of vertices in the protocol complex and by the per-round distinguishability budget imposed by $n$1-bit registers (Toyos-Marfurt et al., 16 Sep 2025). The degree comparison used in the proof is

$n$2

and the chromatic subdivision degree bound is

$n$3

Combining these facts with the observation that, in one bounded round, a process can differentiate at most $n$4 states of the same color among a vertex’s neighbors yields the main lower bound. For an $n$5-dimensional input complex with $n$6, any bounded algorithm using the same write-read pattern and at most $n$7 bits per process per round that satisfies

$n$8

must perform

$n$9

rounds.

The paper interprets the factors combinatorially. The $r$0 term counts the number of process-order permutations across $r$1 rounds that can produce distinct views around a fixed vertex. The $r$2 term reflects the combinatorics of faces containing the vertex and the central vertices generated in subdivisions. The $r$3-bit bound limits per-round distinguishability to at most $r$4 neighbors per process color, producing the factor $r$5 when solving for the number of rounds.

The sensitivity to $r$6 is explicit. When $r$7, the factor $r$8, so the bound becomes $r$9. When $n$0, the number of rounds grows exponentially in $n$1. The paper gives numerical examples, including $n$2, which yields $n$3 rounds; $n$4, which yields $n$5 rounds; and $n$6, which yields $n$7 rounds (Toyos-Marfurt et al., 16 Sep 2025).

6. Greedy Star construction and optimality in iterated collect

The constructive upper bound for IC is the bounded full-information algorithm Greedy Star (Toyos-Marfurt et al., 16 Sep 2025). Its high-level strategy is to build a sequence of encoding functions that partitions the input complex into vertex-star subcomplexes and makes each partition distinguishable in one or more rounds. A vertex star $n$8 is the subcomplex of all faces containing $n$9.

In each phase, Greedy Star selects a set of pairwise disjoint stars and assigns codes within each star so that encodings are injective per process color inside the star. This guarantees distinguishability and ensures that processes can decode which local states are present in their views. Because $M[R,|\Pi|]$0 bounds the number of distinct codes, each phase may require multiple bounded rounds to cover all facets in the selected stars.

The algorithm initializes the covered subcomplex $M[R,|\Pi|]$1 and the remaining-vertex set $M[R,|\Pi|]$2. It then repeats until $M[R,|\Pi|]$3: start a fresh phase, initialize $M[R,|\Pi|]$4 and $M[R,|\Pi|]$5, scan vertices $M[R,|\Pi|]$6, consider $M[R,|\Pi|]$7, and if $M[R,|\Pi|]$8 does not intersect the already chosen $M[R,|\Pi|]$9 in that phase, add $R$0 to $R$1, add its vertices to $R$2, and define $R$3 on $R$4 so that for each process color $R$5, vertices of color $R$6 in $R$7 receive pairwise distinct codes from $R$8, with $R$9 used elsewhere. After the phase, add $n$00 to $n$01, remove $n$02 from $n$03, append $n$04 to the sequence, and continue.

Correctness relies on the fact that, in rounds where $n$05, a process ignores the layer; otherwise it decodes the view to identify which face is present in the corresponding star and refines its knowledge. By construction, once a face is distinguished in some round, intersection-preservation and mesh-shrinking ensure its corresponding configurations persist across subsequent rounds until termination.

The per-phase bound proved in the paper is

$n$06

From this, together with asymptotic degree growth, the paper derives the tight bound for IC. For an $n$07-dimensional input complex with $n$08 and $n$09, there exists a bounded collect-pattern algorithm $n$10 with at most $n$11 bits per register per round such that

$n$12

Moreover, no bounded IC algorithm can use asymptotically fewer rounds. Theorem 5 further states that Greedy Star using the collect pattern actually simulates the unbounded FIIC protocol up to isomorphism:

$n$13

7. Solvability, special cases, and terminological scope

The connection to ACT is direct. ACT characterizes wait-free task solvability in read-write shared memory assuming unbounded full-information variables. The bounded iterated collect results show that bounded variables have the same computational power up to isomorphism with extra rounds: any task solvable by FIIC in $n$14 iterations is solvable by the bounded algorithm with $n$15 rounds, and the ACT decision map $n$16 is preserved (Toyos-Marfurt et al., 16 Sep 2025).

The snapshot-based models obey the same lower bound

$n$17

and there exists an algorithm performing at most

$n$18

rounds. The paper attributes the extra factor $n$19 to the fact that a single immediate snapshot round can be simulated in $n$20 collect rounds. Thus the collect construction is asymptotically optimal, and the snapshot constructions are within a linear factor $n$21 of optimal.

Several caveats delimit the theory. The results assume wait-freedom and an adversarial asynchronous scheduler, unique identifiers, SWMR memory layers, writes preceding reads in each round, and deterministic local computation of the encoding sequence. The general lower bound is stated for $n$22; for $n$23, the paper states a different regime in which two processes need only $n$24 round, achievable with $n$25-bit registers. The paper also states that if one wants a single bounded round per full-information iteration, then the corresponding bit-complexity lower bound is $n$26.

Outside this distributed-computing meaning, the phrase “Iterated Collect Model” is used in several other papers only as a narrative mapping or as a point of clarification, not as the formal SWMR collect model. "When Models Don't Collapse: On the Consistency of Iterative MLE" frames iterative synthetic-data accumulation and retraining as an “Iterated Collect Model” cycle (Barzilai et al., 25 May 2025). "Iterative Document-level Information Extraction via Imitation Learning" presents IterX as an iterative agent that “collects” templates one at a time (Chen et al., 2022). "From Growing to Looping: A Unified View of Iterative Computation in LLMs" explicitly describes an “Iterated Collect-style approach” for repeatedly reusing a middle computation block (Kapl et al., 18 Feb 2026). By contrast, the graph-theoretic papers "The Iterated Local Model for Social Networks" and "The Iterated Local Model for tournaments" explicitly note that “Iterated Collect Model” is not their term; their formal objects are ILM and ILMT, respectively (Bonato et al., 2019, Bonato et al., 30 Jan 2026).

In the precise distributed-computing sense, however, the iterated collect model denotes the layered collect-based read-write model analyzed in (Toyos-Marfurt et al., 16 Sep 2025). Its central significance is that it admits a complete space-time characterization for bounded simulation of full-information: bounded $n$27-bit registers suffice to recover the unbounded protocol complex up to isomorphism, but only at the cost of $n$28 rounds.