Papers for

network protocol designers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Asynchronous message passing gains reversible computation properties

On Asynchrony and Reversibility in CCS

Abstract: Asynchronous communication is a fundamental feature of modern distributed systems, where messages are emitted without requiring immediate synchronization with receivers. In process calculi, this behaviour is typically modelled by separating message emission from message consumption. At the same time, reversible computation has emerged as an important paradigm for analysing concurrent systems, enabling computations to be undone while preserving causal dependencies between actions. While reversible semantics have been extensively studied for synchronous process calculi such as CCS, their integration with asynchronous communication remains largely unexplored. In this paper we investigate the interaction between asynchrony and reversibility in the setting of CCS. We first introduce CCSa, an asynchronous variant of CCS in which output actions generate explicit message entities that can later be consumed by matching input actions. We then define rCCSa, a reversible extension of CCSa obtained by adapting the framework of Phillips and Ulidowski. In rCCSa, prefixes and messages are annotated with unique keys that record message emission and consumption events, allowing computations to be reversed while preserving causal dependencies. We show that the resulting reversible semantics satisfies causal consistency, ensuring that computations can be reversed exactly up to causal equivalence. The proof relies on the axiomatic framework for reversible computation proposed by Lanese et al.

Mon 28 SeptLogic in Computer ScienceFormal Languages and Automata TheoryProgramming Languages
The gist
Modern distributed computer systems send messages without waiting for receivers to be ready, which is called asynchronous communication. The authors look at a way to reverse these message actions so that you can undo steps in a process without breaking important cause-and-effect links. They created a new version of a process algebra called CCS that models asynchronous messaging and then extended it to be reversible while keeping track of message events. Their work ensures that reversing actions respects the original order and dependencies of messages, which is helpful for analyzing and debugging distributed software.
Open → 2609.34925v1

Distributed graph problems need longer randomized algorithms

Distributed Lower Bounds via Automatic Self-Reduction

Abstract: The development of round elimination into a general-purpose technique [PODC 2019] marked a turning point in our understanding of the hardness of many graph problems in the distributed setting and led to several breakthrough results. However, the round elimination technique seems unable to yield randomized lower bounds of $ω(\log \log n)$ rounds as a function of the number $n$ of nodes. Very recently, Khoury and Schild [FOCS 2025] introduced a new technique called round elimination via self-reduction, which bypasses the limitations of classical round elimination. Using this approach, the authors show that any randomized algorithm for maximal matching requires $Ω(\sqrt{\log n})$ rounds in the LOCAL model. Their elegant technique is, in some respects, similar to classical round elimination while being fundamentally different in others. However, it is tailored specifically to maximal matching rather than being applicable to a broad class of problems. In this paper, we show that self-reduction is, in fact, a special case of classical round elimination, thereby turning it into a general-purpose approach. In particular, we introduce a new way to measure the error of an algorithm and show that, under this new measure, classical round elimination can indeed yield $ω(\log \log n)$ randomized lower bounds. More specifically, we identify a large class of problems for which this improvement is entirely black-box: once a problem is shown to belong to the class, stronger randomized lower bounds follow automatically from the classical round-elimination framework. As an application, we prove $Ω(\sqrt{\log n})$ randomized lower bounds for a range of graph problems, namely, maximal matching on regular $2$-colored graphs, $\frac{1}{k}$-integral matching, and maximal $H$-packing.

Mon 28 SeptDistributed, Parallel, and Cluster ComputingData Structures and Algorithms
The gist
The authors focused on proving that certain problems in distributed computing need more time to solve when computers work randomly. They showed that a classic technique to explain hard problems, called round elimination, can actually be used in a broader way than before. By changing how errors in algorithms are measured, they found stronger limits on how fast distributed algorithms can run. This means many graph problems, like finding matchings, require at least about the square root of the logarithm of the network size in communication rounds.
Open → 2609.34753v1

Bounded decoders improve error and erasure estimates in short block communication

Block Erasure Channel and Block z-Channel with Bounded Decoders and Finite Blocklength

Abstract: Block error rate is a standard metric in finite blocklength (FBL) communication, yet it conflates two qualitatively different failure modes: block confusions, where the decoder selects a wrong codeword, and block erasures, where it declares a loss. Higher-layer protocols treat physical-layer failures as erasures, but this cross-layer assumption lacks FBL justification. We derive a rigorous upper bound and a companion lower-side estimate on the block confusion probability (BLCP) and block erasure probability (BLEP) for bounded-distance decoders over additive white Gaussian noise (AWGN) channels at finite blocklength, recasting the coding problem as a geometric sphere packing one. We analyze the sensitivity of these bounds to blocklength and signalto-noise ratio, characterize the envelope of the upper bound, and derive closed-form Chernoff approximations. Extending the model to idle transmission blocks, we bound the false alarm probability (FAP) and show that a block z-channel abstraction emerges from the bounded-decoding geometry. Numerical results confirm that confusion and false alarm probabilities lie far below the error rate constraint, providing quantitative physicallayer support for the block erasure channel and block z-channel abstractions assumed in protocol design.

Wed 23 SeptInformation Theory
The gist
Communicating data in short chunks can lead to different types of problems: sometimes the receiver gets confused and picks the wrong message, and sometimes it just gives up and says it lost the message. The authors show that these two failure types can be separated and accurately bounded using a geometric approach, instead of lumping them together. This helps provide real mathematical support for treating lost messages as erasures in communication protocols. They also explore how often the system mistakenly believes an idle message was sent, which leads to a new simple channel model useful for designing reliable communication systems.
Open → 2609.27519v1

Binary deletion channel capacity approximated within one hundredth bit

Binary Deletion Channel Capacity to Within One Hundredth of a Bit

Abstract: The exact capacity of the binary deletion channel remains unknown despite decades of work on achievable rates and converse bounds. We establish a computer-assisted approximation whose error is below $0.0095$ bits per transmitted bit, uniformly over all deletion probabilities. The mean certified error bound, with uniform weighting of deletion probability, is below $0.006522$. The estimate is the midpoint of explicit lower and upper bounds. For the converse, a stationary-source reduction is combined with finite inequalities covering every allowed input configuration. Two constructions control the unobserved input beyond a finite window: one uses a common outside survivor sequence and bounds omitted deletion patterns, while the other cancels an entropy term to make outside probabilities enter linearly. For the lower bound, finite-state inputs combine output-entropy estimates with selected disjoint counts of compatible deletion masks; independent-run inputs retain additional uncertainty about output-run boundaries. Directed numerical checks establish the finite inequalities. An analytic comparison between deletion probabilities then extends the pointwise bounds over the entire parameter range. The lower endpoint supplies rates within $0.019$ bits of capacity in the asymptotic coding sense. We give the derivations, recorded computational costs, and complete numerical inputs and programs needed to verify the result.

Wed 16 SeptInformation Theory
The gist
Communicating over a channel where some bits get randomly deleted is a hard problem, and exactly how much information you can send without errors is unknown. The authors provide a highly accurate estimate of this maximum reliable rate, called the capacity, with an error smaller than one hundredth of a bit per bit sent. They use computer-assisted proofs combining clever mathematical bounds and numerical checks over every possible deletion probability. Their approach also includes complete computational details and code so others can verify or build on their work.
Open → 2609.19412v1

New framework links memory and query costs in matrix data structures

Systematic Data Structure Lower Bounds via the Query-with-Sketch Model

Abstract: We study data structure lower bounds for the Approximate Matrix Powering (AMP) problem. Given a substochastic, symmetric matrix $\mathbf{M}\in\mathbb{R}^{n\times n}$ and parameters $k$ and $α$, the goal is to preprocess $\mathbf{M}$ so as to answer entry queries $(u,v)\mapsto \mathbf{M}^{k}[u,v]$ up to additive error $1/n^α$. We focus on AMP in the succinct and systematic regime, in which the data structure stores $\mathbf{M}$ verbatim, uses an additional $r$ bits of redundancy, and must answer queries by probing only a small number of entries of $\mathbf{M}$. Our main conceptual contribution is a general framework for proving probe--redundancy trade-offs for systematic data structures. We introduce the query-with-sketch model and develop a min-entropy-based approach that lifts conditional min-entropy bounds in the absence of redundancy to probe lower bounds in the presence of redundancy. We then establish these min-entropy bounds using problem-specific analytic and algebraic tools, for the downstream applications to AMP and its variants. As a consequence, our results provide new unconditional evidence toward a conjecture of Patrascu and Roditty (2010) on the space required for constant-time set-disjointness queries.

Wed 16 SeptData Structures and AlgorithmsComputational Complexity
The gist
This paper looks at how computers store and quickly access information from a special kind of table called a matrix. The authors study how much extra memory and how many checks to memory spots are needed to answer certain questions about the matrix after some preparation. They introduce a new model that helps prove limits on these trade-offs, showing when it’s impossible to have both very little extra memory and very fast answers. Their findings also provide evidence supporting a longstanding idea about how much space certain data tasks require.
Open → 2609.18024v1

Price of anarchy grows with network size in max-distance games

The price of anarchy in the max-distance network creation game is not constant

Abstract: At edge price $α=1$, we construct an infinite family of pure Nash equilibria of the unilateral max-distance network creation game with $\PoA\ge2^{\sqrt{\log_2 n}-O(\log\log n)}$. Together with the known upper bound, this gives $2^{Θ(\sqrt{\log n})}$ along the constructed sequence of population sizes. We subdivide every edge of the bipartite double cover of a distance-uniform graph with large diameter constructed by Lavrov, Loh and Messegué, and let each subdivision vertex buy its two incident edges. A distance calculation rules out every profitable unilateral deviation. The equilibria are not strict. We also give a short proof that the price of anarchy is constant for every polynomially vanishing edge price.

Tue 15 SeptComputer Science and Game TheoryDiscrete Mathematics
The gist
This work studies how inefficient networks can become when individuals create connections selfishly, focusing on a game where players try to minimize their longest distance to others. The authors found that, contrary to some hopes, the inefficiency can grow quite fast as the network gets larger when the cost to add an edge is exactly one. They built specific network examples to show this large inefficiency, and also showed that when edge costs shrink fast enough, the inefficiency remains bounded. This helps to better understand how selfish behavior influences network quality in such settings.
Open → 2609.17395v1

Semantic aware error recovery improves AI data movement latency

SAGE: Semantic-Aware Geographic Error Recovery for AI Data Movement

Abstract: AI interconnects typically protect and replay packets uniformly, yet numerical bit faults differ sharply in consequence: a low-order mantissa flip may resemble quantization noise, while a high-significance exponent flip can produce a catastrophic outlier or non-finite value. We present SAGE, a semantic-aware geographic error-recovery architecture that decouples whether a detected fault merits replay from where replay restarts. For BF16-like data, a workload-calibrated contract separates catastrophic Class-H faults from bounded Class-M and precision Class-L damage. It first applies a Class-H silent-delivery constraint, then ranks admissible policies by quality-normalized terminal latency, $Ψ_{\rm del}$. Independently, a source-local region table adapts checkpoint intervals to fault geography, shortening recovery segments in noisy regions. Detected Class-H failures may trigger protected negative acknowledgments and full-flit replay; Class-M and Class-L outcomes do not trigger default network replay. We implement SAGE's endpoint and replay protocol in gem5 Garnet and synthesize its fully pipelined checker in ASAP7. At a stable synthetic operating point, a ten-seed contention-faithful direct-Garnet campaign shows that SAGE reduces $Ψ_{\rm del}$ by 30.1% relative to fixed 34-hop recovery, combining 28.0% lower mean latency with improved delivered semantic quality. Under higher-BER synthetic stress at the same offered load, SAGE maintains bounded queues while the fixed baseline accumulates backlog. Application-derived DeiT-S communication traces also show lower mean and p99.5 latency at the evaluated nonzero BERs. Within the qualified operating envelope, CRC32 decoder trials yield a simultaneous 95% per-original Class-H silent-delivery upper bound of $3.18\times10^{-7}$.

Wed 9 SeptHardware Architecture
The gist
Data errors happen during AI communication, but not all errors are equally serious. The authors developed SAGE, a method that recognizes which errors matter most and fixes only those, speeding up recovery. SAGE also adapts to where errors occur, making the whole system faster and more reliable. This approach reduces delays and keeps AI data quality higher during movement.
Open → 2609.10126v1