On the Fair Termination of Client-Server Sessions

Session types [Honda93, HondaVasconcelosKubo98, HuttelEtAl16] are descriptions of communication protocols enabling the static enforcement of a variety of safety and liveness properties, including the fact that communication channels are used according to their protocol (fidelity), that processes do not get stuck (deadlock freedom), that pending communications are eventually completed (livelock freedom), that sessions eventually end (termination). It is possible to trace a close correspondence between session types and propositions of linear logic, and between the typing rules of a session type system and the proof rules of linear logic [Wadler14, CairesPfenningToninho16, LindleyMorris16]. This correspondence provides session type theories with a solid logical foundation and enables the application of known results concerning linear logic proofs into the domain of communicating protocols. One notable example is cut elimination: the fact that every linear logic proof can be reduced to a form that does not make use of the cut rule means that the process described by the proof can be reduced to a form in which no pending communication is present, provided that there is a good correspondence between cut reductions in proofs and reductions in processes.

The development of session type systems based on linear logic also poses some challenges with respect to their ability to cope with “real-world” scenarios. An example, which is the focus of this work, is the modeling of the interactions between a pool of clients and a single server. By definition, a server is a process that can handle an unbounded number of requests made by clients. In a session type system based on linear logic, it is natural to associate the channel from which a server accepts client requests with a type of the form $!T$, indicating the unlimited availability of a service with type $T$. In fact, it was observed early on [GirardLafont87] that the meaning of the “of course” modality $!T$ could be informally expressed by the equation

which could be read “as many copies of $T$ as the clients require”. While appealing from a theoretical point of view, the association between the concept of server and the “of course” modality is both unrealistic and imprecise. First of all, it models the “unlimited” availability of the server by means of unlimited parallel copies of the server, each copy dealing with a single request, rather than by a single process that is capable of handling an unlimited number of requests sequentially. Second, it fails to capture the fact that each connection between a client and the server may alter the server’s internal state, in such a way that different connections may potentially affect each other.

These considerations have led Qian et al. [QianKavvosBirkedal21] to develop CSLL (for “Client-Server Linear Logic”), a session type system based on linear logic which includes the coexponential modalities $\text{?`}T$ and $\text{!`}T$ whose meaning can be (informally) expressed by the equations

according to which a server that behaves as $\text{!`}T$ offers $T$ as many times as necessary to satisfy all client requests, but it does so sequentially and in some (unspecified) order. Qian et al. [QianKavvosBirkedal21] show that well-typed CSLL processes are deadlock free, but they leave a proof of termination to future work conjecturing that it could be quite involved. A proof of this property is valuable since termination (combined with deadlock freedom) implies livelock freedom.

In this paper we attack the problem of establishing a termination result for CSLL. Instead of providing an ad hoc proof, we attempt to reduce the termination problem for CSLL to the cut elimination property of a known logical system. To this aim, we propose a variation of CSLL called $\textsf{CSLL}^{\infty}$ that is in close relationship with $\mu\textsf{MALL}^{\infty}$ [BaeldeDoumaneSaurin16, Doumane17, BaeldeEtAl22], the infinitary proof theory of multiplicative-additive linear logic with least and greatest fixed points. The basic idea is to encode the coexponentials in $\textsf{CSLL}^{\infty}$’s type system as fixed points in $\mu\textsf{MALL}^{\infty}$ following their expected meaning (Equation 1). At this point, the cut elimination property of $\mu\textsf{MALL}^{\infty}$ should allow us to deduce that well-typed $\textsf{CSLL}^{\infty}$ processes do not admit infinite reduction sequences. As it turns out, we are unable to follow this plan of action in full. The problem is that some reductions in $\textsf{CSLL}^{\infty}$ do not correspond to cut reduction steps in $\mu\textsf{MALL}^{\infty}$. More specifically, even though clients are queued into client pools, they should be able to reduce in any order, independently of their position in the queue. This independent reduction of the clients in the same pool is not matched by the sequence of cut reduction steps that are performed in the cut elimination proof of $\mu\textsf{MALL}^{\infty}$. Still, the cut elimination property of $\mu\textsf{MALL}^{\infty}$ allows us to prove a useful result, namely that every well-typed $\textsf{CSLL}^{\infty}$ process is fairly terminating. Fair termination [GrumbergFrancezKatz84, Francez86] is weaker than termination since it does not rule out the existence of infinite reduction sequences. However, it guarantees that every fair and maximal reduction sequence of a well-typed $\textsf{CSLL}^{\infty}$ process is finite, under a suitable fairness assumption. In particular, fair termination is strong enough (when combined with deadlock freedom) to guarantee livelock freedom.

The adoption of $\mu\textsf{MALL}^{\infty}$ as logical foundation for $\textsf{CSLL}^{\infty}$ has another advantage. In the original presentation of CSLL [QianKavvosBirkedal21] the process calculus is equipped with an unconventional operational semantics whereby reductions can occur underneath prefixes and prefixes may be moved around crossing restrictions, parallel compositions and other (unrelated) prefixes. This semantics is justified to keep the process reduction rules and the cut reduction rules sufficiently aligned, so that the cut elimination property in the logic can be reflected to some valuable property in the calculus, such as deadlock freedom. In contrast, $\textsf{CSLL}^{\infty}$ features an entirely conventional reduction semantics. We can afford to do so because $\mu\textsf{MALL}^{\infty}$ is an infinitary proof system in which the cut elimination property is proved bottom-up by reducing outermost cuts first. This reduction strategy matches the ordinary reduction semantics of any process calculus in which reductions happen at the outermost levels of processes. In the end, since the reduction semantics of $\textsf{CSLL}^{\infty}$ is stricter than that of CSLL, the deadlock freedom and the fair termination results we prove for $\textsf{CSLL}^{\infty}$ are somewhat stronger than their counterparts in the context of CSLL.

In this section we define syntax and semantics of $\textsf{CSLL}^{\infty}$, a calculus of sessions in which servers handle client requests sequentially. The syntax of $\textsf{CSLL}^{\infty}$ makes use of an infinite set $\mathcal{V}$ of channels ranged over by $x$, $y$ and $z$ and a set $\mathcal{P}$ of process names ranged over by $\mathsf{A}$, $\mathsf{B}$, and so on. In $\textsf{CSLL}^{\infty}$ channels are of two kinds (which will be distinguished by their type): session channels connect two communicating processes; shared channels connect an unbounded number of clients with a single server. The structure of terms is given by the grammar in Table 1 and their meaning is informally described below. The term $(x)(P\mathbin{|}Q)$ represents the parallel composition of $P$ and $Q$ connected by the restricted channel $x$, which can be either a session channel or a shared channel. The term $\mathsf{\color[rgb]{0,0,1}fail}\,x$ represents a process that signals a failure on channel $x$. The term $\mathsf{\color[rgb]{0,0,1}close}\,x$ models the closing of a session, whereas $\mathsf{\color[rgb]{0,0,1}wait}\,x.P$ models a process that waits for $x$ to be closed and then continues as $P$. The term $x[y](P\mathbin{|}Q)$ models a process that creates a new channel $y$, sends $y$ over $x$, uses $y$ as specified by $P$ and $x$ as specified by $Q$. The term $x(y).P$ models a process that receives a channel $y$ from $x$ and then behaves as $P$. The term $\mathsf{\color[rgb]{0,.5,.5}in}_{i}\,x.P$ models a process that sends the label $\mathsf{\color[rgb]{0,.5,.5}in}_{i}$ over $x$ and then behaves as $P$. In this work we only consider two labels $\mathsf{\color[rgb]{0,.5,.5}in}_{1}$ and $\mathsf{\color[rgb]{0,.5,.5}in}_{2}$, although it is common to allow for an arbitrary set of atomic labels. Dually, the term $\mathsf{\color[rgb]{0,0,1}case}\,{x}\{P_{1},P_{2}\}$ models a process that waits for a label $\mathsf{\color[rgb]{0,.5,.5}in}_{i}$ from $x$ and then behaves according to $P_{i}$. The term $\text{?`}x[]$ models the empty pool of clients connecting with a server on the shared channel $x$, whereas the term $\text{?`}x[y].P\mathrel{::}Q$ models a client pool consisting of a client that connects with a server on channel $x$ and behaves as $P$ and another client pool $Q$. Occasionally we write $\text{?`}x[y].P$ instead of $\text{?`}x[y].P\mathrel{::}\text{?`}x[]$. The term $\text{!`}x(y)\{P,Q\}$ models a server that waits for connections on the shared channel $x$. If a new connection $y$ is established, the server continues as $P$. If no clients are left connecting on $x$, the service on $x$ is terminated and the process continues as $Q$. Finally, a term $\mathsf{A}\langle\overline{x}\rangle$ represents the invocation of the process named $\mathsf{A}$ with arguments $\overline{x}$. We assume that each process name is associated with a unique global definition of the form $\mathsf{A}(\overline{x})\triangleq P$. The notation $\overline{e}$ is used throughout the paper to represent possibly empty sequences $e_{1},\dots,e_{n}$ of various entities.

The notions of free and bound names are defined in the expected way. Note that the output operations $x[y](P\mathbin{|}Q)$ and $\text{?`}x[y].P\mathrel{::}Q$ bind $y$ in $P$ but not in $Q$. We write $\mathsf{fn}(P)$ and $\mathsf{bn}(P)$ for the sets of free and bound names in $P$, we identify processes up to renaming of bound channel names and we require $\mathsf{fn}(P)=\{\overline{x}\}$ for each global definition $\mathsf{A}(\overline{x})\triangleq P$.

The operational semantics of $\textsf{CSLL}^{\infty}$ is given by a structural precongruence relation $\preccurlyeq$ and a reduction relation $\rightarrow$, both defined in Table 2 and described below. Rules [s-par-comm] and [s-pool-comm] state the expected commutativity of parallel and pool compositions. In particular, [s-pool-comm] allows clients in the same queue to swap positions, modeling the fact that the order in which they connect to the server is not deterministic. Rule [s-par-assoc] models the associativity of parallel composition. The side conditions make sure that no channel is captured ($y\not\in\mathsf{fn}(P)$) or left dangling ($x\not\in\mathsf{fn}(R)$) and that parallel processes remain connected ($x\in\mathsf{fn}(Q)$). The rules [s-pool-par] and [s-par-pool] deal with the mixed associativity between parallel and pool compositions. The side conditions ensure that no bound name leaves its scope and that parallel processes remain connected. Finally, [s-call] unfolds a process invocation to its definition.

Concerning the reduction relation, rule [r-close] models the closing of a session, rule [r-comm] models the exchange of a channel and [r-case] that of a label. Rule [r-connect] models the connection of a client with a server, whereas [r-done] deals with the case in which there are no clients left. Finally, [r-par] and [r-pool] close reductions under parallel compositions and client pools whereas [r-struct] allows reductions up to structural pre-congruence.

Hereafter we write $\Rightarrow$ for the reflexive, transitive closure of $\rightarrow$, we write $P\rightarrow$ if $P\rightarrow Q$ for some $Q$ and $P\arrownot\rightarrow$ if not $P\rightarrow$. Later on we will also use a restriction of $\textsf{CSLL}^{\infty}$ dubbed $\textsf{CSLL}^{\infty}_{\textsf{det}}$ whose reduction relation, denoted by $\rightarrow_{\textsf{det}}$, is obtained by removing the rules [s-pool-comm], [s-pool-par], [s-par-pool] and [r-pool] (all those with “pool” in their name) from $\rightarrow$. In essence, $\textsf{CSLL}^{\infty}_{\textsf{det}}$ is a more deterministic version of $\textsf{CSLL}^{\infty}$ in which clients are forced to connect and reduce in the order in which they appear in client pools. Also, clients are no longer allowed to cross restricted channels.

We conclude this section by defining various termination properties of interest. A run of $P$ is a (finite or infinite) sequence $(P_{0},P_{1},\dots)$ of processes such that $P=P_{0}$ and $P_{i}\rightarrow P_{i+1}$ whenever $P_{i+1}$ is a term in the sequence. A run is maximal if it is infinite or if it is finite and its last term (say $Q$) cannot reduce any further (that is, $Q\arrownot\rightarrow$). We say that $P$ is terminating if every maximal run of $P$ is finite. We say that $P$ is weakly terminating if $P$ has a maximal finite run. A run of $P$ is fair if it contains finitely many weakly terminating processes. We say that $P$ is fairly terminating if every fair run of $P$ is finite.

A fundamental property of any fairness notion is the fact that every finite run of a process should be extendable to a maximal fair one. This property, called feasibility [AptFrancezKatz87] or machine closure [Lamport00], holds for our fairness notion and follows immediately from the next proposition.

The given notion of fair termination admits an alternative characterization that does not refer to fair runs. This characterization provides us with the key proof principle to show that well-typed $\textsf{CSLL}^{\infty}$ processes fairly terminate (Section 5).

In this section we develop the type system of $\textsf{CSLL}^{\infty}$. Types are defined thus:

Types extend the usual constants and connectives of multiplicative-additive linear logic with the coexponentials $\text{!`}T$ and $\text{?`}T$ and, in the context of $\textsf{CSLL}^{\infty}$, they describe how channels are used by processes. Positive types indicate output operations whereas negative types indicate input operations. In particular: $\mathbf{1}$/$\bot$ describe a session channel used for sending/receiving a session termination signal; $\mathbf{0}$/$\top$ describe a session channel used for sending/receiving an impossible (empty) message; $T\mathbin{\otimes}S$/$T\mathbin{\bindnasrepma}S$ describe a session channel used for sending/receiving a channel of type $T$ and then according to $S$; $T_{1}\mathbin{\oplus}T_{2}$/$T_{1}\mathbin{\binampersand}T_{2}$ describe a session channel used for sending/receiving a label $\mathsf{\color[rgb]{0,.5,.5}in}_{i}$ and then according to $T_{i}$; finally, $\text{?`}T$/$\text{!`}T$ describe a shared channel used for sending/receiving a connection message establishing a session of type $T$. Each type $T$ has a dual $T^{\bot}$ obtained in the expected way. For example, we have $(\mathbf{1}\mathbin{\oplus}T)^{\bot}=\bot\mathbin{\binampersand}T^{\bot}$ and $(\text{!`}T)^{\bot}=\text{?`}T^{\bot}$.

The typing rules for $\textsf{CSLL}^{\infty}$ are shown in Table 3. Typing judgments have the form $P\vdash\Upgamma$ and relate a process $P$ with a context $\Upgamma$. Contexts are finite maps from channel names to types written as $\overline{x:T}$. We let $\Upgamma$ and $\Updelta$ range over contexts, we write $\emptyset$ for the empty context, we write $\mathsf{dom}(\Upgamma)$ for the domain of $\Upgamma$, namely for the set of channel names for which there is an association in $\Upgamma$, and we write $\Upgamma,\Updelta$ for the union of $\Upgamma$ and $\Updelta$ when $\mathsf{dom}(\Upgamma)\cap\mathsf{dom}(\Updelta)=\emptyset$.

For the most part, the typing rules coincide with those of a standard session type system based on linear logic [Wadler14, LindleyMorris16]. In particular, [cut], [$\top$], [$\bot$], [$\mathbf{1}$], [$\mathbin{\bindnasrepma}$], [$\mathbin{\otimes}$], [$\mathbin{\binampersand}$] and [$\mathbin{\oplus}$] relate the standard proof rules of multiplicative-additive classical linear logic with the corresponding forms of $\textsf{CSLL}^{\infty}$. The rule [call] deals with process invocations $\mathsf{A}\langle\overline{x}\rangle$ by unfolding the global definition of $\mathsf{A}$, noted as side condition to the rule. Rule [server] deals with servers $\text{!`}x(y)\{P,Q\}$. The continuation $P$, which is the actual handler of incoming connections, must be well typed in a context enriched with the channel $y$ resulting from the connection. Note that $x$ is still present in the context and with the same type, meaning that $P$ must also be able to handle any further connection on the shared channel $x$. The continuation $Q$, which models the behavior of the server once no more clients are connecting on $x$, is not supposed to use $x$ any longer. Rule [client] deals with non-empty client pools $\text{?`}x[y].P\mathrel{::}Q$. The client $P$ is connecting with a server through a shared channel $x$ and establishes a session $y$. The rest of the pool $Q$ is using $x$ in the same way. Rule [done] deals with the empty pool of clients connecting on $x$.

The typing rules are interpreted coinductively. Therefore, a judgment $P\vdash\Upgamma$ is derivable if there is a possibly infinite typing derivation for it. The need for infinite typing derivations stems from the fact that we type process invocations by “unfolding” them to the process they represent, so this unfolding may go on forever in the case of recursive processes.

Adopting an infinitary type system will make it easy to relate $\textsf{CSLL}^{\infty}$ with $\mu\textsf{MALL}^{\infty}$ (Section 5). However, we must be careful in that some infinite typing derivations allow us to type processes that are not weakly terminating, as illustrated in the next example.

In order to rule out processes like $\Omega$ in Example 3.2, we identify a class of valid typing derivations as follows.

This validity condition requires that every infinite branch of a typing derivation describes the behavior of a server willing to accept an unbounded number of connection requests. If we look back at the infinite typing derivation for the Lock process in Example 3.1, we see that it is valid according to Definition 3.3 since the only infinite branch in it goes through infinitely many applications of the rule [server] concerning the very same shared channel $x$. On the contrary, the typing derivation in Example 3.2 is invalid since the infinite branch in it does not go through any application of [server].

The fact that every infinite branch must go through infinitely many applications of [server] concerning the very same shared channel is a subtle point. Without the specification that it is the same shared channel to be found infinitely often, it would be possible to obtain invalid typing derivations as illustrated by the next example.

We conclude this section by stating two key properties of the type system, starting from the fact that typing is preserved by structural pre-congruence and reductions.

Also, processes that are well typed in a context of the form $x:\mathbf{1}$ are deadlock free.

Note that Theorem 3.6 uses $\rightarrow_{\textsf{det}}$ instead of $\rightarrow$ in order to state that $P$ is able to reduce if it is not (structurally pre-congruent to) $\mathsf{\color[rgb]{0,0,1}close}\,x$. Recalling that ${\rightarrow_{\textsf{det}}}\subseteq{\rightarrow}$, the deadlock freedom property ensured by Theorem 3.6 is slightly stronger than one would normally expect. This formulation will be necessary in Section 5 when proving the soundness of the type system. The proofs of Theorems 3.5 and 3.6 can be found in LABEL:sec:extra-types.

In this section we recall the main elements of $\mu\textsf{MALL}^{\infty}$ [Doumane17, BaeldeDoumaneSaurin16, BaeldeEtAl22], the infinitary proof system of the multiplicative additive fragment of linear logic extended with least and greatest fixed points. The syntax of $\mu\textsf{MALL}^{\infty}$ pre-formulas makes use of an infinite set of propositional variables ranged over by $X$ and $Y$ and is given by the grammar below:

The fixed point operators $\mu$ and $\nu$ are the binders of propositional variables and the notions of free and bound variables are defined accordingly. A $\mu\textsf{MALL}^{\infty}$ formula is a closed pre-formula. We write $\{\varphi/X\}$ for the capture-avoiding substitution of all free occurrences of $X$ with $\varphi$ and $\varphi^{\bot}$ for the dual of $\varphi$, which is the involution such that

among the other expected equations. Postulating that $X^{\bot}=X$ is not a problem since we will always dualize formulas, which do not contain free propositional variables.

We write $\preceq$ for the subformula ordering, that is the least partial order such that $\varphi\preceq\psi$ if $\varphi$ is a subformula of $\psi$. For example, if $\varphi\stackrel{{\scriptstyle\smash{\textsf{\tiny def}}}}{{=}}\mu X.\nu Y.(X\mathbin{\oplus}Y)$ and $\psi\stackrel{{\scriptstyle\smash{\textsf{\tiny def}}}}{{=}}\nu Y.(\varphi\mathbin{\oplus}Y)$ we have $\varphi\preceq\psi$ and $\psi\not\preceq\varphi$. When $\Phi$ is a set of formulas, we write $\mathsf{min}\,\Phi$ for its $\preceq$-minimum formula if it is defined. Occasionally we let $\star$ stand for an arbitrary binary connective (one of $\mathbin{\oplus}$, $\mathbin{\otimes}$, $\mathbin{\binampersand}$, or $\mathbin{\bindnasrepma}$) and $\sigma$ stand for an arbitrary fixed point operator (either $\mu$ or $\nu$).

In $\mu\textsf{MALL}^{\infty}$ it is important to distinguish among different occurrences of the same formula in a proof derivation. To this aim, formulas are annotated with addresses. We assume an infinite set $\mathcal{A}$ of atomic addresses, $\mathcal{A}^{\bot}$ being the set of their duals such that $\mathcal{A}\cap\mathcal{A}^{\bot}=\emptyset$ and $\mathcal{A}^{\bot}{}^{\bot}=\mathcal{A}$. We use $a$ and $b$ to range over elements of $\mathcal{A}\cup\mathcal{A}^{\bot}$. An address is a string $aw$ where $w\in\{i,l,r\}^{*}$. The dual of an address is defined as $(aw)^{\bot}=a^{\bot}w$. We use $\alpha$ and $\beta$ to range over addresses, we write for the prefix relation on addresses and we say that $\alpha$ and $\beta$ are disjoint if $\alpha\not\beta$ and $\beta\not\alpha$.

A formula occurrence (or simply occurrence) is a pair $\varphi_{m}adeofaformula$φ$andanaddress$. We use $F$ and $G$ to range over occurrences and we extend to occurrences several operations defined on formulas. In particular: we use logical connectives to compose occurrences so that $\varphi\mathbin{\star}\psi\stackrel{{\scriptstyle\smash{\textsf{\tiny def}}}}{{=}}(\varphi\mathbin{\star}\psi)_{a}nd$σX.φ_ =def(σX.φ)_; the dual of an occurrence is obtained by dualizing both its formula and its address, that is $(\varphi_{^{\bot}}\stackrel{{\scriptstyle\smash{\textsf{\tiny def}}}}{{=}}\varphi^{\bot}_{{\bot}}$; occurrence substitution preserves the address in the type within which the substitution occurs, but forgets the address of the occurrence being substituted, that is $\varphi_{\alpha}\{\psi_{\beta}/X\}\stackrel{{\scriptstyle\smash{\textsf{\tiny def}}}}{{=}}\varphi\{\psi/X\}_{\alpha}$.

We write $\overline{F}$ for the formula obtained by forgetting the address of $F$. Finally, we write $\leadsto$ for the least reflexive relation on types such that $F_{1}\star F_{2}\leadsto F_{i}$ and $\sigma X.F\leadsto F\{\sigma X.F/X\}$.

The proof rules of $\mu\textsf{MALL}^{\infty}$ are shown in Table 4, where $\Sigma$ and $\Theta$ range over sets of occurrences written as $F_{1},\dots,F_{n}$. The rules allow us to derive sequents of the form $\vdash\Sigma$ and are standard except for [$\nu$], which unfolds a greatest fixed point just like [$\mu$] does. Being an infinitary proof system, $\mu\textsf{MALL}^{\infty}$ rules are meant to be interpreted coinductively. That is, a sequent $\vdash\Sigma$ is derivable if there exists an arbitrary (finite or infinite) proof derivation whose conclusion is $\vdash\Sigma$. Without a validity condition on derivations, such proof system is notoriously unsound. $\mu\textsf{MALL}^{\infty}$’s validity condition requires every infinite branch of a derivation to be supported by the continuous unfolding of a greatest fixed point. In order to formalize this condition, we start by defining threads, which are sequences of occurrences.

Hereafter we use $t$ to range over threads. For example, if we consider $\varphi\stackrel{{\scriptstyle\smash{\textsf{\tiny def}}}}{{=}}\mu X.(X\mathbin{\oplus}\mathbf{1})$, we have that $t\stackrel{{\scriptstyle\smash{\textsf{\tiny def}}}}{{=}}(\varphi_{a},(\varphi\mathbin{\oplus}\mathbf{1})_{ai},\varphi_{ail},\dots)$ is an infinite thread of $\varphi_{a}$.

Among all threads, we are interested in finding those in which a $\nu$-formula is unfolded infinitely often. These threads, called $\nu$-threads, are precisely defined thus:

If we consider the infinite thread $t$ above, we have $\mathsf{inf}(t)=\{\varphi,\varphi\mathbin{\oplus}\mathbf{1}\}$ and $\mathsf{min}\,\mathsf{inf}(t)=\varphi$, so $t$ is not a $\nu$-thread because $\varphi$ is not a $\nu$-formula. Consider instead $\varphi\stackrel{{\scriptstyle\smash{\textsf{\tiny def}}}}{{=}}\nu X.\mu Y.(X\mathbin{\oplus}Y)$ and $\psi\stackrel{{\scriptstyle\smash{\textsf{\tiny def}}}}{{=}}\mu Y.(\varphi\mathbin{\oplus}Y)$ and observe that $\psi$ is the “unfolding” of $\varphi$. Now $t_{1}\stackrel{{\scriptstyle\smash{\textsf{\tiny def}}}}{{=}}(\varphi_{a},\psi_{ai},(\varphi\mathbin{\oplus}\psi)_{aii},\varphi_{aiil},\dots)$ is a thread of $\varphi_{a}$ such that $\mathsf{inf}(t_{1})=\{\varphi,\psi,\varphi\mathbin{\oplus}\psi\}$ and we have $\mathsf{min}\,\mathsf{inf}(t_{1})=\varphi$ because $\varphi\preceq\psi$, so $t_{1}$ is a $\nu$-thread. If, on the other hand, we consider the thread $t_{2}\stackrel{{\scriptstyle\smash{\textsf{\tiny def}}}}{{=}}(\varphi_{a},\psi_{ai},(\varphi\mathbin{\oplus}\psi)_{aii},\psi_{aiir},(\varphi\mathbin{\oplus}\psi)_{aiiri},\dots)$ such that $\mathsf{inf}(t_{2})=\{\psi,\varphi\mathbin{\oplus}\psi\}$ we have $\mathsf{min}\,\mathsf{inf}(t_{2})=\psi$ because $\psi\preceq\varphi\mathbin{\oplus}\psi$, so $t_{2}$ is not a $\nu$-thread. Intuitively, the $\preceq$-minimum formula among those that occur infinitely often in a thread is the outermost fixed point operator that is being unfolded infinitely often. It is possible to show that this minimum formula is always well defined [Doumane17]. If such minimum formula is a greatest fixed point operator, then the thread is a $\nu$-thread. Note that a $\nu$-thread is necessarily infinite.

Now we proceed by identifying threads along branches of proof derivations. To this aim, we provide a precise definition of branch.

An infinite branch is valid if supported by a $\nu$-thread that originates somewhere therein.

In this section we prove that well-typed $\textsf{CSLL}^{\infty}$ processes fairly terminate. We do so by appealing to the alternative characterization of fair termination given by Theorem 2.4. Using that characterization and using the fact that typing is preserved by reductions (Theorem 3.5), it suffices to show that well-typed $\textsf{CSLL}^{\infty}$ processes weakly terminate. To do that, we encode a well-typed $\textsf{CSLL}^{\infty}$ process $P$ into a (valid) $\mu\textsf{MALL}^{\infty}$ proof and we use the cut elimination property of $\mu\textsf{MALL}^{\infty}$ to argue that $P$ has a finite maximal run.