The Buffered pi-Calculus: A Model for Concurrent Languages

Message-passing based concurrent languages are widely used in developing large distributed and coordination systems. This paper presents the buffered $\pi$-calculus — a variant of the $\pi$-calculus where channel names are classified into buffered and unbuffered: communication along buffered channels is asynchronous, and remains synchronous along unbuffered channels. We show that the buffered $\pi$-calculus can be fully simulated in the polyadic $\pi$-calculus with respect to strong bisimulation. In contrast to the $\pi$-calculus which is hard to use in practice, the new language enables easy and clear modeling of practical concurrent languages. We encode two real-world concurrent languages in the buffered $\pi$-calculus: the (core) Go language and the (Core) Erlang. Both encodings are fully abstract with respect to weak bisimulations.

💡 Research Summary

The paper introduces the Buffered π‑Calculus, a variant of the traditional π‑calculus that distinguishes between buffered and unbuffered channels. In this model, communication over buffered channels is asynchronous: a sender places a message into an internal queue and proceeds without waiting for a receiver. Unbuffered channels retain the original synchronous semantics, requiring simultaneous send and receive. This dual‑channel classification mirrors the behavior of real‑world concurrent languages such as Go (where channels may be buffered) and Erlang (where each process has an asynchronous mailbox).

The authors first formalize the syntax and operational semantics of the Buffered π‑Calculus. They model each buffer as an independent process that stores pending messages and supplies them to receivers on demand. By encoding these buffer processes and the asynchronous send/receive actions into polyadic π‑calculus constructs (multi‑argument communication), they prove a strong bisimulation between the Buffered calculus and the polyadic π‑calculus. This result demonstrates that the new calculus does not lose expressive power; any Buffered π‑process can be faithfully simulated by a standard polyadic π‑process, preserving observable behavior under strong equivalence.

Having established the theoretical foundation, the paper proceeds to encode two widely used concurrent languages. For Go, the encoding maps goroutines to independent π‑processes, Go channels to buffered channels, and the select statement to nondeterministic choice over multiple channel actions. The encoding respects Go’s semantics for buffered and unbuffered channels, channel closing, and synchronization primitives. The authors prove that the encoding is fully abstract with respect to weak bisimulation: two Go programs are weakly bisimilar exactly when their Buffered π‑representations are weakly bisimilar.

For Erlang, the encoding treats each Erlang process as a π‑process, the process mailbox as a buffered channel, and message sending as asynchronous output on that channel. Pattern matching on received messages is captured by the matching capabilities of the π‑calculus. Again, a full abstraction result is shown: Erlang programs are weakly bisimilar iff their Buffered π‑encodings are weakly bisimilar.

The paper highlights several practical advantages of the Buffered π‑Calculus. By making the asynchronous nature of communication explicit at the language level, it simplifies reasoning about concurrency, reduces the need for auxiliary encoding tricks that plague standard π‑calculi, and aligns more closely with programmer intuition in languages like Go and Erlang. The clear separation of buffered versus unbuffered channels also aids static analysis, model checking, and verification tools, because the presence of a buffer can be treated as a distinct resource with its own invariants.

In summary, the Buffered π‑Calculus offers a mathematically rigorous yet practically oriented framework for modeling modern message‑passing languages. It retains the compositional and algebraic strengths of the π‑calculus while providing a natural representation of asynchronous communication. The strong bisimulation simulation into polyadic π‑calculus and the fully abstract encodings of core Go and Erlang demonstrate both theoretical robustness and applicability to real‑world concurrent programming. This work bridges the gap between formal process calculi and the design and verification of contemporary concurrent systems.