From X to Pi; Representing the Classical Sequent Calculus in the Pi-calculus

We study the Pi-calculus, enriched with pairing and non-blocking input, and define a notion of type assignment that uses the type constructor “arrow”. We encode the circuits of the calculus X into this variant of Pi, and show that all reduction (cut-elimination) and assignable types are preserved. Since X enjoys the Curry-Howard isomorphism for Gentzen’s calculus LK, this implies that all proofs in LK have a representation in Pi.

💡 Research Summary

The paper establishes a deep correspondence between classical sequent calculus (Gentzen’s LK) and the π‑calculus by introducing a variant of the π‑calculus equipped with pairing and non‑blocking input, and by defining a novel type system that uses only the arrow (→) constructor. The authors first extend the standard π‑calculus with two features: (1) pairing, which allows two channel names to be combined into a single composite channel, thereby supporting multiple inputs and outputs in a natural way; and (2) non‑blocking input, which permits an input action to succeed immediately without waiting for a matching output, mirroring the nondeterministic nature of cut‑elimination in classical logic. On top of this enriched calculus they devise a type system where types are assigned to the free sockets (inputs) on the left of a sequent and to the free plugs (outputs) on the right, without attaching type information to the channel names themselves. This “logical” view of types contrasts with the usual linear or arity‑based type systems for π‑calculus.

The core of the work is the encoding of the X‑calculus, a net‑based representation of LK proofs, into the enriched π‑calculus. X‑calculus nets consist of named sockets and plugs, together with four primitive constructs: capsule, export, import, and cut (denoted by †). Reduction in X is expressed by a set of logical, propagation, and activation rules that move cuts inward, rename connectors, or eliminate them when they meet a capsule. Importantly, reduction in X is non‑confluent, exactly as cut‑elimination in LK. The authors map each X‑net component to a π‑process: sockets become input prefixes, plugs become output prefixes, capsules become synchronisation processes, and cuts become name‑renaming and synchronisation steps. The non‑blocking input ensures that the cut‑reduction steps correspond to immediate communications in the π‑world.

The main technical results are two preservation theorems. First, operational preservation: if a net P reduces to Q in X (P →ₓ Q), then the encoded π‑process ⟦P⟧ reduces (in zero or more steps) to ⟦Q⟧ in the π‑calculus. Second, type preservation: the typing judgments of X (Γ ⊢ Δ) are translated into the new arrow‑based typing judgments for π‑processes, and the encoding respects these judgments. Consequently, every provable sequent in LK has a witness net in X, and that net has a faithful π‑process representation preserving both reduction behaviour and logical typing.

Compared with prior work, the paper avoids the need for linearisation that appears in many π‑calculus encodings of logical systems. Earlier approaches either restricted themselves to fragments of linear logic, required a separate linear type discipline, or encoded only natural‑deduction style proofs. By working directly with X‑calculus, which already embodies the non‑confluent, multi‑conclusion nature of LK, the authors achieve a clean, non‑linear encoding that captures the full implicative fragment of classical logic. The use of pairing further simplifies the representation of multiple inputs/outputs without resorting to complex channel management.

The authors discuss related literature, noting connections to the λµ‑calculi, game semantics, and previous Curry‑Howard correspondences for classical logic. They argue that their approach provides a more direct computational interpretation of cut‑elimination as communication, opening avenues for practical applications such as concurrent proof search, logic‑driven protocol synthesis, and the embedding of classical logical specifications into process‑oriented programming languages.

In conclusion, the paper demonstrates that the enriched π‑calculus, together with the arrow‑type system, can faithfully represent the classical sequent calculus LK via the X‑calculus. This result not only enriches the theoretical landscape linking logic and concurrency but also suggests concrete pathways for leveraging process calculi as execution platforms for classical proofs. Future work is outlined to extend the encoding to additional logical connectives (negation, disjunction) and to explore implementation aspects in real‑world concurrent languages.