{'fraction_non_alphanumeric': 0.041913088197480075, 'fraction_numerical': 0.003985600411416817, 'mean_word_length': 4.418495297805642, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 8, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Multiparty Classical Choreographies

We present Multiparty Classical Choreographies (MCC), a language model where global descriptions of communicating systems (choreographies) implement typed multiparty sessions. Typing is achieved by generalising classical linear logic to judgements that explicitly record parallelism by means of hypersequents. Our approach unifies different lines of work on choreographies and processes with multiparty sessions, as well as their connection to linear logic. Thus, results developed in one context are carried over to the others. Key novelties of MCC include support for server invocation in choreographies, as well as logic-driven compilation of choreographies with replicated processes.


Introduction
Choreographic Programming [17] is a programming paradigm where programs, called choreographies, define the intended communication behaviour of a system based on message passing, using an "Alice and Bob" notation, rather than the behaviour of each endpoint. Choreographies are useful for several reasons: they give a succinct description, or blueprint, of the intended behaviour of a whole system, making the implementation less error-prone. Then, correct-byconstruction distributed implementations can be synthesised automatically by means of projection, a compilation algorithm that generates the code for each endpoint described in the choreography [6,8]. Reversely, it is often possible to obtain a choreography from an endpoint implementation by means of extraction, providing a precise blueprint of a distributed system. Choreographic programming has a deep relationship with the proof theory of linear logic [9]. Specifically, choreographic programs can be seen as terms describing the reduction steps of cut elimination in linear logic (choreographies as cut reductions). The key advantage of this result is that it provides a logical reconstruction of two useful translations, one from choreographies to processes (projection, or synthesis) and another from processes to choreographies (extraction) -this is obtained by exploiting the correspondence between intuitionistic linear logic and a variant of the π-calculus [4]. These translations can be used to keep process implementations aligned with the desired communication flows given as choreographies, whenever code changes are applied to any of the two. This kind of alignment is a desirable property in practice, e.g., it is the basis of the Testable Architecture development lifecycle for web services [14].
Unfortunately, the logical reconstruction of choreographies in [9] covers only the multiplicative-additive fragment of intuitionistic linear logic, limiting its practical applicability to simple scenarios. The aim of this paper is to push the boundaries of this approach towards more realistic scenarios with sophisticated features. In this article, we define a model, strictly related to classical linear logic, that allows for replicated services, and multiparty sessions.
Reaching our aim is challenging for both design and technical reasons. In the multiplicative-additive fragment of linear logic considered in [9], all reductions intuitively match choreographic terms explored in previous works on choreographies, i.e., communication of a channel and branch selection [8]. This is not the case for the exponential fragment, which yields reductions never considered before in choreographies, e.g., explicit garbage collection of services and server cloning (see kill and clone operations). To bridge this gap, we exploit the fact that these operations occur naturally in the process language and, through the logic, can be reflected to choreographic primitives for management of services as explicit resources that can be duplicated, used, or destroyed. We show that the reductions for these terms correspond to the principal cut reductions for exponentials in classical linear logic. Typing guarantees that resource management is safe, e.g., no destroyed resource is ever used again.
In [9], all sessions (protocols) have exactly two participants. This works well in intuitionistic linear logic, where sequents are two-sided: two processes can be connected if one "provides" a behaviour and the other "needs" it. This is verified by checking identity of types, respectively between a type on the right-hand side of the sequent of the first process and a type of the left-hand side of the sequent for the second. To date, it is still unclear how identity for two-sided sequents can be generalised to multiparty sessions, where a session can have multiple participants and thus we need to check compatibility of multiple types. Instead, this topic has been investigated in the setting of classical linear logic, where multiparty compatibility is captured by coherence, a generalisation of duality [10]. Therefore, our formulation of Multiparty Classical Choreographies (MCC) is based on classical linear logic. In order to bridge choreographies to multiparty sessions, we introduce a new session environment, which records the types of multiparty communications performed by a choreography as global types [13]. The manipulation of the session environment reveals that typing a choreography with multiparty sessions corresponds to building the coherence proofs for typing its sessions. Since a proof of coherence is the type compatibility check required by the multiparty version of cut in classical linear logic, our result generalises the choreographies as cut reductions approach to the multiparty case as one would expect, providing further evidence of the robustness of this idea. The final result of our efforts is an expressive calculus for programming choreographies with multiparty sessions and services, which supports both projection and extraction operations for all typable programs.

Preview
We start by introducing MCC informally, focusing on modelling a protocol inspired by OpenID [20], where a client authenticates through a third-party iden-tity provider. MCC offers a way of specifying protocols in terms of global types. For example, our variant of OpenID can be specified by the global type G: This protocol concerns three endpoints (often called roles in literature) denoted by u (user), rp (relaying party) and ip (identity provider). The user starts by sending its login string to both rp and ip. Then, it sends its password to ip which will either confirm or reject u's authentication to rp. If the authentication is successful then the user will send an evaluation of the authentication service to rp, and then complete as the unspecified protocol G 1 . Otherwise, if the password is wrong, then the protocol continues as G 2 . The specification given by the global type G can be used by a programmer during an implementation. In MCC, we could give an implementation in terms of the choreography: u starts rp, ip; // u starts protocol with rp and ip u(useru) → rp(userrp); // u sends its login to rp u(loginu) → ip(loginip); // u sends its login to ip u(pwdu) → ip(pwdip); // s acknowledges to u ′ u(repu) → rp(reprp); P, // u sends report to rp inr : Q // authentication fails Each line is commented with an explanation of the performed action. We observe that two different protocols are started. The first line starts the OpenID protocol between u, rp and ip described above. Moreover, after branching, the choreography starts another session between the user (named u ′ ) and a server s that is used for reviewing the authentication service given by ip. In this case, the protocol used is G ′ = u ′ → s(String); s → u ′ (String); G 3 , for some unspecified G 3 . We leave undefined the case in which the identity provider receives a wrong password (term Q).
In this work, we show how a choreography that follows a protocol such as G can be expressed as a proof in a proof theory strictly related to classical linear logic. Moreover, thanks to proof transformations, the choreography above can be projected into a parallel composition of endpoint processes, each running a different endpoint. As an example, the endpoint process for the user would correspond to the process P u , defined as use u; u(useru); u(loginu); u(pwdu); use u ′ ; u ′ (rep u ′ ); u ′ (ack u ′ ); u(repu); R which mimics the behaviour of u and u ′ specified in the choreography. Operator use is used to start a session, while the other two operators utilised above are for in-session communication. Similarly, we can have the endpoint processes for rp, ip and s:

GCP with Hypersequents
In this section, we present the action fragment of MCC, where we only consider local actions, e.g., inputs or outputs. The action fragment is a variant of Globallygoverned Classical Processes (GCP) [7] whose typing rules use hypersequents. In the remainder, we denote a vector of endpoints x 1 , . . . , x n asx or (x i ) i .
Syntax. The action fragment is a generalisation of Classical Processes [22] that supports multiparty session types. As hinted in §2, when writing a program in our language, we do not identify sessions via channel names, but rather we name sessions' endpoints. Each process owns a single endpoint of a session it participates in. The complete syntax is given by the following grammar: With a few exceptions, the terms above are identical to those of GCP. For space restriction reasons, we only discuss the key differences. Parallel and restriction constructs form a single term (νx : G)(P | Q) in the original GCP. The link process x A → y is a forwarder from x to y. We further allow the general selection x.(inl : P, inr : Q), denoting a process that non-deterministically selects a left or a right branch. For services, an endpoint x may kill all servers by executing the action kill x | P , or duplicate them by means of clone x(x ′ ); P -these operations were silent in the original GCP. In cloning, the new server copies are replicated at fresh endpoints, ready to engage in a session with new endpoint x ′ . More generally, we follow the convention of [22], denoting the result of refreshing names in Q by Q ′ (changing each x ∈ fv(Q) into a fresh x ′ ).
Types. Types, used to ensure proper behaviour of endpoints, are defined as: In the multiparty setting, types can be split into local types A, which specify behaviours of a single process, and global types G, which describe interaction within sessions (and choreography actions). Again, most global types correspond to pairs of local types, the exception being the global axiom type, describing a linking session (restricted by typing to type variables and their duals). Local type operators are based on connectives from classical linear logic -thus, A ⊗ B is the type of a process that outputs an endpoint of type A and continues with type B, whereas A B is the type of a process that receives endpoints of type A and is itself ready to continue as B. The corresponding global typex → y(G); H types the interaction where each of the processes owning an endpoint x i sends their new endpoint to y. Type 0 is justified by the necessity of having a type dual to ⊤, while the rule 0⊤ is essential for the definition of coherence. Type variables are used to represent concrete datatypes. It is worth noting that the logic formulas in our type system enjoy the usual notion of duality, where a formula's dual is obtained by recursively replacing each connective by the other one in the same row in the table above. For example, the dual of Typing. We type our terms in judgements of the form Σ P • • Ψ , where: (i) Σ is a set of session typings of the form (x i ) i : G; (ii) P is a process; and, (iii) Ψ is a hypersequent, a set of classical linear logic sequents. Intuitively, Σ P • • Ψ reads as "Ψ types P under the session protocols described in Σ." Given a judgment Σ P • • Ψ | ⊢ Γ, x : A, checking whether x is availablenot engaged in a session -is implicitly done by verifying that x does not occur in the domain of Σ. Note that names cannot occur more than once in Σ: each endpoint x may only belong to (at most) one session G. Hypersequents Ψ 1 , Ψ 2 and sets of sessions Σ 1 , Σ 2 can only be joined if their domains do not intersect. Moreover, we use indexing in different ways: In order to separate restriction and parallel (reasons for this separation will be explained in § 4), we split the classical linear logic Cut rule into two:

Scope
Rule Conn is used for merging proofs that provide coherent types (we address coherence below), but without removing them from the environment. Since such types need to remain in the conclusion of the rule, we need to use hypersequents. The sequents involved in a session get merged once a Scope rule is applied. This hypersequent presentation is similar to a classical linear logic variant of [9] with sessions explicitly remembered in a separate context Σ.
Coherence is a generalisation of duality [7] to more than two parties: when describing a multiparty session, simple duality of types does not suffice to talk about their compatibility. In Fig. 1, we report the rules defining the coherence relation . We do not describe these here in detail, as they remain unchanged compared to the original GCP presentation, with the exception of the axiom rule which is only applicable to atomic types in our system. Fig. 2. Rules for the action fragment.
The remaining typing rules for the action fragment, presented in Fig. 2 are identical to those of GCP with the exception that a context in GCP may be distributed among several sequents here. For example, rule ⊗ takes two sequents ⊢ Γ 1 , x ′ : A and ⊢ Γ 2 , x : B from two different hypersequents, and merges them into ⊢ Γ 1 , Γ 2 , x : A⊗B, as in classical linear logic. However, elements of Γ 1 and Γ 2 may be connected through Σ 1 and Σ 2 to other parts of Ψ 1 and Ψ 2 respectively (as a result of previously applied Conn). Note that the rules of this fragment work only with processes not engaged in any session, since the endpoints explicitly mentioned in proof terms cannot occur in the domain of Σ: this is an implicit check in all rules of Fig. 2. Rule ⊤ introduces a single sequent Γ, x : ⊤, allowing for any Γ . The proof term xũ.case() keeps track of the endpoints introduced in Γ : it ensures that all endpoints in the typing are mentioned in the proof term, which is useful when defining semantics. In this article, we restrict the axiom to only type variables (see §6).  Semantics. The semantics of the action fragment is almost identical to that of standard GCP. It is obtained from cases of the proof of cut elimination: the principal cases describe reductions (−→), while the permutations of rule applications give rise to the rules for structural equivalence (≡), reported in Fig. 3. Note that as we are interested only in commuting conversions of typable programs, there are certain cases where the correct equivalence can be found only by looking at the typing derivation which contains information that is not part of the process term. Under ≡, parallel distributes safely over case (because only the actions of one branch are going to be executed). A similar mechanism can be found in the original presentation of Classical Processes [22], and was later demonstrated to correspond to a bisimulation law in [1]. The semantics of the action fragment of our calculus is presented in Fig. 4. Notice that the β-reductions are coordinated by a global type, as they correspond to multiple parties communicating. 1 The reduction rules for server killing and cloning may look strange because both kill and clone remain in the proof term after reduction. This is because of the corresponding reduction in classical linear logic, where it is necessary to use weakening and contraction (corresponding to kill and clone respectively) also after reduction. As a consequence, we get them as proof terms.

Extending GCP with Choreographies
In order to obtain full MCC, we extend the action fragment presented in the previous section with choreography terms (interactions).
Syntax. Unlike a process in the action fragment, a choreography, which describes a global view of the communications of a process, will own all of the endpoints of the sessions it describes. We call the fragment of MCC with choreography terms the interaction fragment. Formally, MCC syntax is extended as follows: The link term z ← y B → x; P gives the choreographic view of an axiom connected to some other process P through endpoints x and y. A linear interactionx(x ′ ) → y(y ′ ); P denotes a communication from endpointsx to the endpoint y, where a new session with endpointsx ′ ,y ′ is created. The choreographyx closes y; P closes a session between endpointsx, y. When it comes to branching, we have two choreographic terms denoting left and right selection: x →ỹ.inl(P ; Q 1 , . . . , Q n ) and x →ỹ.inr(P 1 , . . . , P n ; Q). A third term, x → ỹ.(inl : P, inr : Q), is used for non-deterministic choice. In MCC, we can model non-linear behaviour: this is done with the terms x startsỹ; P , x kills y(Q); P and x clonesỹ(x ′ ,ỹ ′ ); P . The first term features a client x starting a new session with serversỹ, while the second term is used by endpoint x to shut down serversỹ. Finally, we have a term for cloning servers so that they can be used by different clients in different sessions.
Typing. Fig. 5 details the rules for typing choreography terms. Each of these rules combines two rules from the action fragment simulating their reduction, where the conclusion of a rule corresponds to the redex and the premise to the reductum. Unlike process rules, the choreography rules now also look at Σ to check that the interactions described conform to the types of the ongoing sessions. In rule C 1⊥ , we close a session (removed from Σ) and terminate all processes involved in it. Rule C ⊗ types the creation of a new session with protocol G, created among endpointsz and w; this session is stored in Σ, while the process types are updated as in rules ⊗ and above. The remaining rules in the linear fragment are similarly understood. Exponentials give rise to three rules, all of them combining ! with another rule. In rule C!?, process x invokes the services provided byỹ, creating a new session among these processes with type G. Rule C !w combines ! with Weaken: here the processes providing the service are simply removed from the context. Finally, rule C !C combines ! with Contract, allowing a service to be duplicated.
Reduction Semantics. Fig. 6 gives the reductions for the interaction fragment. From a proof-theoretical perspective, these reductions correspond to proof transformations of C rules from Fig. 5 followed by a structural Scope rule; the transformation removes the C rule and pushes Scope higher up in the proof tree.
Remark 1 (Server Cloning). The reduction rule for a server cloning choreography must clone all of the doubled endpoints. Looking at the typing rule C !C on Figure 5, cloned variables u j are all of the endpoints mentioned in (?Γ i ) i , and u ′ j are corresponding endpoints from (?Γ ′ i ) i . To make the search for these variables syntactic, one could do an endpoint projection, as described in the next section, and look at the appropriate subterm of the Conn rule which connects y i and x. The u j are then the free variables of this subterm, excluding y i .
Structural equivalence. The reductions given earlier require that programs are written in the very specific form given in their left-hand side. Formally, this is achieved by closing −→ under structural equivalence: if P ≡ P ′ , P ′ −→ Q ′ and Q ′ ≡ Q, then P −→ Q. The equivalences for the interaction part are given in Fig. 7. As in the action fragment, we are only interested in commuting conversions of typable programs, and therefore rely on typing derivations for finding the correct equivalence. Besides the commuting conversions, we also have the usual structural equivalence rules where parallel composition under restriction, linking process and global type for linking sessions are all symmetric. Furthermore, the order of restrictions can be swapped.
Linear Fragment: 5. Rules for the interaction fragment.  Properties. We finish the presentation of MCC by establishing the expected meta-theoretic properties of the system. As structural congruence is typingbased, subject congruence is a property holding by construction: Proof. By induction on the proof that P ≡ Q. In [5], it is explained how the rules for structural equivalence were derived, making this proof straightforward.
Moreover, our reductions preserve typing since they are proof transformations.
Proof. By induction on the proof that P −→ Q. In [5], it is explained how the semantics of MCC were designed in order to make this proof straightforward.
Finally, we can show that MCC is deadlock-free, since the top-level Scope application can be pushed up the derivation. In case the top-level Scope application is next to an application of Conn, either the choreography can reduce directly or both rules can be pushed up. Proof-theoretically, this procedure can be viewed as MCC's equivalent of the Principal Lemma of Cut Elimination.
Theorem 3 (Deadlock-freedom). If P begins with a restriction and Σ P • • Ψ , then there exists Q such that P −→ Q.
Proof (Sketch). Our proof idea is similar to that of Theorem 3 in [9]. We apply induction on the size of the proof of Σ P • • Ψ . If a rule from Fig. 4 or x(x ′ ) → y(y ′ ); P |Q ≡x(x ′ ) → y(y ′ ); (P |Q) x closes y; P |Q ≡x closes y; (P |Q) x startsỹ; P |Q ≡ x startsỹ; (P |Q) x kills y(Q); P |S ≡ x kills y(Q); (P |S) x clonesỹ(x ′ ,ỹ ′ ); P |Q ≡ x clonesỹ(x ′ ,ỹ ′ ); (P |Q)  Fig. 7. Equivalences for commuting C-rules with Conn and Scope. All rules assume that both sides are typable in the same context. Fig. 6 is applicable (corresponding to a proof where an application of Conn and an application of Scope meet), then the thesis immediately holds. Otherwise, we apply commuting conversions from Fig. 3 or Fig. 7, "pushing" the top-level Scope application up in the derivation (and, if it is preceded by an application of Conn, "pushing" also that application). This results in a smaller proof of Σ P • • Ψ , to which the induction hypothesis can be applied.
; P ⇋x closes y; P x.inl; P | (yi.case(Qi, Ri))i |S ⇋ x →ỹ.inl(P |Q |S; R1, . . . , Rn) x.inr; P | (yi.case(Qi, Ri))i |S ⇋ x →ỹ.inr(Q1, . . . , Qn; P |R |S) x.(inl : P, inr : We start by defining the principal transformations for projection and extraction, a set of equivalences that require proof terms to have a special shape. We report such transformations in Fig. 8: they perform extraction if read from left to right, while they perform projection if read from right to left. The extraction relation requires access to the list of open sessions Σ to ensure that we have all the endpoints participating in the session to extract a choreography from. The first two rules deal with axioms: the parallel composition (rule Conn) of an axiom with a process P can be expressed by rule C Ax and vice-versa. On the third line, we show how to transform the parallel composition of an output (⊗) and an input ( ) into a C ⊗ . Similarly,x closes y; P is the choreographic representation of the term (close[x i ]) i | wait[y]; P . Each branching operation (left, right, non-deterministic) has a representative in both fragments with straightforward transformations. A server srv y; Q can either be used by a client, killed or cloned. In the first two cases, such interactions trivially correspond to the choreographic terms x startsỹ; (P |Q) and x kills y(Q); P . In the case of cloning, we create the interaction term x clonesỹ(x ′ ,ỹ ′ ); (P | (srv y i ; Q i ) i | (srv y ′ i ; Q ′ i ) i ), which shows how the choreographic cloning x clonesỹ(x ′ ,ỹ ′ ); must be followed by two instances of the server that is cloned. Note that these transformations are derived by applying similar techniques as those of cut elimination. Concrete derivations, here omitted, are straightforward: an example can be found in [5].
Remark 2. In order to project/extract an arbitrary well-typed term, given the strict format required by the transformations in Fig. 8, we will sometimes have to perform rewriting of terms in accordance with the commuting conversions to reach an expected shape. In particular, we note that when projecting, we must first project the subterms (we start from the leaves of a proof), step by step moving down to the main term. In contrast, when extracting, we must proceed from the root of the proof towards the leaves.
Note that our example in §2 does not provide an exact projection: in order to improve readability, we have removed all parallels that follow output oper-ations, which would be introduced by the translation presented above. This is not problematic, since the outputs in the example are just basic types.
Properties. In the sequel, we write Px −→ extr P ′ whenever it is possible to apply one of the transformations in Fig. 8 to (a term equivalent to) term P from left to right, wherex are the endpoints involved in the transformation. Similarly, we write Px −→ proj P ′ whenever it is possible to apply a transformation from Fig. 8 to (a term equivalent to) term P from right to left. We also write P =⇒ extr P ′ (P =⇒ proj P ′ ) if there is a finite sequence of applications of −→ extr (−→ proj ) and P ′ cannot be further transformed. We then have the following results: Proof. By induction on the proof that Px −→ extr Q or Qx −→ proj P . In [5], we explain how the rules for projection and extraction were derived from the typing rules to ensure that the proof of this result is straightforward.
Theorem 5 (Admissibility of Conn and C-rules). Let P be a proof term such that P • • ⊢Γ . Then, there exists P ′ such that P =⇒ extr P ′ and P ′ is Conn-free; -there exists P ′ such that P =⇒ proj P ′ and P ′ is free from C-rules.
Proof (Sketch). The idea is similar to the proof of Theorem 4.4.1 in [17]: by applying commuting conversions we can always rewrite P such that one of the rules in Fig. 8 is applicable, thus eliminating the outermost application of Conn (in the case of extraction) or the innermost application of a C-rule (in the case of projection). See also Remarks 2 and 3.
Remark 3. The theorem above is only applicable to judgments of the form P • • ⊢Γ . This is because of the commuting conversion of the server rule (νxx : G) (srv y; P |Q) ≡ srv y; (νxx : G) (P |Q) where we can only permute Conn and Scope together. This conversion is needed to rearrange certain proofs into the format required by the transformations in Fig. 8. Note that any judgement Σ P • • Ψ can always be transformed into this format, by repeatedly applying rule Scope to all elements in Σ.
As a consequence of the admissibility of Conn, every program can be rewritten into a (non-unique) process containing only process terms by applying the rules in Fig. 8 from right to left until no longer possible. Conversely, because of admissibility of C-rules, every program can be rewritten into a maximal choreographic form by applying the same rules from left to right until no longer possible.
We conclude this section with our main theorem that shows the correspondence between the two fragments with respect to their semantics. In order to do that, we annotate our semantics with the endpoints where the reduction takes place. This is denoted by P −→x Q and P −→ •x Q where the first relation is a reduction in the action fragment, while the second is a reduction in the interaction fragment. The sequence rev(x) is obtained by reversingx.
Theorem 6 (Correspondence). Let P be a proof term such that Σ P • • Ψ . Then, Proof. This proof follows the same strategy as that of Theorem 6 in [9].

Related Work and Discussion
Related Work. The principle of choreographies as cut reductions was introduced in [9]. As discussed in §1, that system cannot capture services or multiparty sessions. Another difference is that it is based on intuitionistic linear logic, whereas ours on classical linear logic -in particular, on Classical Processes [22].
Switching to classical linear logic is not a mere change of appearance. It is what allows us to reuse the logical understanding of multiparty sessions in linear logic as coherence proofs, introduced in [10] and later extended to polymorphism in [7]. These works did not consider choreographic programs, and thus do not offer a global view on how different sessions are composed, as we do in this paper.
Extracting choreographies from compositions of process code is well-known to be a hard problem. In [15], choreographies that abstract from the exchanged values and computation are extracted from communicating finite-state machines.
have in logics. In order to preserve confluence, we would have to extend MCC with the non-deterministic linear types from [3]. η-expansion. GCP in [7] allows for the axiom to be of any type A. This requires heavily using η-expansions for transforming axioms into processes with communication actions. It is straightforward to do this in the action fragment of MCC. However, given the way choreographies work, we can only define an axiom for binary sessions in the interaction fragment. As a consequence, in order to apply extraction to a process where an axiom is engaged in a multiparty session with several endpoints, we would need to first use η-expansions to transform such axiom into an ordinary process. In the opposite direction, we would never be able to project a process containing an axiom from a choreography, unless it is part of a binary session. We leave further investigation of this as future work. Annotated Types. The original version of GCP [7] comes with an extension called MCP, where an endpoint type A is annotated with names of endpoints which it will be in a session with. In this way, endpoint types become more expressive, since it is possible to specify with whom each endpoint has to communicate, without having to use a global type (coherence proof) during execution. We claim that this extension is straightforward for our presentation of MCC. Polymorphism. As in GCP [7], we can easily add polymorphic types to MCC. However, for simplifying the presentation of this work, we have decided to leave it out, even though adding the GCP rules to the action fragment is straightforward. In the case of the interaction fragment, we obtain the following rule: Other Extensions. By importing the functional stratification from [21], we could obtain a monadic integration of choreographies with functions. The calculus of classical higher-order processes [18] could be of inspiration for adding code mobility to MCC, by adding higher-order types. Types for manifest sharing in [2] may lead us to global specifications of sharing in choreographies. And the asynchronous interpretation of cut reductions in [12] might give us an asynchronous implementation of choreographies in MCC. We leave an exploration of these extensions to future work. Hopefully, the shared foundations of linear logic will make it possible to build on these pre-existing technical developments following the same idea of choreographies as cut reductions.