Interconnection network with a shared whiteboard: Impact of (a)synchronicity on computing power

In this work we study the computational power of graph-based models of distributed computing in which each node additionally has access to a global whiteboard. A node can read the contents of the whiteboard and, when activated, can write one message of O(log n) bits on it. When the protocol terminates, each node computes the output based on the final contents of the whiteboard. We consider several scheduling schemes for nodes, providing a strict ordering of their power in terms of the problems which can be solved with exactly one activation per node. The problems used to separate the models are related to Maximal Independent Set, detection of cycles of length 4, and BFS spanning tree constructions.

💡 Research Summary

The paper studies a family of distributed computing models in which each node of a graph‑based network can write a single O(log n)‑bit message on a global shared memory called a whiteboard. After all nodes have written, they must decide the output of a given problem solely from the final whiteboard contents. The authors introduce four variants that differ along two orthogonal dimensions: (i) how nodes become active (simultaneous activation of all nodes in the first round versus free, self‑determined activation) and (ii) when a node’s message is generated (as soon as it becomes active – “asynchronous” – or only when the adversary finally selects it for writing – “synchronous”). The four resulting models are named SimAsync, SimSync, FreeAsync, and FreeSync.

In SimAsync, every node becomes active in the first step and must generate its message while the whiteboard is still empty; the adversary then decides the order in which the messages are written. Consequently, each node’s message can depend only on its local view (its own identifier, neighbor identifiers, and n). This model is the exact one studied in the earlier “referee” work of Becker et al. The authors show that SimAsync can solve very limited tasks such as testing graph degeneracy, but cannot decide elementary properties like the existence of a triangle or whether the diameter is at most three.

SimSync also forces all nodes to become active in the first round, but a node’s message is created immediately before it is written, i.e., after it has observed all previously written messages. The adversary may choose any permutation of the nodes, and the algorithm must succeed for every such ordering. This extra look‑ahead makes SimSync strictly more powerful: it can detect a 4‑cycle (a square) and solve other problems that require a linear amount of information to be accumulated gradually.

FreeAsync relaxes the activation constraint: nodes may decide on their own when to become active, and they generate their message at that moment. The adversary still decides the order of writes, but because nodes can wait to become active until they have observed enough information on the whiteboard, FreeAsync can implement algorithms that need a carefully chosen activation schedule. The paper demonstrates that FreeAsync can construct a BFS spanning tree, a task impossible in SimSync.

FreeSync is the most powerful variant. Nodes freely choose activation times, and they postpone message generation until the adversary actually selects them for writing. Hence a node can base its message on the complete set of previously written messages, giving it full knowledge of the current whiteboard state. The authors prove that any problem solvable in the other three models is also solvable in FreeSync, and that even the BUILD problem—reconstructing the entire adjacency matrix—can be solved in FreeSync for graph families whose description size satisfies log |G| = O(n log n). Lemma 1 formalizes this information‑theoretic bound and shows that the total information that can be stored on the whiteboard (n·O(log n) bits) limits what can be reconstructed.

The paper establishes a strict hierarchy of computational power: SimAsync ⊂ SimSync ⊂ FreeAsync ⊂ FreeSync. Each inclusion is proved by exhibiting a problem that separates the two adjacent models. The separation results rely on adversarial scheduling: algorithms must succeed regardless of the order in which the adversary writes messages, which forces the design of robust protocols.

Beyond the theoretical hierarchy, the work connects to practical scenarios where a central log or shared memory is used for aggregation, such as sensor‑network data collection, blockchain state broadcasting, or distributed databases that rely on a global “whiteboard” for consensus. The models capture the trade‑off between the amount of local information a node can contribute (O(log n) bits) and the timing flexibility of when that contribution can be made. By clarifying how synchrony and activation freedom affect what global properties can be computed, the paper provides a useful framework for designing distributed algorithms under severe communication constraints.