Towards a formally verified implementation of the MimbleWimble cryptocurrency protocol

TL;DR

This paper discusses the MimbleWimble cryptocurrency protocol's security and scalability, and proposes a model-driven verification approach to ensure the correctness of its implementation.

Contribution

It introduces a formal verification method tailored for MimbleWimble, advancing the reliability of privacy-focused cryptocurrencies.

Findings

Identified key security and scalability properties of MimbleWimble

Outlined a model-driven verification framework for protocol correctness

Discussed the potential for formal certification of implementations

Abstract

MimbleWimble is a privacy-oriented cryptocurrency technology encompassing security and scalability properties that distinguish it from other protocols of the kind. In this paper we present and briefly discuss those properties and outline the basis of a model-driven verification approach to address the certification of the correctness of a particular implementation of the protocol.

Equations

$$\stackrel{v}{\overbrace{(r_{v}G+vH)}}+\stackrel{w}{\overbrace{(r_{w}G+wH)}}=\stackrel{z}{\overbrace{r_{z}G+zH}}$$

$$\begin{array}[]{lcl}Transaction&\stackrel{{\scriptstyle{\rm def}}}{{=}}&\{i:I^{{}^{*}},\ o:O^{{}^{*}},tk:TxKernel^{{}^{*}}\}\end{array}$$

$$ke=\sum_{(r^{\prime},v^{\prime})\in o}{r^{\prime}.G+v^{\prime}.H}-\sum_{(r,v)\in i}{r.G+v.H}\$$

$$\begin{array}[]{lcl}Block&\stackrel{{\scriptstyle{\rm def}}}{{=}}&\{i:I^{{}^{*}},\ o:O^{{}^{*}},\ k:{\bbold N},\ tks:TxKernel^{{}^{*}}\}\\ \end{array}$$

$$\sum _{(r^{\prime },v^{\prime })\in o}(r^{\prime }.G+v^{\prime }.H)-\sum _{(r,v)\in i}(r.G+v.H)=k+\sum _{(ke,s)\in tks}ke$$

$$Chain\stackrel{\mathrm{def}}{=}{Block}^{{}^{\ast }}$$

$$\offinterlineskip\halign to=433.62pt{\strut$\@zlign#$\hfil\cr Time == {\bbold N}\crcr\penalty 100\vskip 6.0pt plus 3.99994pt minus 3.99994pt\cr[Addr,Hash,Proof,Tx] \crcr}$$

$$\offinterlineskip\halign to=433.62pt{\strut\vrule width\arrayrulewidth\hskip\zedleftsep$\@zlign#$\hfil\cr\hbox to433.62pt{\vrule height=0.4pt,width=0.4pt\vrule height=0.0pt,depth=3.0pt,width=0.0pt\hbox to10.00002pt{\leaders\hrule height=0.4pt\hfill\thinspace}$Block$\thinspace\leaders\hrule height=0.4pt\hfill}\cr width=0.4pt\hskip 10.00002pt$prev:Hash \crcr width=0.4pt\hskip 10.00002pt$txs: \mathop{\mathrm{seq}}Tx \crcr width=0.4pt\hskip 10.00002pt$pf:Proof \crcr\vrule height=3.0pt,width=0.4pt\cr\vrule height=0.4pt,width=433.62pt\cr}$$

$$\offinterlineskip\halign to=433.62pt{\strut\vrule width\arrayrulewidth\hskip\zedleftsep$\@zlign#$\hfil\cr\hbox to433.62pt{\vrule height=0.4pt,width=0.4pt\vrule height=0.0pt,depth=3.0pt,width=0.0pt\hbox to10.00002pt{\leaders\hrule height=0.4pt\hfill\thinspace}$LocState$\thinspace\leaders\hrule height=0.4pt\hfill}\cr width=0.4pt\hskip 10.00002pt$as:\mathop{\mathstrut{\bbold P}}\nolimits Addr \crcr width=0.4pt\hskip 10.00002pt$bf: Hash \mathrel{\ooalign{\hfil$\mapstochar\mkern 5.0mu$\hfil\cr$\rightarrow$}}Block \crcr width=0.4pt\hskip 10.00002pt$tp: \mathop{\mathstrut{\bbold P}}\nolimits Tx \crcr\vrule height=3.0pt,width=0.4pt\cr\vrule height=0.4pt,width=433.62pt\cr}$$

$$\offinterlineskip\halign to=433.62pt{\strut\vrule width\arrayrulewidth\hskip\zedleftsep$\@zlign#$\hfil\cr\hbox to433.62pt{\vrule height=0.4pt,width=0.4pt\vrule height=0.0pt,depth=3.0pt,width=0.0pt\hbox to10.00002pt{\leaders\hrule height=0.4pt\hfill\thinspace}$Conf$\thinspace\leaders\hrule height=0.4pt\hfill}\cr width=0.4pt\hskip 10.00002pt$Delta:Addr \mathrel{\ooalign{\hfil$\mapstochar\mkern 5.0mu$\hfil\cr$\rightarrow$}}LocState \crcr width=0.4pt\hskip 10.00002pt$P:\mathop{\mathstrut{\bbold P}}\nolimits Packet \crcr\vrule height=3.0pt,width=0.4pt\cr\vrule height=0.4pt,width=433.62pt\cr}$$

$$\offinterlineskip\halign to=433.62pt{\strut$\@zlign#$\hfil\cr Packet == Addr \times Addr \times Msg \crcr}$$

$$\offinterlineskip\halign to=433.62pt{\strut\vrule width\arrayrulewidth\hskip\zedleftsep$\@zlign#$\hfil\cr\hbox to433.62pt{\vrule height=0.4pt,width=0.4pt\vrule height=0.0pt,depth=3.0pt,width=0.0pt\hbox to10.00002pt{\leaders\hrule height=0.4pt\hfill\thinspace}$RcvAddr$\thinspace\leaders\hrule height=0.4pt\hfill}\cr width=0.4pt\hskip 10.00002pt$\Delta LocState \crcr width=0.4pt\hskip 10.00002pt$p?:Packet \crcr width=0.4pt\hskip 10.00002pt$ps!:\mathop{\mathstrut{\bbold P}}\nolimits Packet \crcr\vrule height=3.0pt,width=0.4pt\cr\vrule height=0.4pt,width=60.00009pt\cr\vrule height=3.0pt,width=0.4pt\cr width=0.4pt\hskip 10.00002pt$p?.2 = this \crcr width=0.4pt\hskip 10.00002pt$\mathop{\mathstrut{\exists}}\nolimits asm:\mathop{\mathstrut{\bbold P}}\nolimits Addr @ \crcr width=0.4pt\hskip 10.00002pt$\hskip 20.00003ptp?.3 = AddrMsg\penalty 10000\ asm \crcr width=0.4pt\hskip 10.00002pt$\hskip 20.00003pt\mathrel{\wedge}as' = as \cup asm \crcr width=0.4pt\hskip 10.00002pt$\hskip 20.00003pt\mathrel{\wedge}bf' = bf \crcr width=0.4pt\hskip 10.00002pt$\hskip 20.00003pt\mathrel{\wedge}tp' = tp \crcr width=0.4pt\hskip 10.00002pt$\hskip 20.00003pt\mathrel{\wedge}ps! = \{a:asm \setminus as @ (p?.2,a,ConnectMsg)\}\penalty 10000\ \cup\crcr width=0.4pt\hskip 10.00002pt$\hskip 20.00003pt\penalty 10000\ \penalty 10000\ \penalty 10000\ \penalty 10000\ \penalty 10000\ \{a:as @ (p?.2,a,AddrMsg\penalty 10000\ as')\} \crcr\vrule height=3.0pt,width=0.4pt\cr\vrule height=0.4pt,width=433.62pt\cr}$$

Full text

1 Introduction

Cryptocurrency protocols deal with virtual money so they are a valuable target of highly skilled attackers. Some attacks have already been mounted against cryptocurrency systems causing irreparable loses of money and credibility (e.g. [17]). For this reason the cryptocurrency community is seeking for approaches, methods, techniques and development practices that can reduce the chances of successful attacks. One such approach is the application of formal methods to software implementation. In particular, the cryptocurrency community is showing interest in formal proof and formally certified implementations.

MimbleWimble is a privacy-oriented cryptocurrency technology encompassing security and scalability properties that distinguish it from other technologies of the kind. Mimblewimble differs from Bitcoin [14], for instance, in key areas: there is no concept of address and all the transactions are confidential. In this (short) paper we outline an approach based on formal software verification aimed at formally verifying the basic mechanisms of MimbleWimble and (one of) its implementations [10].

Reasoning about implementations provides the ultimate guarantee that deployed critical systems provide the expected properties. There are however significant hurdles with this approach. Formally proving non-trivial security properties of code might be an overwhelming task in terms of the effort required, especially compared with proving functional correctness. In addition, many implementation details are orthogonal to the security properties to be established. This implies that slight changes in the implementation technology might have devastating consequences as concerns the security of the implementation. Therefore, complementary approaches are needed when non-trivial security properties are at stake. In this paper we put forward a model-driven verification approach where in the first place security issues that pertain to the realm of critical mechanisms are explored on an idealized model of the system under study. One such model abstracts away the specifics of any particular implementation and yet provides a realistic setting. Then verification is performed on more concrete models where low level mechanisms (such as pointer arithmetic) are specified; and finally the low level model is proved to be a correct implementation of the idealized model.

Organization of the paper

Section 2 provides a very brief description of the MimbleWimble cryptocurrency protocol. Section 3 describes the building blocks of a formal idealized model (abstract state machine) of the computational behaviour of MimbleWimble and Section 4 provides a brief account of the verification activities we are putting in place in order to verify the protocol and its implementation. Final remarks are presented in Section 5.

2 The MimbleWimble protocol

Transactions are at the core of the Mimblewimble protocol and they constitute a derivation of what are known as confidential transactions [13, 9].

A confidential transaction allows a sender to encrypt the amount of bitcoins he wants to send by using blinding factors, which are values chosen by the sender that are used to encrypt bitcoin amounts in a transaction. In a confidential transaction only the two parties involved know the amount of bitcoins being transacted. However, onlookers can still ensure that the transaction is valid by comparing the number of inputs and outputs; if both are the same, then the transaction will be considered valid. Such a procedure ensures that no bitcoins have been created from nothing and is key in preserving the integrity of the system.

Mimblewimble transactions function in a similar way, except the recipient of a transaction randomly selects a range of blinding factors provided by the sender. This blinding factor is then used as proof of ownership by the receiver, thus, permitting him to spend the bitcoins.

The MimbleWimble protocol aims at providing the following properties [11, 10]:

i) verification of zero sums without revealing the actual amounts involved in a transaction, which implies anonymity;

ii) authentication of transaction outputs without signing the transaction; and

iii) good scalability, while preserving security, by generating blocks of smaller sizes—or better, the size of old blocks can be reduced thus producing a blockchain whose size does not grow in time as much as, for instance, Bitcoin’s.

The first two properties are achieved by resting, in the end, on Elliptic Curves Cryptography (ECC) operations and properties. The third one is a consequence of the first two.

Verification of transactions

If $v$ is the value of a transaction (either input or output) and $H$ is a point over an elliptic curve, then $vH$ encrypts $v$ because it is assumed to be computationally hard to get $v$ from $vH$ if we only know $H$. However, if $w$ and $z$ are other values such that $v+w=z$, then if we only have the result of encrypting each of them with $H$ we are still able to verify that equation. Indeed: $v+w=z\Leftrightarrow vH+wH=zH,$ due to simple properties of scalar multiplication over groups. Therefore, with this simple operations, we can check sums of transactions amounts without knowing the actual amounts.

Nevertheless, say some time ago we have encrypted $v$ with $H$ and now we see $vH$, then we know that it is the result of encrypting $v$. In the context of blockchain transactions this is a problem because once a block holding $vH$ is saved in the chain it will reveal all the transactions of $v$ coins. For such problems, MimbleWimble encrypts $v$ as $rG+vH$ where $r$ is an scalar and $G$ is another point in $H$’s elliptic curve. $r$ is called blinding factor and $rG+vH$ is called Pedersen Commitment. By using Pedersen Commitments, MimbleWimble allows for verification of expressions such as $v+w=z$ providing more privacy than with the standard scheme. In effect, if $v+w=z$ then we chose $r_{v}$, $r_{w}$ and $r_{z}$ such that $r_{v}G+r_{w}G=r_{z}G$ and so the expression is recorded as:

[TABLE]

making it possible for every one to verify the transaction without knowing the true values.

Authentication of transactions

Consider that Alice has received $v$ coins and this was recorded somewhere in the blockchain as $rG+vH$, where $r$ was chosen by her to keep it private. Now she wants to transfer these $v$ coins to Bob. As a consequence, Alice looses $v$ coins and Bob receives the very same amount, which means that the transaction adds to zero: $rG+vH-(rG+vH)=0G-0H$. However, Alice now knows Bob’s blinding factor because it must be the same chosen by her (so the transaction is balanced). In order to protect Bob from being stolen by Alice, MimbleWimble allows Bob to add his blinding factor, $r_{B}$, in such a way that the transaction is recorded as: $(r+r_{B})G+vH-(rG+vH)=r_{B}G-0H,$ although now it does not sum zero. However, this excess value is used as part of an authentication scheme. Indeed, Bob uses $r_{B}$ as a private key to sing, say, the empty string ($\epsilon$). This signed document is attached to the transaction so in the blockchain we have:

1. Input: $I$;

2. Output: $O$; and

3. Bob’s signed document: $S$.

In this way, in order to verify the transaction one has to see whether the result of decrypting $S$ with $I-O$ (in the group generated by $G$) yields $\epsilon$. If $I-O$ does not yield something of the form $r_{B}G-0H$, then $\epsilon$ will not be recovered and so we know there is an attempt to create money from thin air or there is an attempt to still Bob’s money.

3 Idealized model of a Mimblewimble-based blockchain

The basic elements in our model are transactions, blocks and chains. Each node in the blockchain maintains a local state. The main components are the local copy of the chain and the set of transactions waiting to be validated and added to a new block. Properties as zero-sum and the absence of double spending in blocks and chains must be proved for local states.

The blockchain global state can be represented as a mapping from nodes to local states. For global states, we can state and prove properties of the entire system like, for instance, correctness of the consensus protocol.

Transactions

Given two elliptic curves $G$ and $H$, we represent transactions as tuples of the form:

[TABLE]

where $X^{{}^{*}}$ represents the lists of $X$ elements. Each element in $i$ and $o$ is a pair of the form $(r,v)$ representing the Pedersen commitment in curves $G$, $H$. The transaction kernel $tk$ contains a list of range proofs of the outputs, a list of transaction excess and the kernel signature $\sigma$111For simplicity, we leave aside fees in this paper.. The transaction excess can be defined as:

[TABLE]

We said that the transaction is balanced iff $\sum{r^{\prime}}-\sum{r}=0$. So, in other words, the excess is $(\sum{v^{\prime}}-\sum{v})H$. The kernel signature proves that the transaction is honestly constructed, in particular that the excess only contains the blinding factor (no money is being created).

A transaction is valid if:

1. the range proofs of all the outputs are valid;

2. the kernel signature $\sigma$ is valid for the excess; and

3. the transaction is balanced.

Blocks and chains

Transactions can be merged into a block. We can see a block as a big transaction with aggregated inputs, outputs and transaction kernels.

A Block is either the genesis block $\mathit{Gen}$, or a record:

[TABLE]

representing the inputs, outputs, the kernel offset and the list of transaction kernels for the block. The kernel offset $k$ is a blinding factor that needs to be added back to the kernel excess to verify the commitments sum to zero.

Given a block $b=\{i,o,k,tks\}$, we say that a block is valid if the following equality holds:

[TABLE]

A chain is a non-empty list of blocks:

[TABLE]

For a chain $c$ and a valid block $b$, we can define a predicate $\mathit{validates(c,b)}$ representing the fact that is valid to add $b$ to $c$. This relation must check, for example, that all the inputs in $b$ are present as outputs in $c$, in other words, they are unspent transaction outputs (UTXOs).

Validating a chain

The model formalizes a notion of valid state that captures several well-formedness conditions. In particular, every block in the blockchain must be valid. A predicate $\mathit{validChain}$ can be defined for a chain $c=[b_{0},b_{1},\dots b_{n}]$ by checking that:

1. $b_{0}$is a valid genesis block, and

2. for every $i\in\{1,\dots n\}$, $\mathit{validates([b_{0},\dots,b_{i-1}],b_{i})}.$

The axiomatic semantics of the system is modeled by defining a set of actions, and providing their semantics as state transformers. The behaviour of actions is specified by a precondition and by a postcondition. This approach is valid when considering local (nodes) or global (blockchain) states and actions. Different set of actions, pre and postcondition are defined to cover local or global state transformations.

Valid states are invariant under execution. The properties in this work are obtained from valid states of the system.

4 Verification of MimbleWimble

We now proceed to discuss some relevant properties that can be verified on our model. In addition to some of the properties mentioned in Section 2 we also plan to include other properties such as those formulated in [15], and various security properties considered in [8, 12, 7] later.

4.0.1 Protocol Properties.

The zero-sum for valid transactions can be proved using properties of ECC. This property, and its proof, straightforwardly propagates to blocks, because adding zero-sum Pedersen commitments is a zero-sum Pedersen commitment.

An important feature of MimbleWimble is the cut-through process. The purpose of this property is to erase redundant outputs that are used as inputs within the same block. Let $C$ be some coins that appear as an output in the block $b$. If the same coins appear as an input within the block, then $C$ can be removed from the list of inputs and outputs after applying the cut-through process. In this way, eventually, the only data that remain are the block headers, transaction kernels and unspent transaction outputs (UTXOs). After applying cut-through to a valid block $b$ is important to ensure that the resulting block $b^{\prime}$ is still valid. We can say that the validity of a block should be invariant with respect to the cut-through process. Basically, this invariant holds because the matching inputs and outputs canceled each other in the overall sum.

Privacy and Security Properties.

In blockchain systems the notion of privacy is crucial: sensitive data should not be revealed over the network. In particular, it is desirable to ensure properties such as confidentiality, anonymity and unlinkability of transactions. The first one refers to the property of preventing other participants from knowing certain information about the transaction, such as the amounts and addresses of the owners. The second one refers to the property of hiding the real identity from the one is transacting while the third one refers to the inability of linking distinct transactions of the same user within the blockchain.

In the Bitcoin network, users interact with the system using public key hashes achieving a kind of pseudo-anonymity. Every transaction recorded on the ledger contains the addresses of the sender and receiver and the transaction amount. That information is publicly available breaking then the confidentiality property. Furthermore, it fails in providing unlinkability since it is possible to trace the transactions of the same associated addresses over the ledger.

In the case of Mimblewimble no addresses or public keys are used, there are only encrypted inputs and outputs. Therefore the communication between the sender and receiver to share the proof of ownership of the coins must be done off-chain using a secure channel. Privacy concerns rely on confidential transactions, cut-through and CoinJoin. The goal of CoinJoin is to combine inputs and outputs from different transactions into a single unified transaction. Thus, for a third-party it is difficult to determine which party is making a particular transaction. It is important to ensure that the resulting transaction satisfies the property of validity defined in the model.

The security problem of double spending refers to spend a coin more than once. All the nodes keep track of the UTXO set, so before confirming a block to the chain, the node checks that the inputs come from it. If we refer to our model, it is performed in the predicate validates mentioned in Section 3.

Zero-knowledge Proof.

The goal of this kind of proofs is to prove that a statment is true without revealing any information beyond the verification of the statment. These proofs could require interaction between the prover and the verifier or not. Genereally, when there is no interaction the validity of the proof relies on computational assumptions. In MimbleWimble we need to ensure that in every transaction the transaction amount is positive so that users cannot create coins. The key here is to prove that property without revealing the amount. As we defined in the model, the output amounts are hidden in the form of a Pedersen Commitment and the transaction contains a list of range proofs of the outputs to prove that the transaction amount is positive. MimbleWimble uses Bulletproofs [2] to achieve this goal222This proof rely on the discrete logarithm assumption and a trusted setup is not required. The proof size is logarithmic in the amount size and the proof generation and verification are linear in the bit length of the range.. In our model, this verification is performed as first step of the validity of the transaction.

4.0.2 Model-driven verification.

MimbleWimble is built on top of a consensus protocol. In that direction, we have developed a Z specification of a consensus protocol (see Appendix 0.A). Z specifications in turn can be easily translated into the $\{log\}$ language [4]. $\{log\}$ can be used as both a (prototyping) programming language and an automated theorem prover for an expressive fragment of set theory and set relation algebra. We include an excerpt of the $\{log\}$ prototype of a consensus protocol in Appendix 0.B. This $\{log\}$ prototype can be used as an executable model where simulations can be run. This allows us to analyze the behavior of the protocol without having to implement it in a low level programming language.

We also plan to use $\{log\}$ to prove some of the properties mentioned above. However, for complex properties or for properties not expressible in the set theories supported by $\{log\}$ we plan to develop a complete and uniform formulation of several security properties of the protocol using the Coq proof assistant [16]. Coq has an important set of libraries; for example [1] contains a formalization of elliptic curves theory, which allows the verification of elliptic curve cryptographic algorithms. The fact of first having a $\{log\}$ prototype over which some verification activities can be carried out without much effort helps in simplifying the process of writing a detailed Coq specification. This is in acordance with proposals such as QuickChick whose goal is to decrease the number of failed proof attempts in Coq by generating counterexamples before a proof is attempted [6].

Applying the program extraction mechanism provided by Coq we shall be able to derive a certified Haskell prototype of the protocol, which can be used as a testing oracle and also to conduct further verification activities on correct-by-construction implementations of the protocol. In particular, both the $\{log\}$ and Coq approaches can be used as forms of model-based testing. That is, we can use either specification to automatically generate test cases with which protocol implementations can be tested [5, 6].

5 Final remarks

We have put forward elements that constitute essential steps towards the development of an exhaustive formalization of the MimbleWimble cryptocurrency protocol, the analysis of its properties and the verification of its implementations. In particular, the proposed idealized model is key in the described verification process.

Appendix 0.A Excerpt of a Z Model of a Consensus Protocol

The following are some snippets of a Z model of a consensus protocol based on the model developed by Pîrlea and Sergey [15]. For reasons of space we just reproduce a little part of it.

The time stamps used in the protocol are modeled as natural numbers. Then we have the type of addresses ($Addr$), the type of hashes ($Hash$), the type of proofs objects ($Proof$) and the type of transactions ($Tx$). Differently from Pîrlea and Sergey’s model333From now on we will refer to Pîrlea and Sergey model simply as PS. we modeled addresses as a given type instead as natural numbers. In PS the only condition required for these types is that they come equipped with equality, which is the case in Z.

[TABLE]

The block data structure is a record with three fields: $prev$, (usually) points to the parent block; $txs$, stores the sequence of transactions stored in the block; and $pf$ is a proof object required to validate the block.

[TABLE]

The local state space of a participating network node is given by three state variables: $as$, are the addresses of the peers this node is aware of; $bf$, is a block forest (not shown) which records the minted and received blocks; and $tp$, is a set of received transactions which eventually will be included in minted blocks.

[TABLE]

The system configuration is represented by two state variables: $Delta$, which establishes a mapping between network addresses and the corresponding node (local) states (in PS this variable is referred to as the global state); and $P$, a set of packets (which represent the messages exchanged by nodes).

[TABLE]

Packets are just tuples of two addresses (origin and destination) and a message.

[TABLE]

The model has twelve state transitions divided into two groups: local and global. Local transitions are those executed by network nodes, while global transitions promote local transitions to the network level. In turn, the local transitions are grouped into receiving and internal transitions. Receiving transitions model the nodes receiving messages from other nodes and, possibly, sending out new messages; internal transitions model the execution of instructions run by each node when some local condition is met. Here, we show only the local, receiving transition named $RcvAddr$.

[TABLE]

As can be seen, $RcvAddr$ receives a packet ($p?$) and sends out a set of packets ($ps!$). The node checks whether or not the packet’s destination address coincides with its own address. In that case, the node adds the received addresses to its local state and sends out a set of packets that are either of the form $(p?.2,a,ConnectMsg)$ or $(p?.2,a,AddrMsg\,as^{\prime})$. The former are packets generated from the received addresses and sent to the new peers the node now knows, while the latter are messages telling its already known peers that it has learned of new peers.

Appendix 0.B Excerpt of a $\{log\}$ Prototype of a Consensus Protocol

In this section we show the $\{log\}$ code corresponding to the Z model presented in Appendix 0.A. $\{log\}$ code can be seen as both a formula and a program [4]. Thus, in this case we use the code as a prototype or executable model of the Z model. The intention is twofold: to show that passing from a Z specification to a $\{log\}$ program is rather easy, and to show how a $\{log\}$ program can be used as a prototype. The first point is achieved mainly because $\{log\}$ provides the usual Boolean conectives and most of the set and relational operators available in Z. Hence, it is quite natural to encode a Z specification as a $\{log\}$ program.

Given that $\{log\}$ is based on Prolog its programs resemble Prolog programs. The $\{log\}$ encoding of $RcvAddr$ is the following:

rcvAddr(LocState,P,Ps,LocState_) :- LocState = {[as,As] / Rest} & P = [,this, addrMsg(Asm)] & un(As,Asm,As) & diff(Asm,As,D) & Ps1 = ris(A in D,[],true,[this,A,connectMsg]) & Ps2 = ris(A in As,[],true,[this,A,addrMsg(As_)]) & un(Ps1,Ps2,Ps) & LocState_ = {[as,As_] / Rest}.

As can be seen, rcvAddr is clause receiving the before state (LocState), the input variable (P), the output variable (Ps) and the after state (LocState_). As in Prolog, $\{log\}$ programs are based on unification with the addition of set unification. In this sense, a statement such as LocState = {[as,As] / Rest} (set) unifies the parameter received with a set term singling out the state variable needed in this case (As) and the rest of the variables (Rest). The same is done with packet P where _ means any value as first component and addrMsg(Asm) gets the set of addresses received in the packet without introducing an existential quantifier.

The set comprehensions used in the Z specification are implemented with $\{log\}$’s so-called Restricted Intentional Sets (RIS) [3]. A RIS is interpreted as a set comprehension where the control variable ranges over a finite set (D and As).

Given rcvAddr we can perform simulations on $\{log\}$ such as:

S = {[as,{}] / R} & rcvAddr(S,[,this,addrMsg({a1,a2})],P1,S1) & rcvAddr(S1,[,this,addrMsg({a1,a3})],P2,S2).

in which case $\{log\}$ returns:

P1 = ris(A in {a1,a2/_N2},[],true,[this,A,connectMsg],true), S1 = {[as,{a1,a2}]/R}, P2 = {[this,a3,connectMsg],[this,a1,addrMsg({a2,a1,a3})], [this,a2,addrMsg({a2,a1,a3})] / ris(A in _N1,[],true,[this,A,connectMsg],true)}, S2 = {[as,{a2,a1,a3}]/R} Constraint: subset(_N2,{a1,a2}), subset(_N1,{a1,a3}), a1 nin _N1, a2 nin _N1

That is, $\{log\}$ binds values for all the free variables in a way that the formula is satisfied (if it is satisfiable at all). In this way we can trace the execution of the protocol w.r.t. states and outputs by starting from a given state (e.g. S) and input values (e.g. [_,this,addrMsg({a1,a2})]), and chaining states throughout the execution of the state transitions included in the simulation (e.g. S1 and S2).