text
stringlengths 2
132k
| source
dict |
|---|---|
\(\textsf{enbl}_{ \tau }\) (\(\tau \in T^L \setminus \{ \textit{idle}\}\)) and (b) that \({\mathfrak {A}}_n \models \bigwedge _{\langle q^0_n, \tau , q' \rangle \in \delta ^L} \lnot \textsf{enbl}_{ \tau }\). (The latter still holds when the conjunction is empty, in which case it evaluates to \(\top \) by convention.) Consequently, !Image 180 satisfies the second disjunct of \(\textsf {stepl}\). In any case, \({\mathfrak {A}}_n \models \textsf {stepl}\). As a result of the above, \(\textsf {leader}\) is true in \({\mathfrak {M}}\). Moving to the followers, it is easily obtained from the definition of a run for _F_ together with (e), (f), and (h) that, for all \(a_i \in A\), \({\mathfrak {A}}_0 \models \textsf {initf}(a_i)\) and, for all \(n \in {\mathbb {N}}\), for all \(a_i \in A\), \({\mathfrak {A}}_n \models \textsf {ustatef}(a_i)\) and \({\mathfrak {A}}_n \models \textsf {utransf}(a_i)\). To show that, for all \(n \in {\mathbb {N}}\), for all \(a_i \in A\), \({\mathfrak {A}}_n \models \textsf {persf}(a_i)\), let !Image 181\), then, from (h), \(\tau ^i_n = \tau \), which implies that !Image 182, which, in turn, implies due to (f) that !Image 183\), then, from (h), !Image 184 that !Image 187\) is then evident. To show that, for all \(n \in {\mathbb {N}}\), for all \(a_i \in A\), \({\mathfrak {A}}_n \models \textsf {stepf}(a_i)\), we consider two cases. If \( enb ( {\mathfrak {c}}^i_n ) \ne \emptyset \), we have \(\tau ^i_n \in enb ( {\mathfrak {c}}^i_n )\). Thus, from (e) and (h) above, \({\mathfrak {A}}_n \models {{\textsf{s}}}{{\textsf{f}}}_{q^i_n}(a_i)\), \({\mathfrak {A}}_n \models {{\textsf{t}}}{{\textsf{f}}}_{\tau
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
^i_n}(a_i)\), and !Image 189\) and (f) that \({\mathfrak {A}}_n \models \textsf{enbf}_{ \tau ^i_n }(a_i)\). Consequently !Image 190 satisfies the first disjunct of \(\textsf {stepf}(a_i)\). If \( enb ( {\mathfrak {c}}^i_n ) = \emptyset \), we have \(\tau ^i_n = \textit{idle}\) and \(q^i_n = q^i_{n+1}\). Thus, from (e) and (h) above, \({\mathfrak {A}}_n \models {{\textsf{s}}}{{\textsf{f}}}_{q^i_n}(a_i)\), \({\mathfrak {A}}_n \models {{\textsf{t}}}{{\textsf{f}}}_{\textit{idle}}(a_i)\), and !Image 191\) (\(\tau \in T^F \setminus \{ \textit{idle}\}\)) and (f) that \({\mathfrak {A}}_n \models \bigwedge _{\langle q^0_n, \tau , q' \rangle \in \delta ^F} \lnot \textsf{enbf}_{ \tau }(a_i)\). (The latter still holds when the conjunction is empty, in which case it evaluates to \(\top \) by convention.) Consequently, !Image 192 satisfies the second disjunct of \(\textsf {stepf}(a_i)\). In any case, \({\mathfrak {A}}_n \models \textsf {stepf}(a_i)\). As a result of the above, for all \(n \in {\mathbb {N}}\), for all \(a_i \in A\), \({\mathfrak {A}}_n \models \textsf {follower}(a_i)\), from which we obtain the truth of \(\forall x \, \textsf {follower}(x)\) in \({\mathfrak {M}}\). Moving to \(\textsf {neta}\), we first show that \(\textsf {pastm}\) is true in \({\mathfrak {M}}\). For the first conjunct of \(\textsf {pastm}\), let \(\vec {\mu }\in T^L_\text {out}\). If \(\tau ^0_n \ne \vec {\mu }\) for all \(n \in {\mathbb {N}}\), then, from (d), \({\mathfrak {A}}_n \models \lnot {{\textsf{t}}}{{\textsf{l}}}_{\vec {\mu }}\) for all \(n \in {\mathbb {N}}\), and, from (c), \({\mathfrak {A}}_n \models \lnot \textsf {past}_{\vec {\mu }}\) for all \(n \in {\mathbb {N}}\). It follows that \({\mathfrak {A}}_0 \models \Box \lnot \textsf {past}_{\vec {\mu }}\), thus !Image 193, ![Image 195]( and  is true in \({\mathfrak {M}}\). Otherwise, let _t_ be the smallest number such that \({\mathfrak {A}}_t \models {{\textsf{t}}}{{\textsf{l}}}_{\vec {\mu }}\). Thus, from (d), \({\mathfrak {A}}_{n} \models \lnot {{\textsf{t}}}{{\textsf{l}}}_{\vec {\mu }}\) for all \(n t\). Now, for all \(n \in {\mathbb {N}}\), we claim !Image 197, and for all \(n \ne t - 1\) if \(t > 0\); further, if \(t > 0\), we have !Image 198, thus it holds for \(n = t-1\) as well. Finally, it is clear that !Image 199. Therefore, the first conjunct of \(\textsf {pastm}\) is true in \({\mathfrak {M}}\). The argument for the second conjunct is completely analogous. Thus, \(\textsf {pastm}\) is true in \({\mathfrak {M}}\). It is straightforward to show that \(\Box \textsf {bcastla}\) and \(\Box \textsf {sendfa}\) are true in \({\mathfrak {M}}\). As a result, \(\textsf {neta}\) is true in \({\mathfrak {M}}\). \(\square \) For the converse of Lemma3 be a distributed machine; let _A_ be a finite, non-empty set; let \({\mathfrak {M}}= \{ {\mathfrak {A}}_n \}_{n \in {\mathbb {N}}}\), where each \({\mathfrak {A}}_n\) (\(n \in {\mathbb {N}}\)) is a \(\Sigma ^M\)-structure with universe _A_, be a model of \(\textsf {Spec}(M)\); and let \(\textsf {past}_{\vec {\mu }}\) be the nullary predicate in \(\Sigma ^M\) corresponding to the symbol \(\vec {\mu }\in T^L_\text {out}\). For all \(n \in {\mathbb {N}}\), (a)if
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
\({\mathfrak {A}}_n \models \textsf {past}_{\vec {\mu }}\), there exists \(n' 0\). Because !Image 203 or !Image 204, we have \({\mathfrak {A}}_0 \not \models \Box \lnot \textsf {past}_{\vec {\mu }}\), therefore !Image 205 be the smallest number such that \({\mathfrak {A}}_{n'} \models {{\textsf{t}}}{{\textsf{l}}}_{\vec {\mu }}\). \({\mathfrak {A}}_n \models \textsf {past}_{\vec {\mu }}\) implies, then, that \(n' \le n\). It also follows that !Image 206, we must have \({\mathfrak {A}}_{n'} \models \lnot \textsf {past}_{\vec {\mu }}\), thus \(n' 0\). From \({\mathfrak {A}}_0 \models \lnot \textsf {past}_{\vec {\mu }} \mathbin {{\mathcal {W}}}{{\textsf{t}}}{{\textsf{l}}}_{\vec {\mu }}\), we have that either \({\mathfrak {A}}_0 \models \Box \lnot \textsf {past}_{\vec {\mu }}\) or ![Image 212]( In the former case,
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
since !Image 213, it follows that \({\mathfrak {A}}_0 \models \Box \lnot {{\textsf{t}}}{{\textsf{l}}}_{\vec {\mu }}\), and, as a result, \({\mathfrak {A}}_{n'} \models \lnot {{\textsf{t}}}{{\textsf{l}}}_{\vec {\mu }}\) for all \(n' 0\)) and let \({\mathfrak {M}}= \{ {\mathfrak {A}}_n \}_{n \in
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
{\mathbb {N}}}\) be a sequence, where each \({\mathfrak {A}}_n\) (\(n \in {\mathbb {N}}\)) is a \(\Sigma ^M\)-structure (\(\Sigma ^M\) as in the beginning of this section) with universe _A_, such that \(\textsf {Spec}(M)\) is true in \({\mathfrak {M}}\). We construct from \({\mathfrak {M}}\) a run \({\mathfrak {R}}= \langle {\mathfrak {R}}^0, {\mathfrak {R}}^1, \ldots , {\mathfrak {R}}^k \rangle \) for _M_ over _A_. That is, we construct \({\mathfrak {R}}\) such that \({\mathfrak {R}}^0 = \{ \langle {\mathfrak {c}}^0_n, \tau ^0_n \rangle \}_{n \in {\mathbb {N}}}\) is a run for _L_ over _A_ and each \({\mathfrak {R}}^i = \{ \langle {\mathfrak {c}}^i_n, \tau ^i_n \rangle \}_{n \in {\mathbb {N}}}\) (\(1 \le i \le k\)) is a run for _F_ over _A_. In the ensuing part, we assume that !Image 215: 1. (a) set !Image 216); 2. (b) set \(\tau ^0_n = \tau \in T^L\) such that \({\mathfrak {A}}_n \models {{\textsf{t}}}{{\textsf{l}}}_{\tau }\); 3. (c) for each _i_ (\(1 \le i \le k\)), set \({\mathfrak {c}}^i_n = \langle q^i_n, {\mathcal {I}}^i_n \rangle \), such that \({\mathfrak {A}}_n \models {{\textsf{s}}}{{\textsf{f}}}_{q^i_n}(a_i)\) and !Image 219 for each _i_ (\(1 \le i \le k\)), set \(\tau ^i_n = \tau \in T^F\) such that \({\mathfrak {A}}_n \models {{\textsf{t}}}{{\textsf{f}}}_{\tau }(a_i)\). It is a consequence of the assumption that \(\textsf {Spec}(M)\) is true in \({\mathfrak {M}}\) that for all \(n \in {\mathbb {N}}\), \({\mathfrak {A}}_n \models \textsf {ustatel}\) and \({\mathfrak {A}}_n \models \textsf {utransl}\); and, for all \(n \in {\mathbb {N}}\), for all _i_ (\(1 \le i \le k\)), \({\mathfrak {A}}_n \models \textsf {ustatef}(a_i)\) and \({\mathfrak {A}}_n \models \textsf {utransf}(a_i)\). Thus \(q^0_n\) and \(\tau ^0_n\) above, as well as \(q^i_n\) and \(\tau ^i_n\) (\(1 \le i \le k\)), are well-defined. We
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
next show that \({\mathfrak {R}}^0\) is a run for _L_ over _A_. Since \({\mathfrak {A}}_0 \models \textsf {initl}\) we have from (a) that \(q^0_n \in Q^L_\text {init}\) and !Image 220). Now, it is a consequence of the assumption that \(\textsf {Spec}(M)\) is true in \({\mathfrak {M}}\) that \({\mathfrak {A}}_n \models \textsf{persl}_{ }\) and \({\mathfrak {A}}_n \models \textsf {stepl}\), for all \(n \in {\mathbb {N}}\). To show that \(\iota ({\mathfrak {c}}^0_n) \preceq ^{\tau ^0_n} \iota ({\mathfrak {c}}^0_{n+1})\), for all \(n \in {\mathbb {N}}\), we consider two possibilities: if !Image 221, implies that !Image 226, !Image 228, implies that !Image 230); and if !Image 231, implies that !Image 236) !Image 237, \(j \ne i\), then, because \({\mathfrak {A}}_n \models \textsf{persl}_{ }\), !Image 238, \(j \ne i\)), whence, due to (a), !Image 240, \(j \ne i\)). That \(\iota ({\mathfrak {c}}^0_n) \preceq ^{\tau ^0_n} \iota ({\mathfrak {c}}^0_{n+1})\) is then evident. Finally, given that \({\mathfrak {A}}_n \models \textsf {stepl}\), it follows that !Image 242, or !Image 243. For the former case, it follows from (a) that \(q^0_n = q\) and \(q^0_{n+1} = q'\), and from (b) that \(\tau ^0_n = \tau \); and, for
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
the latter case, it follows from (a) that \(q^0_n = q^0_{n+1} = q\) and from (b) that \(\tau ^0_n = \textit{idle}\). That is, \(\langle \sigma ({\mathfrak {c}}^0_n), \tau ^0_n, \sigma ({\mathfrak {c}}^0_{n+1}) = \langle q^0_n, \tau ^0_n, q^0_{n+1} \rangle = \langle q, \tau , q' \rangle \in \delta ^L\) or \(\tau ^0_n = \textit{idle}\) and \(\sigma ({\mathfrak {c}}^0_n) = q^0_n = q^0_{n+1} = \sigma ({\mathfrak {c}}^0_{n+1})\). It is straightforward to show from \({\mathfrak {A}}_n \models \textsf{enbl}_{ \tau }\) (a consequence of the assumption that !Image 244 that \(\tau ^0_n \;(= \tau ) \in enb ( {\mathfrak {c}}^0_n )\); and from \({\mathfrak {A}}_n \models \bigwedge _{\langle q, \tau , q' \rangle \in \delta ^L} \lnot \textsf{enbl}_{ \tau }\) (a consequence of the assumption that !Image 245 that \( enb ( {\mathfrak {c}}^0_n ) = \emptyset \). Thus, we have established that \(\tau ^0_n \in enb ( {\mathfrak {c}}^0_n )\) and \(\langle \sigma ({\mathfrak {c}}^0_n), \tau ^0_n, \sigma ({\mathfrak {c}}^0_{n+1}) \rangle \in \delta ^L\), or \( enb ( {\mathfrak {c}}^0_n ) = \emptyset \), \(\tau ^0_n = \textit{idle}\), and \(\sigma ({\mathfrak {c}}^0_n) = \sigma ({\mathfrak {c}}^0_{n+1})\), for all \(n \in {\mathbb {N}}\). We next show that \({\mathfrak {R}}^i\) (for all \(1 \le i \le k\)) is a run for _F_ over _A_. Since \({\mathfrak {A}}_0 \models \textsf {initf}(a_i)\) we have from (c) that \(q^i_n \in Q^F_\text {init}\) and \({\mathcal {I}}^i_0 = \emptyset \) (\(1 \le i \le k\)). It is a consequence of the assumption that \(\textsf {Spec}(M)\) is true in \({\mathfrak {M}}\) that \({\mathfrak {A}}_n \models \textsf{persf}_{ }(a_i)\) and \({\mathfrak {A}}_n \models \textsf {stepf}(a_i)\), for all \(n \in {\mathbb {N}}\). To show that \({\mathcal {I}}^i_n \preceq ^{\tau ^i_n} {\mathcal {I}}^i_{n+1}\), for all \(n \in {\mathbb {N}}\), we consider two possibilities: if \(\tau ^i_n \not \in T^F_\text {in}\),
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
which, due to (d), implies that !Image 246\), !Image 248, implies that \({\mathcal {I}}^{i}_n \subseteq {\mathcal {I}}^{i}_{n+1}\); and if !Image 250, implies that !Image 251\)) !Image 252, !Image 258\), it follows that !Image 260, or !Image 261. For the former case, it follows from (c) that \(q^i_n = q\) and \(q^i_{n+1} = q'\), and from (d) that \(\tau ^i_n = \tau \); and, for the latter case, it follows from (c) that \(q^i_n = q^i_{n+1} = q\) and from (d) that \(\tau ^i_n = \textit{idle}\). It is straightforward to show from \({\mathfrak {A}}_n \models \textsf{enbf}_{ \tau }(a_i)\) (a consequence of the assumption that !Image 262 that \(\tau ^i_n \; (= \tau ) \in enb ( {\mathfrak {c}}^i_n )\); and from \({\mathfrak {A}}_n \models \bigwedge _{\langle q, \tau , q' \rangle \in \delta ^F} \lnot \textsf{enbf}_{ \tau }(a_i)\) (a consequence of the assumption that !Image 263 that \( enb ( {\mathfrak {c}}^i_n ) = \emptyset \). Thus, we have established that \(\tau ^i_n \in enb ( {\mathfrak {c}}^i_n )\) and \(\langle q^i_n, \tau ^i_n, q^i_{n+1} \rangle \in \delta ^F\), or \( enb ( {\mathfrak {c}}^i_n ) = \emptyset \), \(\tau ^i_n = \textit{idle}\), and \(q^i_n = q^i_{n+1}\), for all \(n \in {\mathbb {N}}\). Finally we establish that conditions (A1) and (A2) from Sect.[3.4]( hold for
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
\({\mathfrak {R}}\). For (A1), we first show that if \(\tau ^0_n = \vec {\mu }\) (\(n \in {\mathbb {N}}\)), then, for each _i_ (\(1 \le i \le k\)), there exists \(n' > n\), such that !Image 264 and suppose \(\tau ^0_n = \tau = \vec {\mu }\). From (b), it must be \({\mathfrak {A}}_n \models {{\textsf{t}}}{{\textsf{l}}}_{\tau }\). Further, from \({\mathfrak {A}}_n \models \textsf {bcastla}\) (a consequence of the assumption that \(\textsf {Spec}(M)\) is true in \({\mathfrak {M}}\)), we have !Image 265 and (c) above that, for each _i_ (\(1 \le i \le k\)), there exists \(n' > n\), such that !Image 267), supposing !Image 268), we have from (c) above that !Image 269 again, !Image 270, whence, from Lemma4, or, due to (b) (in this proof), \(\tau ^0_{n'} = \vec {\mu }\), for some \(n' < n\). Thus we establish that, for each _i_ (\(1 \le i \le k\)), if !Image 271), then there exists \(n' < n\) such that \( \tau ^0_{n'} = \vec {\mu }\). In combination with the above, it follows that condition (A1) from Sect.3.4 from Sect.3.4, (a), sendfa, and Lemma5 Combining Lemma3 be an asynchronous distributed machine and \(\textsf {Spec}(M)\) as above. _M_ is runnable if and only if \(\textsf {Spec}(M)\)
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
is satisfiable over a finite model. ### Remark 3 It should be clear from the proofs of Lemma3\) over finite domains are in one-to-one correspondence. It should also be clear that all runs of _M_ have a property \({\mathcal {P}}\) (expressible in \(\textsf {MFOTL}\)) if and only if \(\textsf {Spec}(M) \wedge \lnot \varphi _{\mathcal {P}}\), where \(\varphi _{\mathcal {P}}\) is the formula (over \(\Sigma ^M\)) expressing \({\mathcal {P}}\) in \(\textsf {MFOTL}\), is unsatisfiable over finite domains. ### 4.5 Execution in a synchronous setting If \(N = \langle L, F \rangle \) is a synchronous distributed machine, we can (automatically) construct an MFOTL-sentence !Image 272) such that _N_ is runnable if and only if !Image 274 comprising a nullary predicate \({{\textsf{s}}}{{\textsf{l}}}_{q}\) for each state \(q \in Q^L\), a unary predicate \({{\textsf{s}}}{{\textsf{f}}}_{q}(\cdot )\) for each state \(q \in Q^F\), the symbols in \(T^L_\text {in}\) and \(T^F_\text {in}\) as unary predicates, the symbols in \(T^F_\text {out}\) as unary predicates, a nullary predicate \({{\textsf{t}}}{{\textsf{l}}}_{\tau }\) for each \(\tau \in T^L\), and a unary predicate \({{\textsf{t}}}{{\textsf{f}}}_{\tau }(\cdot )\) for each \(\tau \in T^F\). The intended meaning for each symbol in \(\Sigma ^N\) is the same as the corresponding symbol in \(\Sigma ^M\). As discussed earlier, a synchronous machine differs from an asynchronous machine in that runs of the former satisfy conditions (S1) and (S2) from Sect.3.4 and (A2) from Sect.[3.4]( Thus, the parts of ![Image 276]( describing the operation of the leader and each follower are the same as in the asynchronous case. The only thing that changes is the description of the network.
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
We now proceed to define the formulas describing _N_’s network. The following two formulas (short for _broadcast leader synchronous_ and _send follower synchronous_ respectively) are a translation of conditions (S1) and (S2) respectively from Sect.3.4 and \(\textsf {sendfa}\), the symbol !Image 278 exists because \(T^L_\text {out} \backsimeq T^F_\text {in}\) (resp.\(T^F_\text {out} \backsimeq T^L_\text {in}\)). The following formula (short for _network synchronous_) describes the operation of the synchronous network comprising the leader and its followers: $$\begin{aligned} \textsf {nets} \,:=\, \Box \textsf {bcastls} \wedge \Box \textsf {sendfs}. \end{aligned}$$ Finally, for the whole machine, let !Image 281\Vert = {\mathcal {O}}(\Vert N\Vert ^2)\). ### Lemma 7 Let \(N = \langle L, F \rangle \) be a synchronous distributed machine and !Image 282 ### Lemma 8 Let \(N = \langle L, F \rangle \) be a synchronous distributed machine and !Image 284 Combining Lemma7 be a synchronous distributed machine and !Image 286 (expressible in \(\textsf {MFOTL}\)) then ![Image 288]( where \(\varphi _{\mathcal
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
{P}}\) is the formula (over \(\Sigma ^N\)) expressing \({\mathcal {P}}\) in \(\textsf {MFOTL}\), is unsatisfiable over finite domains. Relevant to Rem.1 synchronous distributed machine \(N = \langle L, F \rangle \) and a property \({\mathcal {P}}\) expressed in \(\textsf {MFOTL}\) (over \(\Sigma ^N\)) by the formula \(\varphi _{\mathcal {P}}\), if !Image 289 all its runs have property \({\mathcal {P}}\). _N_ can fail to be runnable if the definition of _L_ and/or _F_ is such that the behaviour of the machine in each possible execution is undefined, as discussed in Rem.1. ### Remark 5 Applications requiring different time constraints on message delivery are out of scope. Nevertheless, for completeness, we outline here how to enforce within our framework that messages be delivered after _m_ time steps, for a fixed \(m > 1\). For the leader, one introduces _m_ new proposition symbols \(t^{\vec {\mu }}_1, \ldots , t^{\vec {\mu }}_m\), for each message \(\vec {\mu }\) the leader may broadcast, (these symbols are meant to represent the passage of time after a message \(\vec {\mu }\) is broadcast) and enforces the condition that \(t^{\vec {\mu }}_i\) holds true at time \(n + i\) (\(1 \le i \le m\)) if and only if \({{\textsf{t}}}{{\textsf{l}}}_{\vec {\mu }}\) holds true at time _n_ (\(n \in {\mathbb {N}}\)). One then enforces the condition that ![Image 291]( holds true whenever
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
\(t^{\vec {\mu }}_m\) holds true and if !Image 292 respectively then \(t^{\vec {\mu }}_m\) also holds true at time \(n+1\) (\(n \in {\mathbb {N}}\)), for each follower _x_. Similarly, for the followers, one introduces _m_ new unary predicates !Image 293 a follower may send to the leader, and enforces the condition that \(T^{\vec {\mu }}_i(x)\) holds true at time \(n + i\) (\(1 \le i \le m\)) if and only if \({{\textsf{t}}}{{\textsf{f}}}_{\vec {\mu }}(x)\) holds true at time _n_ (\(n \in {\mathbb {N}}\)), for each follower _x_. One then enforces the condition that !Image 294\) holds true and if !Image 295 respectively then \(T^{\vec {\mu }}_m(x)\) also holds true at time \(n+1\) (\(n \in {\mathbb {N}}\)), for each follower _x_. 5 Specification of protocols ---------------------------- In this section we demonstrate the applicability of our framework in practice by formally specifying three protocols. ### 5.1 FloodSet We consider a variant of the _FloodSet algorithm with alternative decision rule_ [28 Distributed Algorithms. Morgan Kaufmann Publishers Inc., San Francisco, CA, USA"), p.105] that appeared in [13 Practical first-order temporal reasoning. In: International Symposium on Temporal Representation and Reasoning, pp. 156–163. IEEE")]. The setting is as follows. There are _k_ processes, each having an _input bit_ and an _output bit_. The processes communicate via broadcast messages, guaranteed to be delivered with an arbitrary delay, and may also arrive to each recipient multiple times. Informally, the protocol works as follows: * At the first round of computations, every process broadcasts its input bit. * At every round the (tentative) output bit is set to the minimum value ever seen
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
so far. The correctness criterion for this protocol is that, eventually, the output bits of all processes will be the same. We now give a formal specification of the above protocol as a network of a leader and followers. Intuitively, each follower corresponds to one of the aforementioned _k_ processes. Since our model does not allow follower broadcasts we shall use the leader as a network relay: the leader remains idle until it receives one or more “0” messages and/or one or more “1” messages; if it does, it broadcasts a “0” and/or “1” accordingly, and keeps broadcasting while new messages arrive; otherwise it returns to its initial state. The leader is fair, in the sense that it does not neglect to broadcast “1” messages (if any) after broadcasting “0” messages, and _vice versa_. **Fig. 3** ![Image 296: figure 3, and \(T^L_\text {local} = \emptyset \); thus !Image 299. Let \(Q^L = \{ q_0, \ldots , q_3 \}\), \(Q^L_\text {init} = \{ q_0 \}\), and !Image 300. _L_ is depicted in Fig.3, and \(T^F_\text {local} = \emptyset \). Let \(T^F = T^F_\text {in} \cup T^F_\text {out} \cup T^F_\text {local} \cup \{ \textit{idle}\}\). Let \(Q^F = \{ i_0, i_1, o_0, o_1 \}\), \(Q^F_\text {init} = \{ i_0, i_1 \}\), and !Image 302. _F_ is depicted in Fig.( Recall that to form
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
a distributed machine out of _L_ and _F_ we must satisfy the constraints \(T^L_\text {in} \cap T^F_\text {in} = \emptyset \), \(T^L_\text {in} \backsimeq T^F_\text {out}\) and \(T^F_\text {in} \backsimeq T^L_\text {out}\). To satisfy the first restriction we could have typeset either \(T^L_\text {out}\) or \(T^F_\text {in}\) with a different font, but we refrained from that for simplicity. The other constraints are satisfied. Finally, let \(M^\text {FS} = \langle L, F \rangle \) be the asynchronous state machine comprising the leader _L_ and (an arbitrary number of replicated) followers _F_. Let \(\textsf {Spec}(M^\text {FS})\) be the FOTL-sentence such that \(M^\text {FS}\) is runnable if and only if \(\textsf {Spec}(M^\text {FS})\) is satisfiable. According to the informal correctness criterion stated above, we need to verify that the following FOTL-sentence is unsatisfiable over finite domains: $$\begin{aligned} \textsf {Spec}(M^\text {FS}) \,\wedge \, \lnot \, \Diamond ( \forall x \,.\, {{\textsf{s}}}{{\textsf{f}}}_{o_0}(x) \, \vee \, \forall x \,.\, {{\textsf{s}}}{{\textsf{f}}}_{o_1}(x) ). \end{aligned}$$ ### 5.2 Two-phase commit We consider the _two-phase commit_ as described in [19 Consensus on transaction commit. ACM Trans Database Syst (TODS) 31(1):133–160")], with minor simplifications. In this setting, _k_ followers (“resource managers”) coordinated by a leader (“transaction manager”) collectively perform a transaction. The transaction is aborted if one or more followers abort, otherwise it is committed. Initially, the leader and each follower are in a _working_ state. The protocol starts with the leader broadcasting a _prepare_ message to the followers, signalling that a decision is about to be made on committing/aborting the transaction. The leader then enters a _waiting_ state and remains there until it has received a response from each follower—either _prepared_ (signalling that a follower is prepared to receive a command to commit or abort) or _aborted_ (signalling that a follower has chosen to abort). Upon
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
receipt of a _prepare_ message from the leader, each follower enters a _preparing_ state. In this state the follower can choose to (a) abort the transaction (for its own reason); or (b) prepare to receive (from the leader) a command to commit or abort. If the follower aborts, it sends an _aborted_ message to the leader and enters an _aborted_ state. If the follower prepares to receive a command, it sends a _prepared_ message to the leader and enters a _prepared_ state. When in a _prepared_ state, the follower _cannot_ abort on its own volition: it will perform the leader’s command (whether it be to commit or to abort). Thus, while in a _prepared_ state, if the follower receives a _commit_ message, it enters a _committed_ state, and if it receives an _abort_ message, it enters an _aborted_ state. While in the _waiting_ state, if the leader receives an _aborted_ message from one or more followers it enters an _aborting_ state; otherwise (if it receives a _prepared_ message from _all_ _k_ followers) it enters a _committing_ state. When in an _aborting_ state, the leader broadcasts an _abort_ message to the followers and enters an _aborted_ state; and while in a _committing_ state, it broadcasts a _commit_ message to the followers and enters a _committed_ state. (Similar to [19 Consensus on transaction commit. ACM Trans Database Syst (TODS) 31(1):133–160")], we could allow the leader (“transaction manager”) to arbitrarily abort when in a _working_, _waiting_, or _committing_ state, but we will refrain from that for simplicity.) The correctness criterion for this protocol is that, eventually, either all followers are in a _commited_ state or all are in an _aborted_ state. We now give a formal description of the above protocol. Towards defining the leader, let \(T^L_\text {in}
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
= \{ \overleftarrow{prepared }, \overleftarrow{aborted } \}\), \(T^L_\text {out} = \{ \overrightarrow{prepare }, \overrightarrow{commit }, \overrightarrow{abort } \}\), and \(T^L_\text {local} = \emptyset \); thus !Image 303. Let \(Q^L = \{ working ,\, waiting ,\, committing ,\, aborting ,\, committed ,\, aborted \}\), \(Q^L_\text {init} = \{ working \}\), and !Image 304. _L_ is depicted in Fig.5, \(T^F_\text {out} = \{ \overrightarrow{prepared }, \overrightarrow{aborted } \}\), and \(T^F_\text {local} = \emptyset \). Let \(T^F = T^F_\text {in} \cup T^F_\text {out} \cup T^F_\text {local} \cup \{ \textit{idle}\}\). Let \(Q^F = \{ working ,\, preparing ,\, prepared ,\, committed ,\, aborted \}\), \(Q^F_\text {init} = \{ working \}\), and $$\begin{aligned}&\delta ^F = \{ \langle working , \overleftarrow{prepare }, preparing \rangle ,\, \langle preparing , \overrightarrow{prepared }, prepared \, \rangle , \\&\qquad \langle preparing , \overrightarrow{aborted }, aborted \, \rangle ,\, \langle prepared , \overleftarrow{commit }, committed \, \rangle , \\&\qquad \langle prepared , \overleftarrow{abort }, aborted \, \rangle \}. \end{aligned}$$ Let \(F = \langle Q^F, Q^F_\text {init}, T^F, \delta ^F \rangle \). _F_ is depicted in Fig.6, \(T^L_\text {in} \backsimeq T^F_\text {out}\) and \(T^F_\text {in} \backsimeq T^L_\text {out}\). **Fig. 5** ![Image 305: figure 5 be the asynchronous state machine comprising the leader _L_ and (an arbitrary number of replicated) followers _F_. Let \(\textsf {Spec}(M^\text {2PC})\) be the FOTL-sentence such that \(M^\text {2PC}\) is runnable
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
if and only if \(\textsf {Spec}(M^\text {2PC})\) is satisfiable. According to the informal correctness criterion stated above, we need to verify that the following FOTL-sentence is unsatisfiable over finite domains: $$\begin{aligned} \textsf {Spec}(M^\text {2PC}) \,\wedge \, \lnot \, \Diamond ( \forall x \,.\, {{\textsf{s}}}{{\textsf{f}}}_{committed }(x) \, \vee \, \forall x \,.\, {{\textsf{s}}}{{\textsf{f}}}_{aborted }(x) ). \end{aligned}$$ ### 5.3 Control-MAC We consider a simplified version of the Control-MAC protocol , used to enforce a form of mutual exclusion in certain sensor networks. The original protocol involves a degree of randomness, which we are unable to model in our framework and first-order temporal logic in general. The simplifications made here address this limitation while staying faithful to the core ideas behind the protocol. The setting is as follows. There are _k_ sensors and a gateway. The sensors sense a physical phenomenon and each sensor wants to send to the gateway its sense data when a certain threshold is met. The gateway has a limited number of transmission slots, say _m_ (\(m < k\)), and if more than _m_ sensors transmit at the same time there will be data corruption. For simplicity we shall take \(m = 1\), i.e.the gateway has only one transmission slot. The protocol is synchronous and evolves in rounds. At the beginning of each round, the gateway waits for bids for the transmission slot from the sensors that have data to transmit; at the same time, each sensor that has data to transmit bids for the transmission slot, otherwise it waits. If the gateway receives exactly one bid it broadcasts a _go_ message; if it receives two or more bids it broadcasts a _nogo_ message; and,
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
for symmetry, if it receives no bid it broadcasts a _nogo_ message. If a sensor that has bid for the transmission slot receives a _go_ message, it sends its data and moves to its initial state; otherwise, if it receives a _nogo_ message simply moves to its initial state. If a sensor that has not bid for the transmission slot receives either a _go_ or a _nogo_ message, it moves to its initial state. In the original protocol, when a sensor that has bid for the transmission slot receives a _nogo_ message, it waits for a random number of rounds before it bids again. This random number depends on the _contention_ in the system (i.e.on how many sensors have bid up to that point) and its specific properties are of no concern to us. What is important to us is that it is calculated in such a way that if two sensors bid for the transmission slot at the same time, the probability of them biding again at the same time in the future is _very low_. Seeing as we cannot model randomness, we shall assume that probability to be _zero_. Thus, we shall assume that if a sensor bids for the transmission slot at the same time with other sensors, there will be a time in the future when the sensor bids on its own. The correctness criterion for this protocol is that every sensor that has data to send, or, in other words, has bid for the transmission slot, will eventually send its data to the gateway. **Fig. 7** [![Image 307: figure 7]( Control-MAC leader [Full size image]( **Fig. 8** [![Image 308: figure 8]( Control-MAC follower [Full size image]( We now give a formal description of the above protocol. Towards defining the leader, let \(T^L_\text {in} = \{
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
\overleftarrow{bid } \}\), \(T^L_\text {out} = \{ \overrightarrow{go }, \overrightarrow{nogo } \}\), and \(T^L_\text {local} = \{ wait \}\); thus !Image 309. Let \(Q^L = \{ q_0, \ldots , q_4 \}\), \(Q^L_\text {init} = \{ q_0 \}\), and !Image 310. _L_ is depicted in Fig.7, \(T^F_\text {out} = \{ \overrightarrow{bid } \}\), and \(T^F_\text {local} = \{ sending ,\, wait ,\, \varepsilon \}\). Let \(T^F = T^F_\text {in} \cup T^F_\text {out} \cup T^F_\text {local} \cup \{ \textit{idle}\}\). Let \(Q^F = \{ q_0, \ldots , q_6 \}\), \(Q^F_\text {init} = \{ q_0 \}\), and $$\begin{aligned}&\delta ^F = \{ \langle q_0, \overrightarrow{bid }, q_1 \rangle ,\, \langle q_0, wait , q_2 \rangle ,\, \langle q_1, \overleftarrow{go }, q_3 \rangle ,\, \langle q_1, \overleftarrow{nogo }, q_4 \rangle , \\&\qquad \langle q_2, \overleftarrow{go }, q_5 \rangle ,\, \langle q_2, \overleftarrow{nogo }, q_6 \rangle ,\, \langle q_3, sending , q_0 \rangle ,\, \langle q_4, \varepsilon , q_0 \rangle ,\, \\&\qquad \langle q_5, \varepsilon , q_0 \rangle ,\, \langle q_6, \varepsilon , q_0 \rangle , \}. \end{aligned}$$ Let \(F = \langle Q^F, Q^F_\text {init}, T^F, \delta ^F \rangle \). _F_ is depicted in Fig.8, \(T^L_\text {in} \backsimeq T^F_\text {out}\) and \(T^F_\text {in} \backsimeq T^L_\text {out}\). Finally, let \(N^\text {MAC} = \langle L, F \rangle \) be the synchronous state machine comprising the leader _L_ and (an arbitrary number of replicated) followers _F_. Let !Image 311 is runnable if and only if ![Image 312]( is satisfiable. According to the informal correctness criterion
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
stated above, we need to verify that the following FOTL-sentence is unsatisfiable over finite domains: $$\begin{aligned}&\textsf {Spec}(N^\text {MAC}) \\&\quad \wedge \, \quad \Box \forall x(({{\textsf{t}}}{{\textsf{f}}}_{\overrightarrow{bid}}(x) \wedge \exists y (x \ne y \wedge {{\textsf{t}}}{{\textsf{f}}}_{\overrightarrow{bid}}(y))) \rightarrow \\&\quad \Diamond ({{\textsf{t}}}{{\textsf{f}}}_{\overrightarrow{bid}}(x) \wedge \lnot \exists y (x \ne y \wedge {{\textsf{t}}}{{\textsf{f}}}_{\overrightarrow{bid}}(y)))) \\&\quad \wedge \, \lnot \Box \forall x ({{\textsf{t}}}{{\textsf{f}}}_{\overrightarrow{bid}}(x) \rightarrow \Diamond {{\textsf{t}}}{{\textsf{f}}}_{sending }(x)) \end{aligned}$$ 6 Related work -------------- [1 Regular Model Checking for LTL(MSO). In: International Conference on Computer Aided Verification, LNCS, vol. 3114, pp. 348–360. Springer")] presents an approach in which the states and transitions of a parameterized or infinite-state system are represented as words over a finite alphabet and properties of a system are specified and checked using automata-theoretic techniques. Because working with these automata-theoretic techniques can be difficult in practice, [1 Regular Model Checking for LTL(MSO). In: International Conference on Computer Aided Verification, LNCS, vol. 3114, pp. 348–360. Springer")]introduces LTL(MSO), a mixture of LTL (linear temporal logic) and MSO (monadic second-order logic), enabling the specification of systems and their properties at a higher level of abstraction. The verification problem for LTL(MSO) reduces to whether some Büchi regular transition system has accepting runs. [1 Regular Model Checking for LTL(MSO). In: International Conference on Computer Aided Verification, LNCS, vol. 3114, pp. 348–360. Springer")] reports that this problem is in general undecidable, but goes on to verify safety properties and some liveness properties (also see [2 Proving liveness by backwards reachability. In: International Conference on Concurrency Theory, LNCS, vol. 4137, pp. 95–109. Springer")] for liveness) for various real-world protocols. In [( "Delzanno G
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
(2003) Constraint-based verification of parameterized cache coherence protocols. Formal Methods Syst Design 23(3):257–301"), 11 Automatic verification of parameterized cache coherence protocols. International Conference on Computer Aided Verification. Springer International Publishing, Cham, pp 353–360")] and [14 On the verification of broadcast protocols. In: Symposium on Logic in Computer Science, pp. 352–359. IEEE Computer Society Press")], the state of a parameterized system is represented using certain numerical abstractions. An abstract, parameterized, cache-coherence (in [10 Constraint-based verification of parameterized cache coherence protocols. Formal Methods Syst Design 23(3):257–301"), 11 Automatic verification of parameterized cache coherence protocols. International Conference on Computer Aided Verification. Springer International Publishing, Cham, pp 353–360")]) or broadcast (in [14 On the verification of broadcast protocols. In: Symposium on Logic in Computer Science, pp. 352–359. IEEE Computer Society Press")]) protocol for such systems is then translated to numerical constraints pertaining to said numerical abstractions. This approach reduces model-checking safety properties to a reachability problem, which can be attacked using common methods for infinite-state model-checking, working over integer or real arithmetics. The latter methods have in general non-elementary worst-case complexity. [14 On the verification of broadcast protocols. In: Symposium on Logic in Computer Science, pp. 352–359. IEEE Computer Society Press")] reports that model-checking liveness properties for their abstract broadcast protocol is undecidable. By utilizing \(\textsf {MFOTL}\), our approach achieves similar expressiveness to LTL(MSO) (if no second-order quantifiers are used, formulas of LTL(MSO) can be straightforwardly translated to monadic \(\textsf {MFOTL}\)) and approximates to some extent the expressiveness of approaches based on numerical abstractions (the latter are more flexible in expressing properties involving complex numerical constraints, but \(\textsf {MFOTL}\) can express simple numerical constraints,
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
possibly sacrificing completeness for constraints requiring equality). At the same time, \(\textsf {MFOTL}\) remains decidable (sacrificing completeness when it comes to properties requiring equality) and has relatively low worst-case computational complexity. The decidability and computational complexity of \(\textsf {MFOTL}\) are not affected by the type of property one wants to check (i.e.safety, liveness, fairness, or other), and, as a result, \(\textsf {MFOTL}\) is particularly useful for checking liveness properties, which present difficulties for the above formalisms. The abstract model that we introduce can emulate the protocol model in [10 Constraint-based verification of parameterized cache coherence protocols. Formal Methods Syst Design 23(3):257–301"), 11 Automatic verification of parameterized cache coherence protocols. International Conference on Computer Aided Verification. Springer International Publishing, Cham, pp 353–360")] and has similarities with the one in [14 On the verification of broadcast protocols. In: Symposium on Logic in Computer Science, pp. 352–359. IEEE Computer Society Press")]. For protocols that include ingoing transitions of the form !Image 313 but incomplete (a protocol may have a given property even if the protocol’s translation does not logically entail that property). For example Control-MAC in Sect.5.3 orchestrating an arbitrary number of identical machines (followers). Our framework provides a high-level formalism based on finite-state machines and encapsulating their network interactions. We
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
have shown that protocols specified in this framework can automatically be translated into monodic first-order temporal logic, maintaining their semantics. Automated theorem provers for said logic can then be used to check whether that translation (and thus the original protocol) satisfies a property of interest. Thus, our framework constitutes a flexible, high-level approach to parameterized verification. To demonstrate the applicability of our framework, we have specified in it three protocols used in real settings. The implementation of our framework and its incorporation with the provers is the subject of ongoing and future work.
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
Title: Parameterized verification of leader/follower systems via first-order temporal logic URL Source: Markdown Content: Formal Methods in System Design (2021) 58:440–468 # Parameterized verification of leader/follower systems via first-order temporal logic G. Kourtis 1 · C. Dixon 1 · M. Fisher 1 · A. Lisitsa 2 Received: 29 March 2021 / Accepted: 13 February 2022 / Published online: 15 March 2022 © The Author(s) 2022 Abstract We introduce a framework for the verification of protocols involving a distinguished machine (referred to as a leader) orchestrating the operation of an arbitrary number of identical machines (referred to as followers) in a network. At the core of our framework is a high-level formalism capturing the operation of these types of machines together with their network interactions. We show that this formalism automatically translates to a tractable form of first-order temporal logic. Checking whether a protocol specified in our formalism satisfies a desired property (expressible in temporal logic) then amounts to checking whether the protocol’s translation in first-order temporal logic entails that property. Many different types of protocols used in practice, such as cache coherence, atomic commitment, consensus, and synchronization protocols, fit within our framework. First-order temporal logic also facili-tates parameterized verification by enabling us to model such protocols abstractly without referring to individual machines. Keywords Parameterized verification · First-order logic · Temporal logic This work was funded by the Engineering and Physical Sciences Research Council (EPSRC) in the UK under the Science of Sensor Systems Software grant (EP/N007565/1), by the UK Industrial Strategy Challenge Fund (ISCF), under the Future AI and Robotics for Space Hub (EP/R026092/1) and through the Royal Academy of Engineering. # B G. Kourtis georgios.kourtis@manchester.ac.uk C. Dixon clare.dixon@manchester.ac.uk M. Fisher michael.fisher@manchester.ac.uk A. Lisitsa a.lisitsa@liverpool.ac.uk 1 Department of Computer Science, The University of Manchester, Manchester, UK 2 Department
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
of Computer Science, University of Liverpool, Liverpool, UK # 123 Formal Methods in System Design (2021) 58:440–468 441 ## 1 Introduction Parameterized verification is becoming increasingly important nowadays, with technologies like the Internet of Things (IoT), sensor networks, robot swarms, and satellite constellations becoming widespread. Systems involving large numbers of communicating components are commonly deployed, increasing the need for scalable verification techniques to ensure that such systems operate as expected. Parameterized verification via first-order temporal logic [13, 16, 18] is an approach to parameterized verification, proposed as an alternative to regular model checking for param-eterized and infinite-state systems [1, 2] and constraint-based verification using counting abstractions [10, 11, 14]. The model checking approach has been applied to several scenar-ios verifying safety properties and some liveness properties, but is in general incomplete. Constraint-based approaches do provide complete procedures for checking safety properties, but these procedures have non-primitive recursive upper bounds, and they usually lead to undecidability when applied to liveness properties. On the other hand, while first-order tem-poral logic is incomplete and generally undecidable , a certain syntactic restriction to it, referred to as monodic first-order temporal logic, is finitely axiomatizable and (if one restricts its first-order part to a decidable fragment of first-order logic) decidable . Roughly speaking, a first-order temporal logic formula ϕ is said to be monodic if every sub-formula of ϕ appearing within the scope of a temporal operator has at most one free variable. As shown in [13, 16], monodic first-order temporal logic is expressive enough to specify various types of systems commonly appearing in practice. In particular, [13, 16] show how to encode in said logic an abstract protocol model, first appearing in [10, 11], for networks of arbitrarily many, identical finite-state machines communicating via broadcast messages. Using this approach, one is able
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
to automatically translate any suitable protocol to a monodic first-order temporal formula that encapsulates its behaviour. One is then able to check whether that protocol has a certain property by checking whether said formula logically entails the property. (Of course the property must be expressible in monodic first-order temporal logic.) In this work, we introduce a new abstract model that encapsulates the one appearing in [10, 11, 13, 16], but can be applied to a wider class of protocols, such as cache coherence, atomic commit, consensus, and synchronization protocols. Sect. 5 provides three examples of protocols specified in this model. Our model applies to settings in which a distinguished finite-state machine (referred to as a leader ) orchestrates the operation of arbitrarily many, identical finite-state machines (referred to as followers ). As an example of such a setting, consider a simple consensus protocol in which the leader asks the followers whether they agree on a certain parameter change by broadcasting to them an “agree?” message, to which they reply with either a “yes” (when they agree) or a “no” message (when they do not agree), and, if they all agree, the leader changes the parameter. We assume that message delivery is guaranteed, but each message can take arbitrarily long to arrive to each recipient and may arrive multiple times. The setting in the above example is different to the setting in [10, 11, 13, 16] in two main ways. First, only the leader broadcasts to the followers: each follower can only message the leader (and not other followers). Second, unlike the followers, which react to individual messages, the leader reacts to collections of messages. For example, an individual “yes” message does not generally convey any information to the leader, apart from the possibility of a consensus in the future (assuming
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
the leader has not received any “no” messages). To # 123 442 Formal Methods in System Design (2021) 58:440–468 > Fig. 1 A simple protocol in which the leader ( a0) has to record the messages it receives from its followers ( a1,a2,a3) be able to make a decision about the consensus in the future, the leader has to maintain a persistent record of individual messages together with an identifier for their sender. To incorporate such functionality, our model introduces the concept of an inbox . Inboxes provide a way for the leader to organize incoming messages and record their sender. For the above setting, the leader maintains an inbox for “yes” messages and an inbox for “no” messages, and, upon delivery of a message, the sender’s identifier is recorded in the inbox. See Fig. 1 for a possible execution in that setting. (Each inbox is represented by a box; dotted arrows represent the flow of time; regular arrows represent messages.) Then, consensus is achieved if the “yes” inbox contains the identifiers of all followers. For different protocols, we enable the leader to react to different conditions upon its inboxes. (For example, the leader can react to an inbox having exactly one element or to an inbox having more than one element.) For symmetry, each follower is also equipped with an inbox, which is simply a record of ingoing messages (all ingoing messages to a follower come from the leader, so the sender need not be recorded). Our model can be considered as a generalization of the model in [10, 11, 13, 16] since follower broadcasts can be emulated using the leader as a network relay that broadcasts all its ingoing messages (see, for example, the leader in Sect 5.1). The plan of this paper is as follows. In Sect.
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
2 we review some relevant concepts from first-order temporal logic. In Sect. 3 we give a formal definition of our model. In Sect. 4 we show how our model automatically translates to (monodic) first-order temporal logic. In Sect. 5 we specify with our framework three protocols appearing in practice, namely the FloodSet protocol , the two-phase commit [6, 19], and Control-MAC . In Sect. 6 we discuss related work. # 123 Formal Methods in System Design (2021) 58:440–468 443 ## 2 Preliminaries In the sequel, we assume standard concepts from first-order logic. The symbols used in first-order temporal logic (abbr. FOTL ) are predicate symbols P0, P1, . . . , each of fixed arity (0-ary or nullary predicate symbols are allowed and correspond to propositions); variables x0, x1, . . . , constants c0, c1, . . . ; the propositional constants (true) and ⊥ (false); the usual Boolean connectives ( ¬, ∨, ∧, →, ↔); the quantifiers ∀ (for all) and ∃ (exists); and the temporal operators (always in the future), ♦ (sometime in the future), (at the next moment), U (until), and W (weak until). The syntax of FOTL is as follows: • and ⊥ are atomic FOTL -formulae; • if P is an n-ary predicate symbol and t1, . . . , tn are variables or constants, then P(t1, . . . , tn ) is an atomic FOTL -formula; • if ϕ and ψ are FOTL -formulae, so are ¬ϕ, ϕ ∧ ψ, ϕ ∨ ψ, ϕ → ψ, and ϕ ↔ ψ; • if ϕ is an FOTL -formula and x is a variable, then ∀x ϕ and ∃x ϕ are FOTL -formulae; • if ϕ and ψ are FOTL -formulae, then so are ϕ, ♦ϕ, ϕ, ϕ U ψ, and
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
ϕ W ψ.If ϕ is an FOTL -formula, we denote its length by ‖ϕ‖. FOTL -formulae are interpreted in first-order temporal structures , i.e. sequences M = A0, A1, . . . of first-order structures over the same domain A. That is, given a non-empty set A, An = 〈 A, I n 〉 (n ∈ N), where is I n an interpretation of predicate and constant symbols over A, assigning to each predicate symbol P a relation PAn on A of the same arity as P (if P is a nullary predicate, PAn is simply one of the propositional constants or ⊥), and to each constant symbol c an element cAn of A.We require that the interpretation of constants be rigid , i.e. I n (c) = I m (c), for all n, m ∈ N.An assignment a in A is a function from the set of variables {x0, x1, . . . } to A. The truth relation (M, An ) | a ϕ (or simply An | a ϕ if M is clear from context) in M = A0, A1, . . . is defined in Fig. 2. We say that a formula ϕ is true in M if there exists an assignment a such that A0 | a ϕ. A formula is satisfiable if it has a model and valid if it is true in any temporal structure under any assignment. A formula is called monodic if any subformula of ϕ of the form ψ, ♦ψ, ψ, ψ1 U ψ2 , or ψ1 W ψ2 has at most one free variable. For example, the formulae ∀x(P(x) → Q(x)) and ∀x ♦∃y P (x, y) are monodic, while the > Fig. 2 Semantics of FOTL # 123 444 Formal Methods in System Design (2021) 58:440–468
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
formula ∀x∀y(P(x, y) → Q(x, y)) is not monodic. The set of all monodic formulae form the monodic fragment of FOTL (abbr. MFOTL ). FOTL is incomplete (not recursively axiomatizable) and undecidable . In contrast, MFOTL is finitely axiomatizable , and, if its first-order part is restricted to a decidable fragment of first-order logic, decidable . Of particular interest to us are the monadic fragment and the two-variable fragment of MFOTL , both decidable and EXPSPACE -complete . (Most of the formulas we require can be written in monadic MFOTL . As we shall see later on, if some form of counting is required, two variables are necessary.) Two automated theorem provers are available for MFOTL : TeMP and TSPASS [26, 27]. These provers implement a form of temporal resolution called fine-grained resolution [8, 24]. (See [12, 15] for some applications of TeMP and [3–5, 20] for TSPASS.) It should be noted that these provers use (for technical reasons) so-called expanding domain semantics . (The semantics that we provided above are constant domain semantics . With expanding domain semantics, the domains of the structures in a temporal model M = A0, A1, . . . are expanding , i.e. An = 〈 A n , I n 〉, where A n ⊆ A n+1 (n ∈ N) and I n is an interpretation over A n ; with constant domains, A n = A n+1 = A.) It is known that satisfiability over expanding domains reduces to satisfiability over constant domains . [24,Sec. 7] discusses how to enforce constant domains in fine-grained temporal resolution (which uses expanding domain semantics). This is useful for applications using TeMP or TSPASS that require constant domains. Various applications may also require finite domains. In this connection, [17, 25] report on characterizing finite
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
domains using MFOTL . In particular, reports that each of the following three axioms enforces finite domains (and is derivable from each of the other two): (F1) ♦∀x(♦P(x) → P(x)) (F2) [∀ x (P(x) → ¬P(x)) ] → [ ♦ ∀x ¬P(x)] (F3) [∀x(P(x) → P(x)) ] → [ ♦ ∀x( P(x) → P(x)) ] ( is interpreted as “sometime in the past”.) also reports that for classes of protocols satisfying a certain “stabilization principle” (FloodSet in Sect. 5.1 and the two-phase commit in Sect. 5.2 both satisfy this principle, but Control-MAC in Sect. 5.3 does not), satisfiability over finite domains coincides with satisfiability over arbitrary domains. Thus, (F1)-(F3) need not be used to enforce finiteness for such protocols. Adding either equality or function symbols to MFOTL leads to the loss of recursive enu-merability [9, 31]. This is a limitation that affects applications (such as the Control-MAC protocol in Sect. 5.3) that require the counting quantifiers ∃ =1 x P (x) and ∃>1 x P (x) (“there exists exactly one x such that P(x)” and “there exist more than one x such that P(x)”respectively), which we use as shorthands for ∃x P (x) ∧ ∀ x∀y(( P(x) ∧ P(y)) → x = y) and ∃x∃y(P(x) ∧ P(y) ∧ ¬ (x = y)) respectively, where P(·) is a unary predicate. (We also use ∃≥1 x P (x) in place of ∃x P (x) sometimes for emphasis.) Due to the aforementioned limitation, ∃ =1 x P (x) and ∃>1 x P (x) cannot be input to TeMP or TSPASS. To address this issue, one option is attempting to specify equality axiomatically. In a non-temporal setting, equality can be axiomatized as a congruence relation, i.e. as a binary relation E(·, ·) satisfying axioms (E1)-(E4) below: (E1) ∀x E (x, x) (E2)
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
∀x y (E(x, y) → E(y, x)) (E3) ∀x yz (E(x, y) ∧ E(y, z) → E(x, z)) (E4) ∀x1 · · · x n y1 · · · yn (∧ni=1 E(x i , yi ) ∧ P(x1, . . . , x n ) → P(y1, . . . , yn )) In a temporal setting, one needs in addition axiom (E5) below, enforcing the condition that equal objects remain equal across time: # 123 Formal Methods in System Design (2021) 58:440–468 445 (E5) ∀x y (E(x, y) ↔ E(x, y)) The problem with this approach is that formula (E5) is not monodic. As a result, one is left only with axioms (E1)-(E4). Now, suppose that one wishes to check whether a monodic formula χ containing equality is valid. (For our purposes, χ will be of the form ϕ → ψ,where ϕ describes a protocol and ψ a correctness condition for that protocol.) It should be clear that if EqAx → [ χ]E is valid, where EqAx is the conjunction of formulas (E1)-(E4) and [χ]E is the result of replacing in χ all occurences of x = y with E(x, y), then χ is valid. (Any proof of χ in the axiomatic system (E1)-(E4) is trivially a proof of χ in the axiomatic system (E1)-(E5), and the latter system fully captures equality.) Thus, one is left with a correct but incomplete approach to check the validity of a monodic formula χ containing equality: one uses TeMP or TSPASS to check whether EqAx → [ χ]E is valid; if the prover concludes that it is, then one knows that χ is valid; if the prover concludes that EqAx → [ χ]E is not valid, then the validity of χ remains unknown. ## 3 Distributed machines In the following setting we
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
have a collection of k + 1 ( k > 0) finite-state machines in a network, k of which are replicas of each other and the remaining machine is a distinguished machine orchestrating the operation of the replicas. Each replica is referred to as a follower ,the distinguished machine is referred to as a leader , and the whole network of these k + 1machines is referred to as a distributed machine .Communication in the network occurs via the exchange of the following types of messages: (a) broadcast messages from the leader to the followers; and (b) individual messages from a follower directed to the leader. (A follower can theoretically broadcast a message to the followers by using the leader as a relay; see, for example, Sect. 5.1.) Delivery of messages in the network is guaranteed. (See Rem. 1 for a technicality about guaranteed delivery in synchronous networks.) Depending on the application, delivery of messages can occur within one time unit (synchronous network) or it can take arbitrarily long (asynchronous network). In the latter case, a broadcast message (by the leader) can arrive to different followers at different times; and each message can arrive to its recipient (be it the leader or a follower) multiple times. The leader has a separate inbox for each message it is meant to receive. Upon delivery of a message, an identifier for the message’s sender (i.e. a follower) is added to the appropriate inbox. Every follower has an inbox of messages and, upon delivery, each message to a follower is added to the follower’s inbox. The leader’s transitions correspond to three types of actions: (a) reacting to one of its inboxes; (b) broadcasting a message to the followers; and (c) local (not related to the network). Specifically, in type (a) transitions the leader reacts
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
to an inbox (i) being empty ; (ii) having exactly one element; (iii) having one or more elements; (iv) having more than one element; or (v) being full , i.e. containing the identities of all followers in the network. Type (a)(ii)-(v) transitions for the leader delete the contents of the corresponding inbox. Each follower’s transitions correspond to three types of actions: (a) reacting to a message in the follower’s inbox; (b) sending a message to the leader; and (c) local (not related to the network). Type (a) transitions for each follower delete the corresponding message from the follower’s inbox. We stress at this point that receiving a message and reacting to a message or a message’s inbox are different things: receiving a message is a network action (simply registering the message to the recipient) and is independent of the recipient’s operation; reacting to a message (in the follower’s case) or a message’s inbox (in the leader’s case) is an action in which the # 123 446 Formal Methods in System Design (2021) 58:440–468 recipient takes a transition relevant to that message. The recipient of a message need not react to it (in the follower’s case) or to its corresponding inbox (in the leader’s case), neither at the time of its receipt nor at any future time. We now proceed to define the above concepts formally. 3.1 Notation for messages and transitions In the sequel, we adopt the following convention regarding messages: to emphasize that a message μ (where μ is an arbitrary label) is ingoing , we write μ with a left-pointing arrow on top ( μ); and to emphasize that μ is outgoing , we write μ with a right-pointing arrow on top ( μ). The leader’s inbox corresponding to a message μ is denoted by Iμ.To distinguish the
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
leader’s three different types of transitions (reacting to an inbox, broad-casting a message, and local) we introduce the following notation. Transitions in which the leader reacts to an inbox Iμ are denoted with the message μ followed by a quantifier , i.e. =0 , > =1 , ≥1 , >1 , or all (written as a superscript). Thus, we write: (i) μ=0 for a transition that occurs on condition that Iμ is empty ; (ii) μ=1 for a transition that occurs on condition that Iμ has exactly one element; (iii) μ≥1 for a transition that occurs on condition that Iμ has one or more elements; (iv) μ >1 for a transition that occurs on condition that Iμ has more than one element; and (v) μall for a transition that occurs on condition that Iμ is full . The above quantifiers are enough for our purposes, but our framework can be easily extended with more quantifiers, depending on the application. Any quantifier expressible in first-order logic can be added by including the quantifier in the set T L > in (Sect. 3.2) and updating the persl and enbl τ formulas (Sect. 4.1) with the quantifier’s semantics in first-order logic. Proofs carry over with minor adjustments. (Note that quantifiers requiring equality to be exressed in first-order logic affect the completeness of our framework as discussed in Sect. 6.) Transitions in which the leader broadcasts a message are simply denoted with that message (employing the above convention for outgoing messages): μ denotes the transition in which the leader broadcasts μ. Local transitions are simply denoted with a plain label (no arrow on top). Similar notation is used for followers reacting to a message ( μ) and sending a message to the leader ( μ), as well as for their local transitions (no arrow
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
on top). For examples using the above notation see Sect. 5 and figures therein. 3.2 Leaders and their execution Let T L > in = { μ1, . . . , μr }, T L > out = { μ1, . . . , μs }, and T L > local = { 1, . . . , t } be sets of symbols (note that μ and μ are different symbols); let T L > in = { μ=0,μ=1,μ≥1,μ>1,μall |μ ∈ T L > in }.A leader is a quadruple L = 〈 Q L , Q L > init , T L , δ L 〉, where • Q L is a finite set, the set of states of L; • Q L > init ⊆ Q L are the initial states of L; • T L = T L > in ∪ T L > out ∪ T L > local ∪ { idle } is the set of transitions of L; and • δL ⊆ Q × (T L \ { idle }) × Q is the transition relation of L.Intuitively, T L > in is the set of all possible ingoing messages to L, thus, according to the notational conventions in Sect. 3.1, T L > in is the set of all available labels for transitions in which # 123 Formal Methods in System Design (2021) 58:440–468 447 L reacts to an inbox; T L > out is the set of all possible outgoing messages from the leader, and, also, the set of all available labels for transitions in which L broadcasts a message; and T L > local is the set of L’s local actions, and, also, the set of all available labels for L’s local transitions. The transition idle is a
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
special transition the leader takes when it is unable to take any other transition. We define the size of L, denoted ‖L‖, to be the quantity |Q L | + | T L | + | δL |. For some example leaders see Sect. 5. We describe the execution of a leader as a sequence of certain configurations in the context of a (non-empty) set A, whose elements are to be viewed as representing followers in the leader’s network. Let L be a leader as above and A = { a1, . . . , a k } (k > 0) be a set (the set of L’s followers). An l-configuration (short for leader configuration ) over A is an (r + 1)-tuple 〈q, Iμ1 , . . . , Iμr 〉 (T L > in = { μ1, . . . , μr }), where q ∈ Q L and Iμi ⊆ A (1 ≤ i ≤ r). Intuitively, q is L’s state at a given moment of time and Iμi (1 ≤ i ≤ r) is L’s inbox corresponding to the message μi ∈ T L > in at that moment of time. Each Iμi (1 ≤ i ≤ r) is to be viewed as a record of those followers (elements of A) from which L has received a message > μi since the last time L reacted to Iμi . (Recall that reacting to a non-empty inbox deletes its content.) If c = 〈 q, Iμ1 , . . . , Iμr 〉 is an l-configuration, σ ( c) denotes the state q and ι( c) denotes the r-tuple 〈Iμ1 , . . . , Iμr 〉.If c = 〈 q, Iμ1 , . . . , Iμr 〉 is an l-configuration, we denote by enb
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
(c) (short for enabled )the set of transitions τ ∈ T L \ { idle } such that 〈q, τ, q′ 〉 ∈ δL , for some q′ ∈ Q L , and either τ ∈ T L > out ∪ T L > local or one of the following holds: (a) τ =μ=0 (μ ∈ T L > in ) and Iμ = ∅ ;(b) τ =μ=1 (μ ∈ T L > in ) and |Iμ| = 1; (c) τ =μ≥1 (μ ∈ T L > in ) and |Iμ| ≥ 1; (d) τ =μ>1 (μ ∈ T L > in ) and |Iμ| > 1; (e) τ =μall (μ ∈ T L > in ) and Iμ = A.We shall refer to a transition τ ∈ enb (c) as an enabled transition. Intuitively, τ ∈ enb (c) if τ is one of the available transitions for L when L’s configuration is c. Thus, all transitions in which a message is broadcast and all local transitions are enabled, whereas transitions in which the leader reacts to an inbox are enabled only if the inbox’s corresponding cardinality constraints are satisfied. Given our intended view of inboxes as records of followers from which the leader has a specific message, we wish to enforce at each moment of time a form of persistence, i.e. that each inbox can grow (when new messages arrive) but never loses its content, unless the leader takes a transition deleting that content. To this end, for each τ ∈ T L , we define the relation τ over r-tuples 〈I 1, . . . , I r 〉, 〈J 1, . . . , J r 〉, where I j , J j ⊆ A (1 ≤ j ≤ r), as follows: (a) if τ =μ=1
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
,μ≥1 ,μ>1 ,μall for all μ ∈ T L > in , 〈I 1, . . . , I r 〉 τ 〈J 1, . . . , J r 〉 iff I j ⊆ J j (for all 1 ≤ j ≤ r); (b) if τ =μ=1 ,μ≥1 ,μ >1 , or μall for some μ =μi ∈ T L > in , 〈I 1, . . . , I r 〉 τ 〈J 1, . . . , J r 〉 iff J i = ∅ and I j ⊆ J j (for all 1 ≤ j ≤ r, j = i). A run for L over A is a sequence R = {〈 cn , τ n 〉} n∈N, where cn = 〈 q n , I > μ1 > n , . . . , I > μrn 〉 (n ∈ N) is an l-configuration and τn ∈ T L (n ∈ N), such that: q0 ∈ Q L > init , I > μi > 0 = ∅ (for all 1 ≤ i ≤ r); for all n ∈ N, ι( cn ) τn ι( cn+1) (persistence); and, for all n ∈ N,(a) τn ∈ enb (cn ) and 〈σ ( cn ), τ n , σ ( cn+1)〉 ∈ δL ; or (b) enb (cn ) = ∅ , τn = idle , and σ ( cn ) = σ ( cn+1).Intuitively, a run describes a valid execution for L: L starts at an initial state with all its inboxes empty, and, at each moment of time, chooses an enabled (at that time) transition # 123 448 Formal Methods in System Design (2021) 58:440–468 or becomes idle if none exists. Inboxes can grow at any moment of time as a result
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
of new messages arriving, except when their content is being deleted. The following simple lemma should be clear from the above. It will be useful when proving that the logical formula in Sect. 4.1 describing the leader’s execution is correct. Lemma 1 Let R = {〈 cn , τ n 〉} n∈N be a run for L over a set A. For all n ∈ N, if τn =μ=1, > μ≥1,μ >1,μall (μ ∈ T Lin ) and a ∈ I > μ > n , then a ∈ I > μ > n+1 . 3.3 Followers and their execution Let T F > in = { μ1, . . . , μr }, T F > out = { μ1, . . . , μs }, and T F > local = { 1, . . . , t } be sets of symbols (note that μ and μ are different symbols). A follower is a quadruple F = 〈 Q F , Q F > init , T F , δ F 〉, where • Q F is a finite set, the set of states of F; • Q F > init ⊆ Q F are the initial states of F; • T F = T F > in ∪ T F > out ∪ T F > local ∪ { idle } is the set of transitions of F; and • δF ⊆ Q F × (T F \ { idle }) × Q F is the transition relation of F.Intuitively, the sets T F > in , T F > out , and T F > local are respectively the sets of all possible ingoing messages, possible outgoing messages, and local actions of F; thus, according to the nota-tional conventions in Sect.
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
3.1, T F > in , T F > out , and T F > local are respectively the sets of labels for the transitions in which F reacts to a message in its inbox, sends a message to the leader, and the set of F’s local actions. The transition idle is a special transition each follower takes when it is unable to take any other transition. We define the size of F, denoted ‖F‖, to be the quantity |Q F | + | T F | + | δF |. For some example followers see Sect. 5. We describe the execution of a follower as a sequence of certain configurations. Let F be a follower as above. An f-configuration (short for follower configuration ) is a pair 〈q, I〉,where q ∈ Q F and I ⊆ T F > in . Intuitively, q is F’s state at a given moment of time and I ⊆ T F > in is its inbox at that moment of time. At any moment of time, I is to be viewed as a record of messages (from the leader) to which F has not yet reacted. If c = 〈 q, I〉 is an f-configuration, we denote by enb (c) (short for enabled ) the set of transitions τ ∈ T F \ { idle } such that 〈q, τ, q′ 〉 ∈ δF , for some q′ ∈ Q F , and either (a) τ ∈ T F > out ∪ T F > local or (b) τ =μ ∈ T F > in and μ ∈ I. Intuitively, τ ∈ enb (c) if τ is one of the available transitions for F when F’s configuration is c. Thus, all transitions in which a message is sent and all local transitions are
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
enabled, whereas transitions in which the follower reacts to a message are enabled only if the corresponding message is present in I.As in the leader’s case, we want to enforce at each moment of time a form of persistence for the inbox I, i.e. that I can grow (when a new message arrives from the leader) but no message is lost, unless the follower reacts to that message (in which case the message is deleted). To this end, for each τ ∈ T F , we define the relation τ over sets I , J ⊆ T F > in as follows: (a) if τ / ∈ T F > in , I τ J iff I ⊆ J ;(b) if τ =μ ∈ T F > in , I τ J iff I \ { μ} ⊆ J and μ / ∈ J .A run for F is a sequence R = {〈 cn , τ n 〉} n∈N, where cn = 〈 q n , In 〉 (n ∈ N) is an f-configuration and τn ∈ T F (n ∈ N), such that: q0 ∈ Q F > init , I0 = ∅ ; for all n ∈ N, In τn In+1 (persistence); and, for all n ∈ N, # 123 Formal Methods in System Design (2021) 58:440–468 449 (a) τn ∈ enb (cn ) and 〈q n , τ n , q n+1〉 ∈ δF ; or (b) enb (cn ) = ∅ , τn = idle , and q n = q n+1 .Intuitively, a run describes a valid execution for F: F starts at an initial state with its inbox empty, and, at each moment of time, chooses an enabled (at that time) transition or becomes idle if none exists. Messages persist in F’s inbox,
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
unless explicitly deleted when a transition in T F > in is taken. The following simple lemma should be clear from the above. It will be useful when proving that the logical formula in Sect. 4.2 describing the followers’ execution is correct. Lemma 2 Let R = {〈 cn , τ n 〉} n∈N be a run for F. For all n ∈ N, if τn =μ (∈ T Fin ), and > μ ∈ In , then μ ∈ In+1. 3.4 Distributed machines and their execution In the ensuing part, we employ the following notation: for any two sets T1 = { μ1, . . . , μi } and T2 = { μ1, . . . , μ j }, we write T1 T2 when the sets T1 and T2 are equal modulo removing the arrows, i.e. T1 T2 when μ ∈ T1 iff μ ∈ T2 . (Likewise T2 T1 .) A distributed machine is a pair M = 〈 L, F〉, where L is a leader, F is a (replicated) follower, T L > in ∩ T F > in = ∅ , T L > in T F > out and T F > in T L > out . (The latter two constraints are to ensure that each message μ broadcast by the leader is a valid ingoing message μ to the followers and for each message μ sent by a follower, the leader has a corresponding inbox. The one before the latter two is to avoid ambiguities in the logical translation presented in Sect. 4.) Let M = 〈 L, F〉 be a distributed machine and A = { a1, . . . , a k } (k > 0) be a set, referred to
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
as the universe of M. Intuitively, each a ∈ A is identified with a (replicated) follower F. A run for M over A is a (k + 1)-tuple R = 〈 R0, R1, . . . , Rk 〉,where R0 = {〈 c0 > n , τ 0 > n 〉} n∈N (c0 > n = 〈 q0 > n , I > μ1 > n , . . . , I > μrn 〉, {μ1, . . . , μr } = T L > in ) is a run for L over A and each Ri = {〈 cin , τ in 〉} n∈N (1 ≤ i ≤ k) ( cin = 〈 q in , Iin 〉) is a run for F, such that the following conditions hold: (A1) If τ 0 > n = μ ∈ T L > out (n ∈ N), then, for each i (1 ≤ i ≤ k), there exists n′ > n such that > μ ∈ Iin′ ; and, for each i (1 ≤ i ≤ k), if μ ∈ Iin (n ∈ N), there exists n′ n′ = μ.(A2) For each i (1 ≤ i ≤ k), if τ in = μ ∈ T F > out , there exists n′ > n such that ai ∈ I > μ > n′ ; and, if ai ∈ I > μ > n (1 ≤ i ≤ k, n ∈ N), there exists n′ < n such that τ in′ = μ.Intuitively, (A1) states that if the leader broadcasts a message μ, a message μ will even-tually appear in each follower’s inbox; and if a message μ is in a follower’s inbox, a message μ has been broadcast
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
by the leader at some point in the past. Similarly, (A2) states that if a follower a ∈ A sends a message μ to the leader, a will eventually appear in the inbox Iμ;and if a ∈ Iμ, a message μ has been sent by a to the leader at some point in the past. Conditions (A1) and (A2) describe an asynchronous network (i.e. a network in which message delivery takes an arbitrary amount of time). For a synchronous network (assuming message delivery takes one time step), conditions (A1) and (A2) above should be replaced with the following two conditions: (S1) If τ 0 > n = μ ∈ T L > out (n ∈ N), then, for each i (1 ≤ i ≤ k), μ ∈ Iin+1 ; and, for each i (1 ≤ i ≤ k), if μ / ∈ Iin and μ ∈ Iin+1 , then τ 0 > n = μ (n ∈ N). (S2) For each i (1 ≤ i ≤ k), if τ in = μ ∈ T F > out , then ai ∈ I > μ > n+1 ; and, if ai /∈ I > μ > n and ai ∈ I > μ > n+1 (1 ≤ i ≤ k), then τ in = μ (n ∈ N). # 123 450 Formal Methods in System Design (2021) 58:440–468 To distinguish a distributed machine whose runs satisfy conditions (A1) and (A2) above from a distributed machine whose runs satisfy conditions (S1) and (S2) above, we shall refer to the former type of machine as an asynchronous distributed machine and to the latter type as a synchronous distributed machine. We say that a distributed machine M = 〈 L, F〉 (asynchronous or synchronous) is runnable if there is a
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
run for M over some universe A ={a1, . . . , a k } (k > 0). Remark 1 The behaviour of a synchronous distributed machine when the delivery of a mes-sage from a follower to the leader coincides with the leader deleting the content of the corresponding inbox or when the delivery of a message from the leader to a follower coin-cides with the follower reacting to it and thus deleting it (the message could already be present in the follower’s inbox due to an earlier delivery) is undefined . It should be clear that the set of all runs of a synchronous distributed machine captures all well-defined (i.e. not undefined) behaviour. In case of undefined behaviour the reader can imagine, for example, the network “dying” and the distributed machine terminating abruptly, or it being left in an inconsistent state, for example, not deleting or not delivering a message when it should. ## 4 Translation to logic Given an asynchronous distributed machine M, we can (automatically) construct an MFOTL -sentence Spec (M) (with ‖Spec (M)‖ quadratic in ‖M‖) such that M is runnable if and only if Spec (M) is satisfiable. (As we see in Sect. 4.5, for any synchronous distributed machine N , we can construct a similar to Spec (M) sentence Spec ′(N ) such that N is runnable if and only if Spec ′(N ) is satisfiable.) To this end, let M = 〈 L, F〉 be an asynchronous distributed machine. Spec (M) is defined over the signature M comprising a nullary predicate sl q for each state q ∈ Q L ; a unary predicate sf q (·) for each state q ∈ Q F ; the symbols in T L > in and T F > in as unary predicates; for each symbol
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
μ ∈ T L > out , a nullary predicate past μ; for each symbol μ ∈ T F > out , a unary predicate past μ (·); a nullary predicate tl τ for each τ ∈ T L ; and a unary predicate tf τ (·) for each τ ∈ T F . For each q ∈ Q L , sl q (short for state leader ) is to be viewed as stating that the leader is at state q. For each q ∈ Q F , sf q (a) (short for state follower ) is to be viewed as stating that follower a is at state q. For each μ ∈ T L > in ,μ( a) is to be viewed as stating that there is a message μ to the leader originating from follower a (i.e. a ∈ Iμ). For each μ ∈ T F > in ,μ( a) is to be viewed as stating that there is a message μ to follower a originating from the leader (i.e. μ is in a’s inbox). For each μ ∈ T L > out , past μ is to be viewed as stating that the leader has in the past broadcast a message μ. For each μ ∈ T F > out , past μ (a) is to be viewed as stating that follower a has in the past sent a message μ to the leader. For each τ ∈ T L , tl τ (short for transition leader ) is to be viewed as stating that the leader takes transition τ . For each τ ∈ T F , tf τ (a) (short for transition follower ) is to be viewed as stating that follower a takes transition τ .We now proceed to write the constituent parts of
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
Spec (M). 4.1 The leader’s execution We first write a collection of formulas describing the execution of the leader. The following two formulas (short for unique state leader and unique transition leader respectively) state that the leader’s states and transitions are unique: # 123 Formal Methods in System Design (2021) 58:440–468 451 ustatel := ∨ > q∈QL (sl q ∧ ∧ > q′∈QL\{ q} ¬sl q′ ), utransl := ∨ > τ∈TL (tl τ ∧ ∧ > τ′∈TL\{ τ} ¬tl τ ′ ). The next formula (short for initial leader ) describes the initial conditions for the leader’s execution, i.e. that the leader starts at an initial state with all its inboxes empty: initl := ∨ > q∈QL > init sl q ∧ ∧ > μ∈TL > in ∀x ¬μ( x) The next formula (short for persistence leader ) is the persistence condition for the leader’s inboxes: inboxes do not lose their content (although they can grow due to the arrival of new messages), except when a transition τ =μ=1 ,μ≥1 ,μ >1 , or μall (μ ∈ T L > in ) (which deletes the content of its corresponding inbox) is taken. In the following definition we slighty abuse the notation tl τ (τ ∈ T L ) for brevity: we write tl τ1,...,τ j (τ1, . . . , τ j ∈ T L ) as a shorthand for tl τ1 ∨ · · · ∨ tl τ j . Let persl := ∧ > μ∈TL > in (( (tl μ=1,μ≥1,μ>1,μall ) → ∀x ¬μ( x)) ∧ (¬(tl μ=1,μ≥1,μ >1,μall ) → ∀ x(μ( x) →μ( x)) )) . The next family of formulas (short for enabled leader ) describe the necessary conditions for a transition to be enabled. They are part of the formulas that describe the
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
step-by-step execution of the leader. For each τ ∈ T L \ { idle }, let enbl τ := ⎧⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎩ , if τ ∈ T L > out ∪ T L > local ;∀x ¬μ( x), if τ =μ=0 ∈ T L > in ;∃ =1 xμ( x), if τ =μ=1 ∈ T L > in ;∃ ≥1 xμ( x), if τ =μ≥1 ∈ T L > in ;∃>1 xμ( x), if τ =μ>1 ∈ T L > in ;∀xμ( x), if τ =μall ∈ T L > in . The next formula (short for step leader ) describes the step-by-step execution of the leader: at each moment of time the leader takes an enabled transition or becomes idle if none exists. Let stepl be the logical disjunction of the following two formulas: ∨ > 〈q,τ, q′〉∈ δL (sl q ∧ enbl τ ∧ tl τ ∧ sl q′ ), ∨ > q∈QL (sl q ∧ ∧ > 〈q,τ, q′〉∈ δL ¬enbl τ ∧ tl idle ∧ sl q ). Finally, the formula leader := initl ∧ (ustatel ∧ utransl ∧ persl ∧ stepl ) describes the leader’s whole operation. It is clear that ‖leader ‖ = O(‖L‖2). 4.2 The followers’ execution Next, we write a collection of formulas describing the execution of each follower. # 123 452 Formal Methods in System Design (2021) 58:440–468 The following formulas (short for unique state follower and unique transition follower respectively) state that the states and transitions of follower x are unique: ustatef (x) := ∨ > q∈QF (sf q (x) ∧ ∧ > q′∈QF\{ q} ¬sf q′ (x)), utransf (x) := ∨ > τ∈TF (tf τ (x) ∧ ∧ > τ′∈TF\{ τ} ¬tf τ ′ (x)). The next formula (short for initial follower ) describes the initial conditions for the execu-tion of
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
follower x, i.e. that follower x starts at an initial state with its inbox empty: initf (x) := ∨ > q∈QF > init sf q (x) ∧ ∧ > μ∈TF > in ¬μ( x) The next formula (short for persistence follower ) is the persistence condition for the inbox of follower x: the inbox does not lose any messages (although it can grow due to the arrival of new ones), except when a transition τ ∈ T F > in (which deletes the corresponding message) is taken. Let persf (x) := ∧ > τ=μ∈TF > in (( tf τ (x) → ¬μ( x)) ∧ (¬tf τ (x) → (μ( x) →μ( x)) )) . The next family of formulas (short for enabled follower ) describe the necessary conditions for a transition to be enabled. They are part of the formulas that describe the step-by-step execution of a follower x. For each τ ∈ T F , let enbf τ (x) := { , if τ ∈ T F > out ∪ T F > local ;μ( x), if τ =μ ∈ T F > in . The next formula (short for step follower ) describes the step-by-step execution of follower x: at each moment of time follower x takes a feasible transition or becomes idle if none exists. Let stepf (x) be the logical disjunction of the following two formulas: ∨ > 〈q,τ, q′〉∈ δF (sf q (x) ∧ enbf τ (x) ∧ tf τ (x) ∧ sf q′ (x)), ∨ > q∈QF (sf q (x) ∧ ∧ > 〈q,τ, q′〉∈ δF ¬enbf τ (x) ∧ tf idle (x) ∧ sf q (x)). Finally, the formula follower (x) := initf (x) ∧ (ustatef (x) ∧ utransf (x) ∧ persf (x) ∧ stepf (x)) describes the leader’s whole operation. It is
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
clear that ‖follower (x)‖ = O(‖F‖2). 4.3 The distributed machine’s execution Next, we write a collection of formulas describing the network of the leader and its followers, and, combining these formulas with the ones in the previous two subsections, we form Spec (M). # 123 Formal Methods in System Design (2021) 58:440–468 453 The following two formulas enforce the intended semantics for the predicates past μ ( μ ∈ T L > in ) and past μ (·) ( μ ∈ T F > in ). Recall from the beginning of this section that past μ ( μ ∈ T L > in ) is to be read as “a message μ has in the past been broadcast by the leader” and past μ (x) ( μ ∈ T F > in ) as “follower x has in the past sent a message μ to the leader”. Thus, past μ must be false until (and when) the leader takes transition tl μ (if it ever does) and true thereafter; and likewise for past μ (x) and tf μ (x). Let pastm (short for past messages ) be the logical conjunction of the following two formulas: ∧ > μ∈TL > out ((¬past μ ∧ ¬ past μ W tl μ ) ∧ [(( ¬past μ ∧ ¬ tl μ ∧ tl μ ) → ¬past μ ) ∧ (tl μ → past μ )]), ∀x ∧ > μ∈TF > out ((¬past μ (x) ∧ ¬ past μ (x) W tf μ (x)) ∧ [(( ¬past μ (x) ∧ ¬ tf μ (x) ∧ tf μ (x)) → ¬past μ (x)) ∧ (tf μ (x) → past μ (x)) ]). The following two formulas specify the conditions for message delivery when the leader broadcasts a message to the followers ( bcastla ,
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
short for broadcast leader asynchronous ) and when a follower sends a message to the leader ( sendfa , short for send follower asynchronous ). (Recall that the network is asynchronous.) They correspond to conditions (A1) and (A2) respectively from Sect. 3.4. bcastla := ∧ > μ∈TL > out (tl μ → ∀ x ♦μ( x)) ∧ ∀x ∧ > μ∈TF > in ( > μ( x) → past μ ), sendfa := ∀ x ∧ > μ∈TF > out (tf μ (x) → ♦μ( x)) ∧ ∀x ∧ > μ∈TL > in ( > μ( x) → past μ (x)). Notice that, since T L > out T F > in (resp. T F > out T L > in ), the symbol μ ∈ T F > in (resp. μ ∈ T L > in ), and, thus, the predicate μ( ·) appearing in the first conjunct of bcastla (resp. sendfa ) exists. Likewise, the nullary predicate past μ (resp. unary predicate past μ (·)) appearing in the second conjunct of bcastla (resp. sendfa ) exists. Finally, the following formula neta (short for network asynchronous ) describes the oper-ation of the asynchronous network comprising the leader and its followers: neta := pastm ∧ (bcastla ∧ sendfa ). It is clear that ‖neta ‖ = O(‖L‖ + ‖ F‖).We are now ready to give a full logical description of M. Let Spec (M) := leader ∧ ∀ x follower (x) ∧ neta . With regard to size, it follows that ‖Spec (M)‖ = O(‖M‖2). Remark 2 The assumption that each message can be delivered multiple times is natural (as it applies to many common protocols), but also favourable because it simplifies the network encoding. Indeed, to enforce the condition that if a message μ is
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
sent then a message μ is received (by the intended recipient(s)) at some point in the future (possibly at different times by different recipients), we simply state that if tl μ or tf μ (x) (for any follower x) holds true at any moment then ♦μ( x) holds true next. That μ can be received multiple times is # 123 454 Formal Methods in System Design (2021) 58:440–468 simply a consequence of the semantics of the operator ♦. In some cases this behaviour may be unwanted. (For example, consider a scenario, such as an asynchronous version of the Control-MAC protocol in Sect. 5.3, in which a follower awaits a ←−go or a ←−−nogo message to enter or not enter respectively a critical section, and, at a given round of the protocol, it receives both a ←−go and a ←−−nogo message, the first being the intended message and the second being a re-delivery from a previous round, leaving the follower in an inconsistent state.) At the time of writing, the authors know of no way of enforcing delivery of messages exactly once within the current approach. One possibility could be to parameterize each message delivery to a recipient x with an identifier y. Then, one could state that a delivery with identifier y to any recipient x is followed by no delivery with identifier y. (In the absence of identifiers for deliveries, a similar condition would block future deliveries of a message, even if the message were re-sent. In contrast, in the presence of identifiers, a re-sent message could still be delivered using a new identifier.) Unfortunately, this approach results in formulas that are not monodic. 4.4 Correspondence between runs and models We now show that an asynchronous distributed machine M is runnable if and only if Spec (M) is satisfiable.
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
Lemma 3 Let M = 〈 L, F〉 be an asynchronous distributed machine and Spec (M) as above. If M is runnable, then Spec (M) is satisfiable over a finite domain. Proof Let A = { a1, . . . , a k } (k > 0) and let R = 〈 R0, R1, . . . , Rk 〉 be a run for M over A. Thus, R0 = {〈 c0 > n , τ 0 > n 〉} n∈N is a run for L over A and each Ri = {〈 cin , τ in 〉} n∈N (1 ≤ i ≤ k) is a run for F. Recall that for each n ∈ N, assuming that T L > in = { μ1, . . . , μr }, c0 > n = 〈 q0 > n , I > μ1 > n , . . . , I > μrn 〉, where I > μjn ⊆ A (1 ≤ j ≤ r); and cin = 〈 q in , Iin 〉 (1 ≤ i ≤ k), where Iin ⊆ T F > in (1 ≤ i ≤ k). Let M be as in the beginning of this section. We construct from R a sequence M = { An }n∈N, where each An (n ∈ N) is a M -structure with universe A, such that Spec (M) is true in M. For each n ∈ N, let An be such that: (a) for each q ∈ Q L , sl Anq = if q = q0 > n , otherwise sl Anq = ⊥ ;(b) for each μ ∈ T L > in ,μAn = I > μ > n ;(c) for each μ ∈ T L > out , past An > μ = if
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
τ 0 > n′ = μ for some n′ μ = ⊥ ;(d) for each τ ∈ T L , tl An > τ = if τ 0 > n = τ , otherwise tl An > τ = ⊥ ;(e) for each q ∈ Q F , sf Anq = { ai ∈ A | q in = q};(f) for each μ ∈ T F > in ,μAn = { ai ∈ A |μ ∈ Iin };(g) for each μ ∈ T F > in , past An > μ = { ai ∈ A | ∃ n′ τ = { ai ∈ A | τ in = τ }.We now show that leader , ∀x follower (x), and neta are all true in M. It then follows that Spec (M) is true in M.Starting with the leader, it is easily obtained from the definition of a run for L together with (a), (b), and (d) that A0 | initl and, for all n ∈ N, An | ustatel and An | utransl . To show that, for all n ∈ N, An | persl , let μ ∈ T L > in . If An | tl μ=1,μ≥1,μ>1,μall , i.e. An | tl μ=1 , tl μ≥1 , tl μ>1 , or tl μall , then, from (d), τ 0 > n =μ=1 ,μ≥1 ,μ>1 , or μall , which implies that I > μ > n+1 = ∅ (from the definition of a run for L), which, in turn, implies due to (b) that An | ∀x ¬μ( x); and if An | ¬ (tl μ=1,μ≥1,μ >1,μall ), i.e. An |
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
¬ tl μ=1 , ¬tl μ≥1 , ¬tl μ >1 , and ¬tl μall , then, from (d), # 123 Formal Methods in System Design (2021) 58:440–468 455 τ 0 > n =μ=1 ,μ≥1 ,μ >1 ,μall , which by Lemma 1 implies that, for all a ∈ A, if a ∈ I > μ > n then a ∈ I > μ > n+1 , which, in turn, implies due to (b) that An | ∀ x(μ( x) →μ( x)); consequently An | (( tl μ=1,μ≥1,μ>1,μall ) → ∀x ¬μ( x)) ∧ (¬(tl μ=1,μ≥1,μ >1,μall ) → ∀ x(μ( x) →μ( x))) . That An | persl is then evident. To show that, for all n ∈ N, An | stepl , we consider two cases. If enb (c0 > n ) = ∅ , we have τ 0 > n ∈ enb (c0 > n ). Thus, from (a) and (d), An | sl q0 > n , An | tl τ 0 > n ,and An | sl q0 > n+1 . Further, it is straightforward to establish from the definition of enbl τ 0 > n and (b) that An | enbl τ 0 > n . Consequently, An | sl q0 > n ∧ enbl τ 0 > n ∧ tl τ 0 > n ∧ sl q0 > n+1 and An satisfies the first disjunct of stepl . If enb (c0 > n ) = ∅ , we have τ 0 > n = idle and q0 > n = σ ( c0 > n ) = σ ( c0 > n+1 ) = q0 > n+1 . Thus, from (a) and (d), An | sl q0 > n , An | tl idle , and An | sl q0 > n
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
. Further, it is straightforward to establish from the definition of enbl τ (τ ∈ T L \{ idle }) and (b) that An | ∧ > 〈q0 > n,τ, q′〉∈ δL ¬enbl τ . (The latter still holds when the conjunction is empty, in which case it evaluates to by convention.) Consequently, An | sl q0 > n ∧∧ > 〈q0 > n,τ, q′〉∈ δL ¬enbl τ ∧tl idle ∧ sl q0 > n and An satisfies the second disjunct of stepl . In any case, An | stepl . As a result of the above, leader is true in M.Moving to the followers, it is easily obtained from the definition of a run for F together with (e), (f), and (h) that, for all ai ∈ A, A0 | initf (ai ) and, for all n ∈ N, for all ai ∈ A, An | ustatef (ai ) and An | utransf (ai ). To show that, for all n ∈ N, for all ai ∈ A, An | persf (ai ), let τ =μ ∈ T F > in . If An | tf τ (ai ), then, from (h), τ in = τ , which implies that μ / ∈ Iin+1 (from the definition of a run for F), which, in turn, implies due to (f) that An | ¬μ( ai ); and if An | ¬ tf τ (ai ), then, from (h), τ in =μ, which by Lemma 2 implies that if μ ∈ Iin then μ ∈ Iin+1 , which, in turn, implies due to (f) that An | μ( ai ) →μ( ai );consiquently An | (tf τ (ai ) → ¬μ( ai )) ∧ (¬tf τ (ai ) → (μ( ai ) →μ( ai ))) . That An |
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
persf (ai ) is then evident. To show that, for all n ∈ N, for all ai ∈ A, An | stepf (ai ),we consider two cases. If enb (cin ) = ∅ , we have τ in ∈ enb (cin ). Thus, from (e) and (h) above, An | sf q in (ai ), An | tf τ in (ai ), and An | sf q in+1 (ai ). Further, it is straightforward to establish from the definition of enbf τ in (ai ) and (f) that An | enbf τ in (ai ). Consequently An | sf q in (ai ) ∧ enbf τ in (ai ) ∧ tf τ in (ai ) ∧ sf q in+1 (ai ) and An satisfies the first disjunct of stepf (ai ). If enb (cin ) = ∅ , we have τ in = idle and q in = q in+1 . Thus, from (e) and (h) above, An | sf q in (ai ), An | tf idle (ai ), and An | sf q in (ai ). Further, it is straightforward to establish from the definition of enbf τ (ai ) (τ ∈ T F \{ idle }) and (f) that An | ∧ > 〈q0 > n,τ, q′〉∈ δF ¬enbf τ (ai ).(The latter still holds when the conjunction is empty, in which case it evaluates to by convention.) Consequently, An | sf q in (ai )∧∧ > 〈qin,τ, q′〉∈ δF ¬enbf τ (ai )∧tf idle (ai )∧ sf q in (ai ) and An satisfies the second disjunct of stepf (ai ). In any case, An | stepf (ai ). As a result of the above, for all n ∈ N, for all ai ∈ A, An | follower (ai ), from which we obtain
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
the truth of ∀x follower (x) in M.Moving to neta , we first show that pastm is true in M. For the first conjunct of pastm ,let μ ∈ T L > out . If τ 0 > n = μ for all n ∈ N, then, from (d), An | ¬ tl μ for all n ∈ N, and, from (c), An | ¬ past μ for all n ∈ N. It follows that A0 | ¬past μ, thus A0 | ¬ past μ W tl μ, and, as a result, A0 | ¬ past μ ∧ ¬ past μ W tl μ. Further, for all n ∈ N, An | (¬past μ ∧ ¬ tl μ ∧ tl μ ) → ¬past μ and An | tl μ → past μ trivially. Therefore, the first conjunct of pastm is true in M. Otherwise, let t be the smallest number such that At | tl μ. Thus, from (d), An | ¬ tl μ for all n t. Now, for all n ∈ N, we claim An | (¬past μ ∧ ¬ tl μ ∧ tl μ ) → ¬past μ. Indeed, the latter holds trivially for all n if t = 0, and for all n = t − 1 if t > 0; further, if t > 0, we have At−1 | ¬ past μ ∧ ¬ tl μ ∧ tl μ and At | ¬ past μ, thus it holds for n = t − 1 as well. Finally, it is clear that An | tl μ → past μ for all n ∈ N. Therefore, the first conjunct of
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
# 123 456 Formal Methods in System Design (2021) 58:440–468 pastm is true in M. The argument for the second conjunct is completely analogous. Thus, pastm is true in M. It is straightforward to show that bcastla and sendfa are true in M.As a result, neta is true in M. For the converse of Lemma 3, we require the following two auxiliary lemmas: Lemma 4 Let M = 〈 L, F〉 be a distributed machine; let A be a finite, non-empty set; let M = { An }n∈N, where each An (n ∈ N) is a M -structure with universe A, be a model of Spec (M); and let past μ be the nullary predicate in M corresponding to the symbol μ ∈ T Lout . For all n ∈ N, (a) if An | past μ, there exists n ′ 0. Because A0 | ¬ past μ W tl μ, A0 | ¬past μ or A0 | ¬ past μ Utl μ.Since An | past μ, we have A0 | ¬past μ, therefore A0 | ¬ past μ Utl μ. Thus, let n′ be the smallest number such that An′ | tl μ.
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
An | past μ implies, then, that n′ ≤ n. It also follows that An′ −1 | ¬ past μ ∧ ¬ tl μ ∧ tl μ. Since Am | (¬past μ ∧ ¬ tl μ ∧ tl μ ) → ¬past μ for all m ∈ N, we must have An′ | ¬ past μ, thus n′ 0. From A0 | ¬ past μ W tl μ, we have that either A0 | ¬past μ or A0 | ¬ past μ U tl μ. In the former case, since Am | tl μ → past μ for all m ∈ N, it follows that A0 | ¬tl μ, and, as a result, An′ | ¬ tl μ for all n′ < n. In the latter case, let n′′ be the smallest number such that An′′ | tl μ. Since Am | tl μ → past μ for all m ∈ N, n ≤ n′′ . It follows that An′ | ¬ tl μ for all n′ < n. Lemma 5 Let M = 〈 L, F〉 be a distributed machine; let A be a finite, non-empty set; let M = { An }n∈N, where each An (n ∈ N) is a M -structure with universe A, be a model of Spec (M); and let past μ (·)
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
be the unary predicate in M corresponding to the symbol μ ∈ T Fout . Let a ∈ A. For all n ∈ N, (a) if An | past μ (a), there exists n ′ 0) and let M = { An }n∈N be a sequence, where each An (n ∈ N) is a M -structure ( M as in the beginning of this section) with universe A, such that Spec (M) is true in M. We construct from M a run R = 〈 R0, R1, . . . , Rk 〉 for M over A. That is, we construct R such that R0 = {〈 c0 > n , τ 0 > n 〉} n∈N is a run for L over A and each Ri = {〈 cin , τ in 〉} n∈N (1 ≤ i ≤ k) is a run for F over A. In the ensuing part, we assume that T L > in = { μ1, . . . , μr }. For each n ∈ N:(a) set c0 > n = 〈 q0 > n , I > μ1 > n , . . . , I >
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
μrn 〉, such that An | sl q0 > n and I > μin =μAni (1 ≤ i ≤ r); # 123 Formal Methods in System Design (2021) 58:440–468 457 (b) set τ 0 > n = τ ∈ T L such that An | tl τ ;(c) for each i (1 ≤ i ≤ k), set cin = 〈 q in , Iin 〉, such that An | sf q in (ai ) and Iin = { μ ∈ T F > in | An | μ( ai )};(d) for each i (1 ≤ i ≤ k), set τ in = τ ∈ T F such that An | tf τ (ai ).It is a consequence of the assumption that Spec (M) is true in M that for all n ∈ N, An | ustatel and An | utransl ; and, for all n ∈ N, for all i (1 ≤ i ≤ k), An | ustatef (ai ) and An | utransf (ai ). Thus q0 > n and τ 0 > n above, as well as q in and τ in (1 ≤ i ≤ k), are well-defined. We next show that R0 is a run for L over A. Since A0 | initl we have from (a) that q0 > n ∈ Q L > init and I > μi > 0 = ∅ (for all 1 ≤ i ≤ r). Now, it is a consequence of the assumption that Spec (M) is true in M that An | persl and An | stepl , for all n ∈ N. To show that ι( c0 > n ) τ 0 > n ι( c0 > n+1 ), for all n ∈ N, we consider two possibilities: if τ 0 > n =μ=1 ,μ≥1 ,μ >1
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
,μall for all μ ∈ T L > in , which, due to (b), implies that An | ¬ tl μ=1,μ≥1,μ>1,μall for all μ ∈ T L > in ,then, because An | persl , An | ∀ x(μ( x) →μ( x)) for all μ ∈ T L > in , which, due to (a), implies that I > μjn ⊆ I > μjn+1 (for all 1 ≤ j ≤ r); and if τ 0 > n =μ=1 ,μ≥1 ,μ>1 ,μall for some μ =μi ∈ T L > in , which, due to (a), implies that An | tl μ=1,μ≥1,μ>1,μall and (because An | utransl ) An | ¬ tl μ=1 > j,μ≥1 > j,μ>1 > j,μall > j for all 1 ≤ j ≤ r, j = i, then, because An | persl , An | ∀x ¬μi (x) and An | ∀ x(μ j (x) →μ j (x)) (for all 1 ≤ j ≤ r, j = i), whence, due to (a), I > μin+1 = ∅ and I > μjn ⊆ I > μjn+1 (for all 1 ≤ j ≤ r, j = i). That ι( c0 > n ) τ 0 > n ι( c0 > n+1 ) is then evident. Finally, given that An | stepl , it follows that An | sl q ∧ enbl τ ∧ tl τ ∧ sl q′ ,for some 〈q, τ, q′ 〉 ∈ δL , or An | sl q ∧ ∧ > 〈q,τ, q′〉∈ δL ¬enbl τ ∧ tl idle ∧ sl q , for some q ∈ Q L . For the former case, it follows from (a) that q0 > n = q and q0 > n+1 = q′, and from (b) that τ 0 > n = τ ; and,
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
for the latter case, it follows from (a) that q0 > n = q0 > n+1 = q and from (b) that τ 0 > n = idle . That is, 〈σ ( c0 > n ), τ 0 > n , σ ( c0 > n+1 ) = 〈 q0 > n , τ 0 > n , q0 > n+1 〉 = 〈 q, τ, q′ 〉 ∈ δL or τ 0 > n = idle and σ ( c0 > n ) = q0 > n = q0 > n+1 = σ ( c0 > n+1 ). It is straightforward to show from An | enbl τ (a consequence of the assumption that An | sl q ∧ enbl τ ∧ tl τ ∧ sl q′ ) and (a) that τ 0 > n (= τ ) ∈ enb (c0 > n ); and from An | ∧ > 〈q,τ, q′〉∈ δL ¬enbl τ (a consequence of the assumption that An | sl q ∧ ∧ > 〈q,τ, q′〉∈ δL ¬enbl τ ∧ tl idle ∧ sl q ) and (a) that enb (c0 > n ) = ∅ .Thus, we have established that τ 0 > n ∈ enb (c0 > n ) and 〈σ ( c0 > n ), τ 0 > n , σ ( c0 > n+1 )〉 ∈ δL , or enb (c0 > n ) = ∅ , τ 0 > n = idle , and σ ( c0 > n ) = σ ( c0 > n+1 ), for all n ∈ N.We next show that Ri (for all 1 ≤ i ≤ k) is a run for F over A. Since A0 | initf (ai ) we have from (c) that q in ∈ Q F > init and
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
Ii > 0 = ∅ (1 ≤ i ≤ k). It is a consequence of the assumption that Spec (M) is true in M that An | persf (ai ) and An | stepf (ai ), for all n ∈ N. To show that Iin τ in Iin+1 , for all n ∈ N, we consider two possibilities: if τ in /∈ T F > in ,which, due to (d), implies that A | ¬ tf μ (ai ) for all μ ∈ T F > in , then, because An | persf (ai ), An | μ( ai ) →μ( ai ) for all μ ∈ T F > in , which, due to (c), implies that Iin ⊆ Iin+1 ;and if τ in =μ ∈ T F > in , which, due to (d), implies that An | tf μ (ai ) and (because An | utransf (ai )) An | ¬ tf ν (ai ) for all ν ∈ T F > in \ { μ}, then, because An | persf (ai ), An | ¬μ( ai ) and An | ν( ai ) →ν( ai ) for all ν ∈ T F > in , whence, due to (c), μ / ∈ Iin+1 and Iin+1 ⊇ Iin \ { μ}. The required condition follows. Finally, given that An | stepf (ai ), it follows that An | sf q (ai ) ∧ enbf τ (ai ) ∧ tf τ (ai ) ∧ sf q′ (ai ), for some 〈q, τ, q′ 〉 ∈ δF ,or An | sf q (ai ) ∧ ∧ > 〈q,τ, q′〉∈ δF ¬enbf τ (ai ) ∧ tf idle (ai ) ∧ sf q (ai ), for some q ∈ Q F .For the former case, it follows from (c) that
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
q in = q and q in+1 = q′, and from (d) that τ in = τ ; and, for the latter case, it follows from (c) that q in = q in+1 = q and from (d) that τ in = idle . It is straightforward to show from An | enbf τ (ai ) (a consequence of the # 123 458 Formal Methods in System Design (2021) 58:440–468 assumption that An | sf q (ai ) ∧ enbf τ (ai ) ∧ tf τ (ai ) ∧ sf q′ (ai )) and (c) that τ in (= τ ) ∈ enb (cin ); and from An | ∧ > 〈q,τ, q′〉∈ δF ¬enbf τ (ai ) (a consequence of the assumption that An | sf q (ai ) ∧ ∧ > 〈q,τ, q′〉∈ δF ¬enbf τ (ai ) ∧ tf idle (ai ) ∧ sf q (ai )) and (c) that enb (cin ) = ∅ .Thus, we have established that τ in ∈ enb (cin ) and 〈q in , τ in , q in+1〉 ∈ δF , or enb (cin ) = ∅ , τ in = idle , and q in = q in+1 , for all n ∈ N.Finally we establish that conditions (A1) and (A2) from Sect. 3.4 hold for R. For (A1), we first show that if τ 0 > n = μ (n ∈ N), then, for each i (1 ≤ i ≤ k), there exists n′ > n, such that μ ∈ Iin′ . Let n ∈ N and suppose τ 0 > n = τ = μ. From (b), it must be An | tl τ . Further, from An | bcastla (a consequence of the assumption that Spec (M) is true in M), we have An
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
| tl τ → ∀ x ♦μ( x), and, as a result, An | ∀ x ♦μ( x). It is then straightforward to show from the semantics of MFOTL and (c) above that, for each i (1 ≤ i ≤ k), there exists n′ > n, such that μ ∈ Iin′ . Now, for each i (1 ≤ i ≤ k), supposing μ ∈ Iin (n ∈ N), we have from (c) above that An | μ( ai ), thus, from An | bcastla again, An | μ( ai ) → past μ,and, as a result, An | past μ, whence, from Lemma 4, An′ | tl μ, or, due to (b) (in this proof), τ 0 > n′ = μ, for some n′ n′ = μ. In combination with the above, it follows that condition (A1) from Sect. 3.4 holds. Condition (A2) from Sect. 3.4 can be obtained in a similar manner, using (d), (a), sendfa , and Lemma 5. Combining Lemma 3 and 6 , we have proved: Theorem 1 Let M = 〈 L, F〉 be an asynchronous distributed machine and Spec (M) as above. M is runnable if and only if Spec (M) is satisfiable over a finite model. Remark 3 It should be clear from the proofs of Lemma 3 and 6 that runs of each asynchronous machine M and models of Spec (M) over finite domains are in one-to-one correspondence. It should also be clear that all runs of M have a property P (expressible in MFOTL ) if and only if Spec (M) ∧ ¬ ϕP , where
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
ϕP is the formula (over M ) expressing P in MFOTL , is unsatisfiable over finite domains. 4.5 Execution in a synchronous setting If N = 〈 L, F〉 is a synchronous distributed machine, we can (automatically) construct an MFOTL -sentence Spec ′(N ) (with ‖Spec ′(N )‖ quadratic in ‖N ‖) such that N is runnable if and only if Spec ′(N ) is satisfiable. Spec ′(N ) is defined over the signature N comprising a nullary predicate sl q for each state q ∈ Q L , a unary predicate sf q (·) for each state q ∈ Q F ,the symbols in T L > in and T F > in as unary predicates, the symbols in T F > out as unary predicates, a nullary predicate tl τ for each τ ∈ T L , and a unary predicate tf τ (·) for each τ ∈ T F . The intended meaning for each symbol in N is the same as the corresponding symbol in M .As discussed earlier, a synchronous machine differs from an asynchronous machine in that runs of the former satisfy conditions (S1) and (S2) from Sect. 3.4, whereas runs of the latter satisfy conditions (A1) and (A2) from Sect. 3.4. Thus, the parts of Spec ′(N ) describing the operation of the leader and each follower are the same as in the asynchronous case. The only thing that changes is the description of the network. We now proceed to define the formulas describing N ’s network. The following two for-mulas (short for broadcast leader synchronous and send follower synchronous respectively) are a translation of conditions (S1) and (S2) respectively from Sect. 3.4: # 123 Formal Methods in System Design (2021) 58:440–468 459 bcastls := ∧ > μ∈TL > out ((tl μ →
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
∀ xμ( x)) ∧ ∀ x(( ¬μ( x) ∧μ( x)) → tl μ )), sendfs := ∀ x ∧ > μ∈TF > out ((tf μ (x) →μ( x)) ∧ (( ¬μ( x) ∧μ( x)) → tf μ (x)) ). As in the definition of bcastla and sendfa , the symbol μ ∈ T F > in (resp. μ ∈ T L > in ), and, thus, the predicate μ( ·) appearing in bcastls (resp. sendfs ) exists because T L > out T F > in (resp. T F > out T L > in ). The following formula (short for network synchronous ) describes the operation of the synchronous network comprising the leader and its followers: nets := bcastls ∧ sendfs . Finally, for the whole machine, let Spec ′(N ) := leader ∧ ∀ x follower (x) ∧ nets . As in the asynchronous case, we have ‖Spec (N )‖ = O(‖N ‖2). Lemma 7 Let N = 〈 L, F〉 be a synchronous distributed machine and Spec ′(N ) as above. If N is runnable, then Spec ′(N ) is satisfiable over a finite model. Proof Omitted. (Similar to the proof of Lemma 3.) Lemma 8 Let N = 〈 L, F〉 be a synchronous distributed machine and Spec ′(N ) as above. If Spec ′(N ) is satisfiable over a finite model, then N is runnable. Proof Omitted. (Similar to the proof of Lemma 6.) Combining Lemma 7 and 8 , we have: Theorem 2 Let N = 〈 L, F〉 be a synchronous distributed machine and Spec ′(N ) as above. N is runnable if and only if Spec ′(N ) is satisfiable over a finite model. Remark 4 Similar to the asynchronous case, it should be clear that if all
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
runs of a runnable synchronous machine N have a property P (expressible in MFOTL ) then Spec ′(N ) ∧ ¬ ϕP ,where ϕP is the formula (over N ) expressing P in MFOTL , is unsatisfiable over finite domains. Relevant to Rem. 1, it should also be clear that for an arbitrary (not necessarily runnable) synchronous distributed machine N = 〈 L, F〉 and a property P expressed in MFOTL (over N ) by the formula ϕP , if Spec ′(N )∧¬ ϕP is unsatisfiable over finite domains then either N is not runnable or ( N is runnable and) all its runs have property P. N can fail to be runnable if the definition of L and/or F is such that the behaviour of the machine in each possible execution is undefined, as discussed in Rem. 1. We stress that it is upon the designer to ensure that any such machine N specified within our framework cannot give rise to undefined behaviour during its execution, and, as a result, from the unsatisfiability of Spec ′(N ) ∧ ¬ ϕP one can conclude that all runs of N satisfy P. Remark 5 Applications requiring different time constraints on message delivery are out of scope. Nevertheless, for completeness, we outline here how to enforce within our framework that messages be delivered after m time steps, for a fixed m > 1. For the leader, one introduces m new proposition symbols t μ > 1 , . . . , t μ > m , for each message μ the leader may broadcast, (these symbols are meant to represent the passage of time after a message μ is broadcast) and enforces the condition that t μ > i holds true at time n + i (1 ≤ i ≤ m) if
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
and only if tl μ holds true # 123 460 Formal Methods in System Design (2021) 58:440–468 at time n (n ∈ N). One then enforces the condition that μ( x) holds true whenever t μ > m holds true and if ¬μ( x), μ( x) hold true at times n, n + 1 respectively then t μ > m also holds true at time n + 1 ( n ∈ N), for each follower x. Similarly, for the followers, one introduces m new unary predicates T > μ > 1 (·), . . . , T > μ > m (·), for each message μ a follower may send to the leader, and enforces the condition that T μ > i (x) holds true at time n + i (1 ≤ i ≤ m) if and only if tf μ (x) holds true at time n (n ∈ N), for each follower x. One then enforces the condition that > μ( x) holds true whenever T μ > m (x) holds true and if ¬μ( x), μ( x) hold true at times n, n + 1respectively then T μ > m (x) also holds true at time n + 1 ( n ∈ N), for each follower x. ## 5 Specification of protocols In this section we demonstrate the applicability of our framework in practice by formally specifying three protocols. 5.1 FloodSet We consider a variant of the FloodSet algorithm with alternative decision rule [28,p. 105] that appeared in . The setting is as follows. There are k processes, each having an input bit and an output bit . The processes communicate via broadcast messages, guaranteed to be delivered with an arbitrary delay, and may also arrive to each recipient multiple times. Informally, the protocol works as follows:
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
• At the first round of computations, every process broadcasts its input bit. • At every round the (tentative) output bit is set to the minimum value ever seen so far. The correctness criterion for this protocol is that, eventually, the output bits of all processes will be the same. We now give a formal specification of the above protocol as a network of a leader and followers. Intuitively, each follower corresponds to one of the aforementioned k processes. Since our model does not allow follower broadcasts we shall use the leader as a network relay: the leader remains idle until it receives one or more “0” messages and/or one or more “1” messages; if it does, it broadcasts a “0” and/or “1” accordingly, and keeps broadcasting while new messages arrive; otherwise it returns to its initial state. The leader is fair, in the sense that it does not neglect to broadcast “1” messages (if any) after broadcasting “0” messages, and vice versa .Towards defining the leader, let T L > in = { 0,1}, T L > out = { 0, 1}, and T L > local = ∅ ; thus T L > in ={0 =0,0 =1,0 ≥1,0 >1,0 all ,1 =0,1 =1,1 ≥1,1 >1,1 all }. Let T L = T L > in ∪T L > out ∪T L > local ∪{ idle }.Let Q L = { q0, . . . , q3}, Q L > init = { q0}, and δL = {〈 q0,0 ≥1, q1〉, 〈q1, 0, q3〉, 〈q0,1 ≥1, q2〉, 〈q2, 1, q4〉, 〈q3,1 =0, q0〉, 〈q3,1 ≥1, q2〉, 〈q4,0 ≥1, q1〉, 〈q4,0 =0, q0〉} . Let L = 〈 Q L , Q L > init , T L , δ L 〉. L is depicted in Fig. 3. T F
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
> in = { 0,1}, T F > out = { 0, 1}, and T F > local = ∅ . Let T F = T F > in ∪ T F > out ∪ T F > local ∪ { idle }. Let Q F = { i0, i1, o0, o1}, Q F > init = { i0, i1},and δF = {〈 i0, 0, o0〉, 〈i1, 1, o1〉, 〈o1,0, o0〉, 〈o1,1, o1〉, 〈o0,0, o0〉, 〈o0,1, o0〉} . # 123 Formal Methods in System Design (2021) 58:440–468 461 > Fig. 3 FloodSet leader > Fig. 4 FloodSet follower Let F = 〈 Q F , Q F > init , T F , δ F 〉. F is depicted in Fig. 4. Recall that to form a distributed machine out of L and F we must satisfy the constraints T L > in ∩ T F > in = ∅ , T L > in T F > out and T F > in T L > out . To satisfy the first restriction we could have typeset either T L > out or T F > in with a different font, but we refrained from that for simplicity. The other constraints are satisfied. Finally, let MFS = 〈 L, F〉 be the asynchronous state machine comprising the leader L and (an arbitrary number of replicated) followers F. Let Spec (MFS ) be the FOTL -sentence such that MFS is runnable if and only if Spec (MFS ) is satisfiable. According to the informal correctness criterion stated above, we need to verify that the following FOTL -sentence is unsatisfiable over finite domains: Spec (MFS ) ∧ ¬ ♦(∀x . sf o0 (x) ∨ ∀ x . sf o1 (x)). 5.2 Two-phase commit We consider the two-phase commit as
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
described in , with minor simplifications. In this setting, k followers (“resource managers”) coordinated by a leader (“transaction manager”) collectively perform a transaction. The transaction is aborted if one or more followers abort, otherwise it is committed. Initially, the leader and each follower are in a working state. The protocol starts with the leader broadcasting a prepare message to the followers, signalling that a decision is about to be made on committing/aborting the transaction. The leader then enters a waiting state and # 123 462 Formal Methods in System Design (2021) 58:440–468 remains there until it has received a response from each follower—either prepared (signalling that a follower is prepared to receive a command to commit or abort) or aborted (signalling that a follower has chosen to abort). Upon receipt of a prepare message from the leader, each follower enters a preparing state. In this state the follower can choose to (a) abort the transaction (for its own reason); or (b) prepare to receive (from the leader) a command to commit or abort. If the follower aborts, it sends an aborted message to the leader and enters an aborted state. If the follower prepares to receive a command, it sends a prepared message to the leader and enters a prepared state. When in a prepared state, the follower cannot abort on its own volition: it will perform the leader’s command (whether it be to commit or to abort). Thus, while in a prepared state, if the follower receives a commit message, it enters a committed state, and if it receives an abort message, it enters an aborted state. While in the waiting state, if the leader receives an aborted message from one or more followers it enters an aborting state; otherwise (if it receives a prepared message from all k
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
followers) it enters a committing state. When in an aborting state, the leader broadcasts an abort message to the followers and enters an aborted state; and while in a committing state, it broadcasts a commit message to the followers and enters a committed state. (Similar to , we could allow the leader (“transaction manager”) to arbitrarily abort when in a working , waiting , or committing state, but we will refrain from that for simplicity.) The correctness criterion for this protocol is that, eventually, either all followers are in a commited state or all are in an aborted state. We now give a formal description of the above protocol. Towards defining the leader, let T L > in = {←−−−−− prepared , ←−−−− aborted }, T L > out = {−−−−→prepare , −−−−→ commit , −−→ abort }, and T L > local = ∅;thus T L > in = { ←−−−−− prepared =0, ←−−−−− prepared =1, ←−−−−− prepared ≥1, ←−−−−− prepared >1, ←−−−−− prepared all , ←−−−− aborted =0, ←−−−− aborted =1, ←−−−− aborted ≥1, ←−−−− aborted >1, ←−−−− aborted all }. Let T L = T L > in ∪ T L > out ∪ T L > local ∪ { idle }. Let Q L = { working , waiting , committing , aborting , committed , aborted }, Q L > init = { working },and δL = {〈 working , −−−−→prepare , waiting 〉, 〈waiting , ←−−−−− prepared all , committing 〉, 〈waiting , ←−−−− aborted ≥1, aborting 〉, 〈committing , −−−−→ commit , committed 〉, 〈aborting , −−→ abort , aborted 〉} . Let L = 〈 Q L , Q L > init , T L , δ L 〉. L is depicted in Fig. 5. For the followers, let T F >
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
in = { ←−−−−prepare , ←−−−− commit , ←−− abort }, T F > out = { −−−−−→ prepared , −−−−→ aborted }, and T F > local = ∅ . Let T F = T F > in ∪ T F > out ∪ T F > local ∪{idle }. Let Q F = { working , preparing , prepared , committed , aborted }, Q F > init = { working },and δF = {〈 working , ←−−−−prepare , preparing 〉, 〈preparing , −−−−−→ prepared , prepared 〉, 〈preparing , −−−−→ aborted , aborted 〉, 〈prepared , ←−−−− commit , committed 〉, 〈prepared , ←−− abort , aborted 〉} . Let F = 〈 Q F , Q F > init , T F , δ F 〉. F is depicted in Fig. 6. Notice that T L > in ∩ T F > in = ∅ , T L > in T F > out and T F > in T L > out .Finally, let M2PC = 〈 L, F〉 be the asynchronous state machine comprising the leader L and (an arbitrary number of replicated) followers F. Let Spec (M2PC ) be the FOTL -sentence such that M2PC is runnable if and only if Spec (M2PC ) is satisfiable. According to the informal correctness criterion stated above, we need to verify that the following FOTL -sentence is # 123 Formal Methods in System Design (2021) 58:440–468 463 > Fig. 5 Two-phase commit leader > Fig. 6 Two-phase commit follower unsatisfiable over finite domains: Spec (M2PC ) ∧ ¬ ♦(∀x . sf committed (x) ∨ ∀ x . sf aborted (x)). 5.3 Control-MAC We consider a simplified version of the Control-MAC protocol , used to enforce a form of mutual exclusion in certain sensor networks.
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
The original protocol involves a degree of randomness, which we are unable to model in our framework and first-order temporal logic in general. The simplifications made here address this limitation while staying faithful to the core ideas behind the protocol. # 123 464 Formal Methods in System Design (2021) 58:440–468 The setting is as follows. There are k sensors and a gateway. The sensors sense a physical phenomenon and each sensor wants to send to the gateway its sense data when a certain threshold is met. The gateway has a limited number of transmission slots, say m (m < k), and if more than m sensors transmit at the same time there will be data corruption. For simplicity we shall take m = 1, i.e. the gateway has only one transmission slot. The protocol is synchronous and evolves in rounds. At the beginning of each round, the gateway waits for bids for the transmission slot from the sensors that have data to transmit; at the same time, each sensor that has data to transmit bids for the transmission slot, otherwise it waits. If the gateway receives exactly one bid it broadcasts a go message; if it receives two or more bids it broadcasts a nogo message; and, for symmetry, if it receives no bid it broadcasts a nogo message. If a sensor that has bid for the transmission slot receives a go message, it sends its data and moves to its initial state; otherwise, if it receives a nogo message simply moves to its initial state. If a sensor that has not bid for the transmission slot receives either a go or a nogo message, it moves to its initial state. In the original protocol, when a sensor that has bid for the transmission slot receives a nogo message, it
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
waits for a random number of rounds before it bids again. This random number depends on the contention in the system (i.e. on how many sensors have bid up to that point) and its specific properties are of no concern to us. What is important to us is that it is calculated in such a way that if two sensors bid for the transmission slot at the same time, the probability of them biding again at the same time in the future is very low . Seeing as we cannot model randomness, we shall assume that probability to be zero . Thus, we shall assume that if a sensor bids for the transmission slot at the same time with other sensors, there will be a time in the future when the sensor bids on its own. The correctness criterion for this protocol is that every sensor that has data to send, or, in other words, has bid for the transmission slot, will eventually send its data to the gateway. We now give a formal description of the above protocol. Towards defining the leader, let T L > in = { ←− bid }, T L > out = { −→go , −−→nogo }, and T L > local = { wait }; thus T L > in = { ←− bid =0, ←− bid =1, ←− bid ≥1, ←− bid >1, ←− bid all }. Let T L = T L > in ∪ T L > out ∪ T L > local ∪ { idle }. Let Q L = { q0, . . . , q4}, Q L > init = { q0},and δL = {〈 q0, wait , q1〉, 〈q1, ←− bid =0, q2〉, 〈q1, ←− bid =1, q3〉, 〈q1, ←− bid >1, q4〉, 〈q2, −−→nogo ,
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
q0〉, 〈q3, −→go , q0〉, 〈q4, −−→nogo , q0〉} . Let L = 〈 Q L , Q L > init , T L , δ L 〉. L is depicted in Fig. 7. For the followers, let T F > in = { ←−go , ←−−nogo }, T F > out = { −→ bid }, and T F > local = { sending , wait , ε }. Let T F = T F > in ∪ T F > out ∪ T F > local ∪ { idle }. Let > Fig. 7 Control-MAC leader # 123 Formal Methods in System Design (2021) 58:440–468 465 > Fig. 8 Control-MAC follower Q F = { q0, . . . , q6}, Q F > init = { q0}, and δF = {〈 q0, −→ bid , q1〉, 〈q0, wait , q2〉, 〈q1, ←−go , q3〉, 〈q1, ←−−nogo , q4〉, 〈q2, ←−go , q5〉, 〈q2, ←−−nogo , q6〉, 〈q3, sending , q0〉, 〈q4, ε, q0〉, 〈q5, ε, q0〉, 〈q6, ε, q0〉, }. Let F = 〈 Q F , Q F > init , T F , δ F 〉. F is depicted in Fig. 8. Notice that T L > in ∩ T F > in = ∅ , T L > in T F > out and T F > in T L > out .Finally, let N MAC = 〈 L, F〉 be the synchronous state machine comprising the leader L and (an arbitrary number of replicated) followers F. Let Spec ′(N MAC ) be the FOTL -sentence such that N MAC is runnable if and only if Spec ′(N MAC ) is satisfiable. According to the informal correctness criterion stated above, we need to verify that the following FOTL -sentence is unsatisfiable over
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
finite domains: Spec (N MAC ) ∧ ∀x(( tf −→ > bid (x) ∧ ∃ y(x = y ∧ tf −→ > bid (y))) → ♦(tf −→ > bid (x) ∧ ¬∃ y(x = y ∧ tf −→ > bid (y)))) ∧ ¬ ∀x(tf −→ > bid (x) → ♦tf sending (x)) ## 6 Related work presents an approach in which the states and transitions of a parameterized or infinite-state system are represented as words over a finite alphabet and properties of a system are specified and checked using automata-theoretic techniques. Because working with these automata-theoretic techniques can be difficult in practice, introduces LTL(MSO), a mixture of LTL (linear temporal logic) and MSO (monadic second-order logic), enabling the specification of systems and their properties at a higher level of abstraction. The verification problem for LTL(MSO) reduces to whether some Büchi regular transition system has accepting runs. reports that this problem is in general undecidable, but goes on to verify safety properties and some liveness properties (also see for liveness) for various real-world protocols. In [10, 11] and , the state of a parameterized system is represented using certain numerical abstractions. An abstract, parameterized, cache-coherence (in [10, 11]) or broad- # 123 466 Formal Methods in System Design (2021) 58:440–468 cast (in ) protocol for such systems is then translated to numerical constraints pertaining to said numerical abstractions. This approach reduces model-checking safety properties to a reachability problem, which can be attacked using common methods for infinite-state model-checking, working over integer or real arithmetics. The latter methods have in general non-elementary worst-case complexity. reports that model-checking liveness properties for their abstract broadcast protocol is undecidable. By utilizing MFOTL , our approach achieves similar expressiveness to LTL(MSO) (if no second-order quantifiers are used, formulas of
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
LTL(MSO) can be straightforwardly trans-lated to monadic MFOTL ) and approximates to some extent the expressiveness of approaches based on numerical abstractions (the latter are more flexible in expressing properties involving complex numerical constraints, but MFOTL can express simple numerical constraints, pos-sibly sacrificing completeness for constraints requiring equality). At the same time, MFOTL remains decidable (sacrificing completeness when it comes to properties requiring equality) and has relatively low worst-case computational complexity. The decidability and compu-tational complexity of MFOTL are not affected by the type of property one wants to check (i.e. safety, liveness, fairness, or other), and, as a result, MFOTL is particularly useful for checking liveness properties, which present difficulties for the above formalisms. The abstract model that we introduce can emulate the protocol model in [10, 11] and has similarities with the one in . For protocols that include ingoing transitions of the form μ=1 ,μ>1 , or any other ingoing transitions added in the future whose translation in first-order logic requires the use of equality, our framework is correct (a protocol does have a given property if the protocol’s translation logically entails that property) but incomplete (a protocol may have a given property even if the protocol’s translation does not logically entail that property). For example Control-MAC in Sect. 5.3 is affected by this limitation, but neither FloodSet in Sect. 5.1 nor the two-phase commit in Sect. 5.2 are affected by it. ## 7 Conclusions We have introduced a framework that simplifies the verification of protocols involving a distinguished machine (leader) orchestrating an arbitrary number of identical machines (fol-lowers). Our framework provides a high-level formalism based on finite-state machines and encapsulating their network interactions. We have shown that protocols specified in this framework can automatically be translated into monodic first-order temporal logic, main-taining their semantics. Automated theorem
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
provers for said logic can then be used to check whether that translation (and thus the original protocol) satisfies a property of interest. Thus, our framework constitutes a flexible, high-level approach to parameterized verification. To demonstrate the applicability of our framework, we have specified in it three protocols used in real settings. The implementation of our framework and its incorporation with the provers is the subject of ongoing and future work. > Data Availibility Statement Data sharing not applicable. > Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article’s Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article’s Creative Commons licence and your intended use is not permitted by statutory # 123 Formal Methods in System Design (2021) 58:440–468 467 regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit ## References 1. Abdulla PA, Jonsson B, Nilsson M, d’Orso J, Saksena M (2004) Regular Model Checking for LTL(MSO). In: International Conference on Computer Aided Verification, LNCS , vol. 3114, pp. 348–360. Springer 2. Abdulla PA, Jonsson B, Rezine A, Saksena M (2006) Proving liveness by backwards reachability. In: International Conference on Concurrency Theory, LNCS , vol. 4137, pp. 95–109. Springer 3. Behdenna A, Dixon C, Fisher M (2009) Deductive verification of simple foraging robotic behaviours. Int J Intell Comput Cybern
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
2(4):604–643 4. Benghabrit W, Grall H, Royer JC, Sellami M (2015) Abstract accountability language: translation, com-pliance and application. In: Asia-Pacific Software Engineering Conference, pp. 214–221. IEEE 5. Benghabrit W, Grall H, Royer JC, Sellami M (2015) Checking accountability with a prover. In: Computer Software and Applications Conference, vol. 2, pp. 83–88. IEEE 6. Bernstein PA, Hadzilacos V, Goodman N (1987) Concurrency control and recovery in database systems. Addison-Wesley, Boston 7. Bhatia L, Tomic I, Fu A, Breza M, McCann JA, Control communication co-design for wide area cyber-physical systems. ACM Trans Cyber-Phys Syst 8. Degtyarev A, Fisher M, Konev B (2006) Monodic temporal resolution. ACM Trans Comput Logic 7(1):108–150 9. Degtyarev A, Fisher M, Lisitsa A (2002) Equality and monodic first-order temporal logic. Studia Logica 72(2):147–156 10. Delzanno G (2003) Constraint-based verification of parameterized cache coherence protocols. Formal Methods Syst Design 23(3):257–301 11. Delzanno G (2020) Automatic verification of parameterized cache coherence protocols. International Conference on Computer Aided Verification. Springer International Publishing, Cham, pp 353–360 12. Dixon C (2006) Using temporal logics of knowledge for specification and verification-a case study. J Appl Logic 4(1):50–78 13. Dixon C, Fisher M, Konev B, Lisitsa A (2008) Practical first-order temporal reasoning. In: International Symposium on Temporal Representation and Reasoning, pp. 156–163. IEEE 14. Esparza J, Finkel A, Mayr R (1999) On the verification of broadcast protocols. In: Symposium on Logic in Computer Science, pp. 352–359. IEEE Computer Society Press 15. Fernández-Gago M, Hustadt U, Dixon C, Fisher M, Konev B (2005) First-order temporal verification in practice. J Autom Reason 34(3):295–321 16. Fisher M, Konev B, Lisitsa A (2006) Practical Infinite-State Verification with Temporal Reasoning. In: Verification of Infinite State Systems and Security, NATO Security through Science Series: Information and Communication , vol. 1, pp. 91–100. IOS Press 17. Fisher M, Konev B, Lisitsa
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
A (2009) Temporal verification of fault-tolerant protocols. In: Methods, Models and Tools for Fault Tolerance, pp. 44–56. Springer 18. Fisher M, Lisitsa A (2003) Deductive verification of cache coherence protocols. In: Proceedings of the 3rd Workshop on Automated Verification of Critical Systems AVoCS, 3: 177–186 19. Gray J, Lamport L (2006) Consensus on transaction commit. ACM Trans Database Syst (TODS) 31(1):133–160 20. Halle S (2011) Causality in message-based contract violations: a temporal logic “whodunit”. In: Interna-tional Enterprise Distributed Object Computing Conference, pp. 171–180. IEEE 21. Hodkinson I, Kontchakov R, Kurucz A, Wolter F, Zakharyaschev M (2003) On the computational com-plexity of decidable fragments of first-order linear temporal logics. In: 10th International Symposium on Temporal Representation and Reasoning, 2003 and Fourth International Conference on Temporal Logic. Proceedings., pp. 91–98. IEEE 22. Hodkinson I, Wolter F, Zakharyaschev M (2000) Decidable fragments of first-order temporal logics. Annals Pure Appl Logic 106(1–3):85–134 23. Hustadt U, Konev B, Riazanov A, Voronkov A (2004) Temp: A temporal monodic prover. In: International Joint Conference on Automated Reasoning, LNCS , vol. 3097, pp. 326–330. Springer 24. Konev B, Degtyarev A, Dixon C, Fisher M, Hustadt U (2005) Mechanising first-order temporal resolution. Inf Comput 199(1–2):55–86 25. Konev B, Degtyarev A, Fisher M, Lisitsa A, Characterising finite domains in monodic first-order temporal logic. Tech. rep., ULCS-09-009, Department of Computer Science, University of Liverpool # 123 468 Formal Methods in System Design (2021) 58:440–468 26. Ludwig M, Hustadt U (2009) Fair derivations in monodic temporal reasoning. In: International Conference on Automated Deduction, pp. 261–276. Springer 27. Ludwig M, Hustadt U (2010) Implementing a fair monodic temporal logic prover. AI Commun 23(2– 3):69–96 28. Lynch NA (1996) Distributed Algorithms. Morgan Kaufmann Publishers Inc., San Francisco, CA, USA 29. Szalas A, Holenderski L (1988) Incompleteness of first-order temporal logic with until. Theoretical Comput
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
Sci 57(2–3):317–325 30. Wolter F, Zakharyaschev M (2001) Decidable fragments of first-order modal logics. J Symb Logic 66(3):1415–1438 31. Wolter F, Zakharyaschev M (2002) Axiomatizing the monodic fragment of first-order temporal logic. Annals Pure Appl logic 118(1–2):133–145 Publisher’s Note Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations. # 123
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
Title: A Brief Introduction to Chemical Reaction Optimization URL Source: Markdown Content: This website utilizes technologies such as cookies to enable essential site functionality, as well as for analytics, personalization, and targeted advertising. To learn more, view the following link: Privacy Policy Manage Preferences ACS ACS Publications C&EN CAS Find my institution Log In ADVERTISEMENT Chemical ReviewsVol 123/Issue 6Article Cite Share Jump to Expand REVIEWFebruary 23, 2023 A Brief Introduction to Chemical Reaction Optimization Connor J. Taylor*Alexander PombergerKobi C. FeltonRachel GraingerMagda BareckaThomas W. ChamberlainRichard A. BourneChristopher N. JohnsonAlexei A. Lapkin* Open PDF Abstract From the start of a synthetic chemist’s training, experiments are conducted based on recipes from textbooks and manuscripts that achieve clean reaction outcomes, allowing the scientist to develop practical skills and some chemical intuition. This procedure is often kept long into a researcher’s career, as new recipes are developed based on similar reaction protocols, and intuition-guided deviations are conducted through learning from failed experiments. However, when attempting to understand chemical systems of interest, it has been shown that model-based, algorithm-based, and miniaturized high-throughput techniques outperform human chemical intuition and achieve reaction optimization in a much more time- and material-efficient manner; this is covered in detail in this paper. As many synthetic chemists are not exposed to these techniques in undergraduate teaching, this leads to a disproportionate number of scientists that wish to optimize their reactions but are unable to use these methodologies or are simply unaware of their existence. This review highlights the basics, and the cutting-edge, of modern chemical reaction optimization as well as its relation to process scale-up and can thereby serve as a reference for inspired scientists for each of these techniques, detailing several of their respective applications. This publication is licensed under CC-BY 4.0 . Copyright © 2023 The Authors. Published by
|
{
"page_id": null,
"source": 7334,
"title": "from dpo"
}
|
American Chemical Society Subjects what are subjects Algorithms Catalysts Chemical Reactions Kinetic Modeling Optimization 1. Introduction Chemical reaction optimization is a term that has a variety of meanings depending on the chemist defining it, with a large corresponding variance in expectations of optimization capability and proficiency. As reaction optimization is largely unexplored during undergraduate chemistry teaching, (1−3) many research chemists are simply unaware of existing optimization techniques and are therefore unlikely to employ robust strategies in their workflows as their career progresses. This is particularly true in academic research, where intuition-based optimization (4−12,) is commonplace despite the increasing evidence showing that reaction modeling and algorithmic optimizations are more efficient in relation to both time and material and therefore cost. (13−16) For these reasons, the use of these methodologies is much more widespread in industrial research and development, particularly in process laboratories compared to their discovery laboratory counterparts, (17,18) as manufacturing conditions often result from vigorous optimization protocols. Consequently, there is often a large disparity in the familiarity of optimization techniques between industrial and academic researchers, particularly because industrial scientists also often have internal multidisciplinary teams of statisticians and process chemists to collaborate with. However, the techniques covered are not inaccessible for chemists, and increasing the exposure of these methodologies will make them more widespread across both academic research and teaching, thereby enriching the skillset of the entire chemical community. Although the primary aims of many scientists (particularly synthetic chemists) may not be to achieve truly optimal processes, familiarity with the concepts discussed herein will help researchers meet the needs of the modern and evolving laboratory. This review aims to critically analyze and compare major chemical reaction optimization techniques, thereby helping to deliver an accessible account of optimization strategies (with references to their applications) for the general chemical scientist. As many
|
{
"page_id": null,
"source": 7334,
"title": "from dpo"
}
|
of these methodologies borrow concepts from related fields, such as statistics, computer science, process chemistry, and engineering, this review will help to diversify the chemist’s toolkit and serve as a comprehensible reference for optimization campaigns. Although reaction optimization is often related to reaction yields, it may also be performed with respect to purity, E-factor, enantiomeric excess, etc., and these concepts will be explored further. Typical reaction variables that are optimized are also often described as either continuous (in a numeric form, such as temperature or reaction time) or categorical (discrete options, such as solvent or catalyst/ligand choice). Further in-depth reading will also be provided at each stage for interested scientists seeking a deeper understanding of the workings of each methodology. We also discuss how to explore the generated reaction knowledge within the subsequent process scale-up efforts. By providing tools for considerations of scale-up challenges and complexity in the early stages of process optimization, we hope to help chemists to guide their optimization efforts toward scalable processes and thus facilitate the translation of critical laboratory discoveries into commercially available products. 2. One Factor At a Time (OFAT) “Intuition-based optimization” largely relates to optimization using the trends and anecdotal observations from experienced chemists to improve reaction metrics. Alongside optimization via chemical intuition, one factor at a time (OFAT) approaches often substitute as a method for chemical process optimization and understanding. (16,19) This is primarily performed in academia and in the presence of a structured, yet simple to follow, procedure, making this technique seem both effective and accessible. The OFAT methodology itself requires some scientific intuition, where experiments are iteratively performed by fixing all process factors except for one. After the best value for the one factor has been identified, that value is fixed while another set of experiments are executed to optimize
|
{
"page_id": null,
"source": 7334,
"title": "from dpo"
}
|
another factor until each factor is optimized and the scientist believes that they have arrived at the optimum reaction conditions. (20) These factors can be any number of experimental conditions (such as temperature, stoichiometry, reaction time, etc.) which, when combined, constitute a multidimensional space with many possible combinations of factors to make up one experiment. This is termed the parameter space and is constrained by the upper and lower limits of each factor (for example, max and min temperature). The OFAT approach is often inaccurate and inefficient as an optimization technique, and the method frequently misinterprets the chemical process as there are no considerations for any synergistic effects between the factors considered. (21) Interactions between the experimental factors are ignored, as this linear experimental procedure is applied to chemical reaction outputs that give exclusively nonlinear responses. (22) This nonlinearity can be explained by statistical or physical modeling but is not explored using OFAT, which therefore often incorrectly identifies true optimal reaction conditions. (23,24) An exemplar schematic of an OFAT campaign is shown in Figure 1, mapped onto the response surface for a given parameter space for a chemical reaction (in which reagent equivalents and temperature are considered). The optimization is initialized as the temperature is fixed, and iterative experiments (1–7) are performed to identify the optimum reagent equivalents. After this value is found at experiment 5, subsequent experiments are performed (8–14) to determine the optimum temperature. As there are only two factors considered in this example, the optimization is now complete with a set of experimental conditions found that are presumed to be optimal. However, as the response surface cannot be known a priori for a real chemical example, it is difficult to estimate the distance from this identified set of optimum conditions and the true optimum for the system.
|
{
"page_id": null,
"source": 7334,
"title": "from dpo"
}
|
Figure 1 Figure 1. An example of an OFAT experimental procedure in varying temperature and reagent equivalents, where ○ represents a numbered experimental data point and the blue region indicates the true optimum area of parameter space. Response surface is contoured from red (low response) to blue (high response). Generally, scientists perform OFAT campaigns as the method can be performed without mathematical modeling, which is a critical advantage when performing lab-based experiments and is one major reason it is prevalent. A recent example by Abtahi and Tavakol (25) shows the use of OFAT optimization to achieve fair yields in the synthesis of bioactive propargylamine scaffolds. The model reaction was optimized, shown in Scheme 1, and the identified reaction conditions were then applied to several substrates achieving 38–91% yield. The optimization procedure began by fixing the temperature and reaction time and optimizing the reaction media and catalyst to obtain the highest reaction yield. The reaction media and catalyst were then fixed as the temperature and reaction time were optimized, followed by a fixing of all factors except catalyst loading, as this factor was finally optimized to achieve a 75% yield in the model reaction. Scheme 1 Scheme 1. Model Reaction Used for OFAT Optimization for the Synthesis of Propargylamine Derivatives (25) There are several examples from the literature of this technique’s application to various chemistries, in many cases with different levels of applied chemical intuition but still following the structure of the OFAT methodology. (26−28) In our own laboratories, when undergraduate chemists are given the task of optimizing a reaction, students will often employ OFAT techniques as they are unaware of other means of optimization. (29) This is not the fault of the student, nor is it the fault of the academics optimizing their reactions in this way, as this does
|
{
"page_id": null,
"source": 7334,
"title": "from dpo"
}
|
perform as a rudimentary technique to achieve improved reaction yields. However, as research laboratories are beginning to diversify their equipment by incorporating advanced technologies such as automated retrosynthesis software and experimentation, (30,31) it is also important for chemists to evolve at the same pace by diversifying their own skillsets to fully harness the capabilities of the evolving laboratory. Synthetic chemists, in recent years, have begun to embrace facets of process chemistry, chemical engineering, analytical chemistry, and computer science, to name a few. (17,18) Concurrently, it is important to facilitate better understanding and adoption of reaction optimization methods as OFAT optimizations are superseded by more robust and more efficient techniques. (32−34) Chemical reaction optimization by OFAT has therefore been included in this paper for comparative purposes. 3. Design of Experiments (DoE) One robust and widely used optimization technique, particularly in the pharmaceutical and fine chemical industries, is design of experiments (DoE). DoE is a class of statistical methods that aim to build a model that can mathematically describe the output of a chemical reaction (such as reaction yield, purity etc.) based on the experimental inputs for that reaction (factors such as temperature or reaction time). There are many reports of widespread DoE usage for reaction optimization, but it is also often used in the literature as a comparison with OFAT optimizations to highlight its efficiency and thereby refute OFAT. (16,23) There are three main objectives for DoE: screening, optimization, and robustness. (35) Screening involves the identification of factors that have a significant effect on reaction output, as well as their respective upper and lower bounds. Optimization focuses on the determination of the optimum factor levels, such as the optimum temperature and reagent equivalents, to achieve the best reaction output possible. Finally, robustness testing involves the identification of the sensitivity of this
|
{
"page_id": null,
"source": 7334,
"title": "from dpo"
}
|
response to small changes in the experimental factors; this is important on a process scale to understand how possible deficiencies in reactors may lead to suboptimal outputs. The practical manner of running DoE campaigns focuses on performing predefined experiments from a structured experimental design. These designs are templates from which to execute experiments, based on the factors and bounds of interest, that explore the parameter space efficiently and provide data in a structured format to build robust statistical models. (20,36) The format of this experimental data is important and often difficult to replicate/analyze using human intuition, which is why DoE software is often implemented, such as MODDE, (37) JMP, (38) Design-Expert, (39) or toolbox applications in languages such as R, MATLAB, and Python. After data collection and the fitting of the statistical model, optimized process parameters can then be identified, and response surfaces are often plotted to help visualize the effects of experimental factors on the chemical output. One optimization campaign performed using DoE in our laboratory is the multistep SNAr reaction of 2,4-difluoronitrobenzene with pyrrolidine, as shown in Scheme 2. (1) This reaction has multiple products, but the study aimed to produce the ortho-substituted product, 7, in the highest yield by using a face-centered central composite (CCF) design; more details on specific DoE designs are outlined in section 3.2. The 17 experiments were predefined and executed according to this design, where the experimental bounds for each of the defined factors were: residence time (0.5–3.5 min, as this was a flow experiment), temperature (30–70 °C), and equivalents of pyrrolidine (2–10). Among these experiments were three repeated center-point experiments, or replicates, that ensure that any extraneous variables are identified (uncontrolled variables that could be changing unknowingly, e.g., stock solution degradation throughout the experimental procedure). These replicates are experiments with the center
|
{
"page_id": null,
"source": 7334,
"title": "from dpo"
}
|
value for each factor, e.g., a reaction temperature of 50 °C in this example, and are conducted throughout the course of the 17 experiment campaign. The outputs from each experiment were then inputted into the DoE software, MODDE, to identify the optimum reaction conditions that afforded the highest yield of 7. After statistical analysis, a response surface was plotted for the chemical process to visualize the effect of each factor on the yield of our ortho-substituted product, as shown in Figure 2. It was found that the highest yield of 7 could be obtained by using higher temperature, longer residence times, and higher pyrrolidine equivalents, leading to a yield of 93%. However, these reaction conditions also produced the highest yield of the impurity, the disubstituted product, 9. A process chemist could then use this information to decide for a particular reactor system if product throughput is more important than other downstream processes, such as product purity and separation. Scheme 2 Scheme 2. SNAr System of Interest, Where the DoE Campaign Aims to Optimize the Yield of the Ortho-Substituted Product, 7 (1) Figure 2 Figure 2. Contour plot for the response of 7, showing how the yield of the desired product varies with respect to changing experimental conditions. (1) Another campaign highlighting the effectiveness of DoE was reported by Minisci and co-workers (40) on the synthesis of vanillin, iso-vanillin, and heliotropin. Several DoE studies were employed to identify optimum process factors for each synthetic step, one of which was the initial addition of glyoxylic acid, 11, to catechol, 10, to form the desired 3,4-dihydroxymandelic acid intermediate, 12, as shown in Scheme 3. Their initial attempts to reproduce reported literature led to poor selectivity and hence poor yields (<20%), so the authors systematically employed full factorial DoE designs to identify the important
|
{
"page_id": null,
"source": 7334,
"title": "from dpo"
}
|
experimental factors and to estimate the main factor effects and interactions, hence giving an accurate statistical model for the process and thereby optimizing the product output. Scheme 3 Scheme 3. One Reaction of Interest, Optimizing the Yield and Selectivity of the Desired 3,4-Dihydroxymandelic Acid Intermediate, 12a aThis intermediate can then be used to synthesize either vanillin, 13, iso-vanillin, 14, or heliotropin, 15. (40) The first DoE study explored the following factors: amount of glyoxylic acid, amount of aluminum oxide, reaction temperature, and amount of sodium hydroxide, while fixing the amount of catechol, volume of water, and reaction time at convenient levels. This design resulted in 18 experiments (24 + 2 “center” experiments). However, it was found that an excess of sodium hydroxide results in much greater rates of impurity formation, hence another study was performed under fixed, less basic conditions. The resulting three factors were therefore inputted into the second full factorial design of nine experiments (23 + 1), where the responses of recovered catechol, selectivity of desired product, and yield of desired product were measured. A statistical model was constructed for each response, and the response surface for the selectivity of the desired intermediate, 12, is plotted in Figure 3. Using this information, it was determined that to achieve an optimum product output, the amount of glyoxylic acid must be increased, the quantity fraction of catechol:aluminum oxide must fall within the range of 2.17–2.28, and the temperature must also be increased. After further experiments using this information at higher factor bounds, the selectivity of the process was improved to 90.5% with a conversion of 78.4%, where the unconverted catechol could be easily recovered and recycled. Figure 3 Figure 3. Contour plot for the selectivity of the reaction forming the desired intermediate, 12. Data was used from the original publication
|
{
"page_id": null,
"source": 7334,
"title": "from dpo"
}
|
by Minisci and co-workers to refit the model and plot the response surface using MODDE Pro. (40) There are many advantages to running optimization campaigns using DoE. The use of predefined, space-filling experimental designs removes the necessity for chemical-intuition-guided optimization, and it has been shown numerous times to be a more effective methodology. (23,33) This space-filling experimentation, as shown in Figure 4 when compared to more conventional OFAT studies, allows statistical models to be constructed to describe the chemical process across the entire parameter space; this is particularly powerful for reaction prediction and allows response contours to be generated. (16) These statistical models are also often intuitive for a chemist to use because the responses are described as a direct result of the changing factors which can be much easier to interpret than calculating responses using physical models such as kinetic models. These considerations are advantageous in many chemistry situations and are conducive to the efficient optimization of chemical processes. Figure 4 Figure 4. Parameter space exploration expected when comparing a typical OFAT optimization with a DoE design, where • represents an experiment. The DoE shown represents a CCF experimental design. Note that an OFAT optimization does not require a predetermined number of experiments and therefore may or may not exceed the number of experiments in a given DoE design. There are, however, some practical disadvantages to using DoE for optimization that may lead to the necessity of employing other techniques. Although some research groups utilize coding (or packages in particular languages, such as pyDoE) and statistical expertise to perform DoE campaigns, (41,42) most researchers use paid software packages specifically designed for DoE. These options carry either an expertise or a cost burden (or both), which may have classically hindered the uptake of the technique, particularly for smaller research organizations.
|
{
"page_id": null,
"source": 7334,
"title": "from dpo"
}
|
However, software options have undoubtedly helped to facilitate the employment of DoE overall due to the high expertise barrier for typical bench scientists to use the statistical methods unaided. Another major disadvantage is the difficulty in exploring categorical variables in DoE studies, as these experimental designs are only suitable for continuous variables. One way to incorporate categorical variables, such as solvent or catalyst, would be to describe them with suitable continuous descriptors that can then be translated to real-world categorical choices; see more information on molecular parametrization in section 6.2. As DoE builds a statistical model, it has only an empirical meaning rather than physical, therefore, there is no ingrained physicochemical information about the optimized process within the model; this means that model responses are only considered to be accurate within the explored bounds of the experimental factors. (43,44) For example, if the reaction time is explored as a factor as part of a DoE study between the bounds of 5–30 min, extrapolating the model to predict responses after 60 min would likely result in inaccuracies, and further study must be conducted to predict these outputs. Furthermore, the number of experiments that are required to be performed in parallel for some DoE studies may be large, depending on the amount of reaction material or time required to conduct these experiments, this may be prohibitive in some circumstances. (45) However, the rise of highly automated experimental platforms with online analytics provides a powerful option for chemical process development in many cases by miniaturizing and automating experimentation using DoE. DoE has been used extensively in the optimization of chemical processes, particularly in pharmaceutical and fine chemical settings. DoE is often used for studies relating to enhancing the yield (46−57) and purity (58−62) of particular products but is also used for drug formulations
|
{
"page_id": null,
"source": 7334,
"title": "from dpo"
}
|
(63−68) and delivery, (69−71) analytical method development, (72−75) and more. (76−79) This is because there are numerous and undisputed benefits to the use of DoE for experimental parameter screening and optimization, especially when compared with traditional human intuition-guided experimentation. With the rise of user-friendly software packages and the increased awareness of the chemical community, there has been a large uptake of this statistical method in recent years, although the technique itself has been around since the mid-20th century. (34) As the advantages of DoE are harnessed, and more industrial job roles will require familiarity with the technique, (35,80) an organic evolution of academic departments will also occur where there is more teaching of the topic and utilization of the methods for optimization practices. It is therefore a possibility in the future that DoE optimization becomes routine, regardless of the research setting, where the modernized laboratory contains enabling equipment for these studies, with chemists possessing highly diversified skillsets. 3.1. Statistical Modeling A mathematical, empirical model is featured at the center of each DoE study, built from real-world chemical experiments that relate experimental factors to chemical responses. The general format for the model involves fitting coefficients for each experimental factor, as well as for each 2-factor-combination possible. Therefore, the model for a 2-factor experiment is shown in eq 1, where x1 is variable 1 (for example, temperature), x2 is variable 2 (for example, reaction time), y is the experimental response (such as reaction yield) and bn is the coefficient term for the variable(s) of interest (determined by regression). Therefore, by replacing x1 and x1 with actual values for the factors considered, it is possible to predict the response for any experiment, including experiments with reaction conditions that have not actually been conducted. As any point in the parameter space can be predicted
|
{
"page_id": null,
"source": 7334,
"title": "from dpo"
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.