Parameterised Multiparty Session Types

For many application-level distributed protocols and parallel algorithms, the set of participants, the number of messages or the interaction structure are only known at run-time. This paper proposes a dependent type theory for multiparty sessions which can statically guarantee type-safe, deadlock-free multiparty interactions among processes whose specifications are parameterised by indices. We use the primitive recursion operator from G"odel’s System T to express a wide range of communication patterns while keeping type checking decidable. To type individual distributed processes, a parameterised global type is projected onto a generic generator which represents a class of all possible end-point types. We prove the termination of the type-checking algorithm in the full system with both multiparty session types and recursive types. We illustrate our type theory through non-trivial programming and verification examples taken from parallel algorithms and Web services usecases.

💡 Research Summary

The paper addresses a fundamental limitation of traditional Multiparty Session Types (MPST): they assume a fixed set of participants and a static communication structure, which does not reflect many real‑world distributed protocols where the number of parties, the number of messages, or the interaction pattern is only known at run‑time. To bridge this gap, the authors introduce a dependent type theory that allows global session specifications to be parameterised by indices (natural numbers, sets, or more complex arithmetic expressions).

The key technical device is the incorporation of the primitive recursion operator from Gödel’s System T into the type system. This operator enables the definition of recursive type families such as rec n. …, which can succinctly describe patterns that repeat a variable number of times or depend on run‑time conditions. By combining primitive recursion with dependent types, the authors can express a wide variety of dynamic communication topologies while preserving decidability of type checking.

A novel concept called a “generic generator” is used to project a parameterised global type onto endpoint types. The generator abstracts over all possible instantiations of the indices and automatically produces, for each participant, the concrete endpoint type that corresponds to a particular run‑time configuration. Consequently, developers write only a single, parameterised specification; the type system derives the exact contract for each process without requiring the programmer to know the exact number of participants in advance.

The paper provides a formal definition of the type system, a deterministic type‑checking algorithm, and proofs of termination, type soundness, and deadlock‑freedom even in the presence of both recursive types and index‑parameterised global types. The termination proof hinges on a well‑founded measure that combines the size of the type syntax with the decreasing nature of primitive recursion arguments.

To demonstrate practicality, three substantial case studies are presented: (1) a pipeline parallel algorithm where the number of stages is a run‑time parameter; (2) a dynamic worker‑pool implementation of a MapReduce‑style computation, where the master spawns an arbitrary number of workers and coordinates request/response cycles; and (3) a web‑service orchestration scenario in which the client count determines which sub‑services are invoked and in what order. Each example is encoded in a Haskell‑like DSL, annotated with the parameterised global type, and successfully type‑checked, confirming that the generated endpoint programs are free of communication mismatches and deadlocks.

The authors conclude by outlining future work: integrating the approach with richer dependent type languages such as Agda or Idris, extending the index language beyond natural numbers to support lists, trees, and more complex predicates, and exploring automatic code generation and runtime verification tools that can exploit the parameterised session specifications. Overall, the paper makes a significant contribution by showing that static guarantees of safety and deadlock‑freedom can be retained even when the communication topology is only known at execution time, opening new avenues for safe development of highly dynamic distributed systems.