byzantine fault tolerance

Consensus protocols often lack accountability guarantees for liveness—i.e., the ability to uniquely identify and provably attribute liveness violations to a majority of malicious nodes. Method: We formally define *liveness accountability*: when liveness fails, at least a strict majority of Byzantine nodes must be uniquely identifiable and provably culpable. To capture realistic network uncertainty, we introduce the *x-partial synchrony* model, which unifies asynchronous and synchronous behaviors via a tunable parameter *x*. Within this model, we rigorously characterize the necessary and sufficient conditions for accountable liveness: *x < 1/2* and *f < n/2*, where *f* is the number of Byzantine nodes and *n* the total number of nodes—thereby establishing its fundamental feasibility boundary. Contribution/Results: We design a near-optimal protocol achieving asymptotically optimal culpable-node identification. Our work provides the first formal foundation and optimality proof for mechanisms such as Ethereum’s “inactivity leak,” bridging theory and practice in accountable consensus.

This work addresses safety and liveness risks arising from the interplay between global protocols and locally optimized specifications in asynchronous multiparty session types. We propose the first precise and practical theoretical framework for asynchronous multirole session types. Our approach introduces a rigorously defined asynchronous multirole subtyping relation and formally establishes, for the first time, an asynchronous correspondence between global protocols and their local projections. We mechanically verify in Coq and Isabelle the soundness and completeness of this correspondence. Crucially, this correspondence serves as a system-level invariant: it guarantees type safety, deadlock freedom, and liveness—even when distributed components are developed independently and their actions are asynchronously reordered. The framework thus provides a foundational basis for compositional verification of asynchronous distributed systems.

Formal verification of liveness in Byzantine Fault-Tolerant (BFT) distributed systems remains challenging due to the difficulty of rigorously modeling adversarial behavior, cryptographic primitives, and progress guarantees. Method: This paper introduces three novel, modular techniques grounded in formal verification: (i) compositional proof support for sub-protocol separation; (ii) precise semantic modeling of cryptographic signatures; and (iii) joint verification of liveness and safety properties. The framework is deeply integrated into an executable Go implementation of Practical Byzantine Fault Tolerance (PBFT). Contribution/Results: It achieves the first end-to-end formal liveness verification of a single-log PBFT consensus protocol. Experimental evaluation confirms that the prototype strictly guarantees both progress and correctness under normal operation and diverse malicious fault scenarios. This work establishes the first practical, formally verified path to liveness assurance in BFT systems.

Traditional Byzantine fault-tolerant (BFT) protocols for large-scale distributed systems suffer from high communication overhead, reliance on expensive digital signatures, and poor scalability. Method: This paper proposes a signature-free randomized BFT framework built upon a hierarchical witness committee and randomized sampling, enabling lightweight signature-free verification and probabilistic consistency guarantees. Contribution/Results: For the first time under a constant-fraction adversarial model (f < αn, α < 1/3), the framework achieves near-constant-round complexity and O(log n) per-node communication and computation cost for core primitives—including consensus, reliable broadcast, aggregation, and public random beacon generation. Its precomputation architecture breaks the conventional quorum-based bottleneck, supporting high-frequency execution and sharding-based scalability. This work establishes a new paradigm for scalable, low-overhead, and cryptography-light BFT systems.

This study addresses the realizability of global distributed protocols under asynchronous network architectures—specifically, whether local implementations can satisfy global specifications. To this end, the work introduces a network-parameterized coherence condition, combined with operational axioms that characterize message buffering behavior, enabling a unified formal model of five prominent asynchronous network paradigms. Leveraging symbolic algorithms and formal verification techniques, the paper establishes—for the first time—a systematic relationship between network architecture parameters and protocol realizability, and derives optimal complexity bounds. The accompanying tool, Sprout(A), is the first realizability verifier supporting multiple network architectures, achieving both high performance and modularity without sacrificing generality.

This work addresses the state explosion problem inherent in asynchronous, parameterized distributed protocols, which arises from communication asynchrony and unbounded participant counts. The authors propose an automated safety verification method based on backward unreachableness analysis. Their key innovation lies in distinguishing parameterized unboundedness into affine and non-affine categories, focusing specifically on affine protocols. By integrating goal-directed instantiation, causal reasoning, and state summarization, the approach efficiently prunes the state space. The prototype tool DissProve successfully verifies multiple affine protocols featuring infinitely many participants and unbounded execution lengths, achieving—for the first time—scalable, fully automatic safety verification for such asynchronous parameterized systems.

This work resolves the theoretical tension between the feasibility of deterministic crash-tolerant consensus in fully asynchronous settings and the FLP impossibility result. By constructing a rigorous formal framework, it demonstrates that the apparent contradiction between Attia et al.’s conclusions and alternative claims of consensus possibility stems from differing assumptions about the semantics of protocol rounds. Building on this insight, the paper introduces a novel multi-crash-tolerant consensus algorithm. It provides the first formal proof that bridges a critical gap in asynchronous consensus theory, establishing the theoretical feasibility of achieving deterministic consensus tolerating multiple crashes within a fully asynchronous model, accompanied by a complete correctness proof of the proposed algorithm.

Existing swarm protocols lack compositionality, hindering modular development and code reuse in large-scale, complex systems. This work proposes a compositional approach grounded in a local-first, asynchronous communication model, establishing the first theoretical framework for compositional swarm protocols that enables independent component design, formal specification, and correct integration. By integrating formal methods, asynchronous event propagation, and local-first computation paradigms, the authors develop a verifiable protocol composition technique accompanied by an automated toolchain. This ensures that verified components retain global system correctness upon integration, substantially enhancing both development efficiency and system reliability.

Traditional typestate systems struggle to capture quantitative constraints—such as quorum requirements—and concurrent I/O behaviors inherent in distributed protocols, and they lack resilience to runtime network failures. This work proposes a probabilistic runtime verification approach that integrates mutable internal state, hybrid session mechanisms, and expected action ratios into an extended typestate model. The resulting framework enables dynamic modeling and monitoring of critical properties like concurrent message exchange and quorum satisfaction. Evaluated on commit and voting-based consensus protocols, the method effectively detects runtime behavioral deviations, significantly enhancing the expressiveness and practical applicability of typestate reasoning in distributed systems.