text
stringlengths 2
132k
| source
dict |
|---|---|
process . We consider that the system is com-posed of N uniquely identified processes, denoted by p1, p 2, . . . , p N . Some-times we also denote the processes by p, q, r. The set of system processes is denoted by Π. Unless explicitly stated otherwise, it is assumed that this set is static (does not change) and processes do know of each other. We do not assume any particular mapping of our abstract notion of pro-cess to the actual processors, processes, or threads of a specific machine or operating system. The processes communicate by exchanging messages and the messages are uniquely identified, say by their original sender process us-ing a sequence number or a local clock, together with the process identifier. Messages are exchanged by the processes through communication links . We will capture the properties of the links that connect the processes through specific link abstractions, and which we will discuss later. 2.1.2 Automata and Steps A distributed algorithm is viewed as a collection of distributed automata, one per process. The automaton at a process regulates the way the process executes its computation steps, i.e., how it reacts to a message. The execution of a distributed algorithm is represented by a sequence of steps executed by the processes. The elements of the sequences are the steps executed by the processes involved in the algorithm. A partial execution of the algorithm is represented by a finite sequence of steps and an infinite execution by an infinite sequence. It is convenient for presentation simplicity to assume the existence of a global clock, outside the control of the processes. This clock provides a global and linear notion of time that regulates the execution of the algorithms. The steps of the processes are executed according to ticks of the
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
global clock: *DRAFT* 24 (22/11/2004) CHAPTER 2. BASICS 2.1. COMPUTATION one step per clock tick. Even if two steps are executed at the same physical instant, we view them as if they were executed at two different times of our global clock. A correct process executes an infinite number of steps, i.e., every process has an infinite share of time units (we come back to this notion in the next section). In a sense, there is some entity (a global scheduler) that schedules time units among processes, though the very notion of time is outside the control of the processes. A process step consists in receiving (sometimes we will be saying deliver-ing ) a message from another process (global event), executing a local com-putation (local event), and sending a message to some process (global event) (Figure 2.1). The execution of the local computation and the sending of a message is determined by the process automaton, i.e., the algorithm. Local events that are generated are typically those exchanged between modules of the same process at different layers. Process > (receive) incoming message outgoing message (send) internal computation (modules of the process) > Figure 2.1. Step of a process The fact that a process has no message to receive or send, but has some local computation to perform, is simply captured by assuming that messages might be nil , i.e., the process receives/sends the nil message. Of course, a process might not have any local computation to perform either, in which case it does simply not touch any of its local variables. In this case, the local computation is also nil. It is important to notice that the interaction between local components of the very same process is viewed as a local computation and not as a commu-nication. We will not be
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
talking about messages exchanged between modules of the same process. The process is the unit of communication, just like it is the unit of failures as we will discuss shortly below. In short, a communica-tion step of the algorithm occurs when a process sends a message to another process, and the latter receives this message. The number of communica-tion steps reflects the latency an implementation exhibits, since the network latency is typically a limiting factor of the performance of distributed algo-rithms. An important parameter of the process abstraction is the restriction imposed on the speed at which local steps are performed and messages are exchanged. *DRAFT* 25 (22/11/2004) 2.1. COMPUTATION CHAPTER 2. BASICS Unless specified otherwise, we will consider deterministic algorithms. That is, for every step performed by any given process, the local computation executed by the process and the message sent by this process are uniquely determined by the message received by the process and its local state prior to executing the step. We will also, in specific situations, describe randomized (or probabilistic ) algorithms where processes make use of underlying random oracles to choose the local computation to be performed or the next message to be sent, among a set of possibilities. 2.1.3 Liveness and Safety When we devise a distributed algorithm to implement a given distributed programming abstraction, we seek to satisfy the properties of the abstraction in all possible executions of the algorithm, i.e., in all possible sequences of steps executed by the processes according to the algorithm. These properties usually fall into two classes: safety and liveness . Having in mind the dis-tinction between these classes usually helps understand the abstraction and hence devise an adequate algorithm to implement it. • Basically, a safety property is a property of a distributed algorithm that can be
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
violated at some time t and never be satisfied again after that time. Roughly speaking, safety properties state that the algorithm should not do anything wrong. To illustrate this, consider a property of perfect links (which we will discuss in more details later in this chapter) that roughly stipulates that no process should receive a message unless this message was indeed sent. In other words, processes should not invent messages out of thin air. To state that this property is violated in some execution of an algorithm, we need to determine a time t at which some process receives a message that was never sent. More precisely, a safety property is a property that whenever it is violated in some execution E of an algorithm, there is a partial execution E′ of E such that the property will be violated in any extension of E′. In more sophisticated terms, we would say that safety properties are closed under execution prefixes. Of course, safety properties are not enough. Sometimes, a good way of preventing bad things from happening consists in simply doing nothing. In our countries of origin, some public administrations seem to understand this rule quite well and hence have an easy time ensuring safety. • Therefore, to define a useful abstraction, it is necessary to add some liveness properties to ensure that eventually something good happens. For instance, to define a meaningful notion of perfect links, we would require that if a correct process sends a message to a correct destination process, then the destination process should eventually deliver the message. To state that such a property is violated in a given execution, we need to show that there is no chance for a message to be delivered. *DRAFT* 26 (22/11/2004) CHAPTER 2. BASICS 2.2. PROCESSES More precisely, a
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
liveness property is a property of a distributed system execution such that, for any time t, there is some hope that the property can be satisfied at some time t′ ≥ t. It is a property for which, quoting Cicero: “While there is life there is hope”. In general, the challenge is to guarantee both liveness and safety. (The difficulty is not in talking , or not lying , but in telling the truth ). Indeed, useful distributed services are supposed to provide both liveness and safety proper-ties. Consider for instance a traditional inter-process communication service such as TCP: it ensures that messages exchanged between two processes are not lost or duplicated, and are received in the order they were sent. As we pointed out, the very fact that the messages are not lost is a liveness prop-erty. The very fact that the messages are not duplicated and received in the order they were sent are rather safety properties. Sometimes, we will con-sider properties that are neither pure liveness nor pure safety properties, but rather a union of both. ## 2.2 Abstracting Processes 2.2.1 Process Failures Unless it fails , a process is supposed to execute the algorithm assigned to it, through the set of components implementing the algorithm within that process. Our unit of failure is the process. When the process fails, all its components are supposed to fail as well, and at the same time. Process abstractions differ according to the nature of the failures that are considered. We discuss various forms of failures in the next section (Fig-ure 2.2). Omissions Crashes Arbitrary Crashes&recoveries > Figure 2.2. Failure modes of a process *DRAFT* 27 (22/11/2004) 2.2. PROCESSES CHAPTER 2. BASICS 2.2.2 Lies and Omissions A process is said to fail in an arbitrary manner if it deviates arbitrarily
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
from the algorithm assigned to it. The arbitrary fault behavior is the most general one. In fact, it makes no assumptions on the behavior of faulty processes, which are allowed any kind of output and in particular can send any kind of messages. These kinds of failures are sometimes called Byzantine (see the historical note at the end of this chapter) or malicious failures. Not surpris-ingly, arbitrary faults are the most expensive to tolerate, but this is the only acceptable option when an extremely high coverage is required or when there is the risk of some processes being indeed controlled by malicious users that deliberately try to prevent correct system operation. An arbitrary fault need not be intentional and malicious: it can simply be caused by a bug in the implementation, the programming language or the compiler, that causes the process to deviate from the algorithm it was supposed to execute. A more restricted kind of faults to consider is the omis-sion (Figure 2.2). An omission fault occurs when a process does not send (resp. receive) a message it is supposed to send (resp. receive), according to its algorithm. In general, omission faults are due to buffer overflows or network conges-tion. Omission faults result in lost messages. With an omission, the process deviates from the algorithm it is supposed to execute by dropping some mes-sages that should have been exchanged with other processes. 2.2.3 Crashes An interesting particular case of omissions is when a process executes its al-gorithm correctly, including the exchange of messages with other processes, possibly until some time t, after which the process does not send any mes-sage to any other process. This is what happens if the process for instance crashes at time t and never recovers after that time. If, besides not sending any message
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
after some time t, the process also stops executing any local computation after t, we talk here about a crash failure (Figure 2.2), and a crash stop process abstraction. The process is said to crash at time t. With this abstraction, a process is said to be faulty if it crashes. It is said to be cor-rect if it does never crash and executes an infinite number of steps. We discuss in the following two ramifications underlying the crash-stop abstraction. • It is usual to devise algorithms that implement a given distributed program-ming abstraction, say some form of agreement, provided that a minimal number F of processes are correct, e.g., at least one, or a majority. It is important to understand here that such assumption does not mean that the hardware underlying these processes is supposed to operate correctly forever. In fact, the assumption means that, in every execution of the al-gorithm making use of that abstraction, it is very unlikely that more than *DRAFT* 28 (22/11/2004) CHAPTER 2. BASICS 2.2. PROCESSES a certain number F of processes crash, during the lifetime of that very ex-ecution. An engineer picking such algorithm for a given application should be confident enough that the chosen elements underlying the software and hardware architecture make that assumption plausible. In general, it is also a good practice, when devising algorithms that implement a given distributed abstraction under certain assumptions to determine precisely which properties of the abstraction are preserved and which can be vio-lated when a specific subset of the assumptions are not satisfied, e.g., when more than F processes crash. • Considering a crash-stop process abstraction boils down to assuming that a process executes its algorithm correctly, unless it crashes, in which case it does not recover. That is, once it crashes, the process does
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
never per-form any computation. Obviously, in practice, processes that crash can in general be rebooted and hence do usually recover. It is important to notice that, in practice, the crash-stop process abstraction does not preclude the possibility of recovery, nor does it mean that recovery should be prevented for a given algorithm (assuming a crash-stop process abstraction) to be-have correctly. It simply means that the algorithm should not rely on some of the processes to recover in order to pursue its execution. These processes might not recover, or might recover only after a long period encompassing the crash detection and then the rebooting delay. In some sense, an algo-rithm that is not relying on crashed processes to recover would typically be faster than an algorithm relying on some of the processes to recover (we will discuss this issue in the next section). Nothing prevents however recovered processes from getting informed about the outcome of the computation and participate in subsequent instances of the distributed algorithm. Unless explicitly stated otherwise, we will assume the crash-stop process abstraction throughout this manuscript. 2.2.4 Recoveries Sometimes, the assumption that certain processes never crash is simply not plausible for certain distributed environments. For instance, assuming that a majority of the processes do not crash, even only long enough for an algorithm execution to terminate, might simply be too strong. An interesting alternative as a process abstraction to consider in this case is the crash-recovery one; we also talk about a crash-recovery kind of failure (Figure 2.2). We say that a process is faulty in this case if either the pro-cess crashes and never recovers, or the process keeps infinitely crashing and recovering. Otherwise, the process is said to be correct. Basically, such a pro-cess is eventually always (i.e., during the lifetime of the algorithm execution
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
of interest) up and operating. A process that crashes and recovers a finite number of times is correct in this model (i.e., according to this abstraction of a process). *DRAFT* 29 (22/11/2004) 2.2. PROCESSES CHAPTER 2. BASICS According to the crash-recovery abstraction, a process can indeed crash, in this case the process stops sending messages, but might later recover. This can be viewed as an omission fault, with one exception however: a process might suffer amnesia when it crashes and loses its internal state. This significantly complicates the design of algorithms because, upon recovery, the process might send new messages that contradict messages that the process might have sent prior to the crash. To cope with this issue, we sometimes assume that every process has, in addition to its regular volatile memory, a stable storage (also called a log ), which can be accessed through store and retrieve primitives. Upon recovery, we assume that a process is aware that it has crashed and recovered. In particular, a specific 〈 Recovery 〉 event is supposed to be automatically generated by the run-time environment in a similar manner to the 〈 Init 〉 event, executed each time a process starts executing some algo-rithm. The processing of the 〈 Recovery 〉 event should for instance retrieve the relevant state of the process from stable storage before the processing of other events is resumed. The process might however have lost all the remain-ing data that was preserved in volatile memory. This data should thus be properly re-initialized. The 〈 Init 〉 event is considered atomic with respect to recovery. More precisely, if a process crashes in the middle of its initialization procedure and recovers, say without having processed the 〈 Init 〉 event prop-erly, the process should redo again the 〈 Init 〉 procedure
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
before proceeding to the 〈 Recovery 〉 one. In some sense, a crash-recovery kind of failure matches an omission one if we consider that every process stores every update to any of its variables in stable storage. This is not very practical because access to stable storage is usually expensive (as there is a significant delay in accessing it). Therefore, a crucial issue in devising algorithms with the crash-recovery abstraction is to minimize the access to stable storage. We discuss in the following three important ramifications underlying the crash-recovery abstraction. • One way to alleviate the need for accessing any form of stable storage is to assume that some of the processes never crash (during the lifetime of an algorithm execution). This might look contradictory with the ac-tual motivation for introducing the crash-recovery process abstraction at the first place. In fact, there is no contradiction, as we explain below. As discussed earlier, with crash-stop failures, some distributed programming abstractions can only be implemented under the assumption that a certain number of processes do never crash, say a majority the processes participat-ing in the computation, e.g., 4 out of 7 processes. This assumption might be considered unrealistic in certain environments. Instead, one might con-sider it more reasonable to assume that at least 2 processes do not crash during the execution of an algorithm. (The rest of the processes would in-deed crash and recover.) As we will discuss later in the manuscript, such *DRAFT* 30 (22/11/2004) CHAPTER 2. BASICS 2.2. PROCESSES assumption makes it sometimes possible to devise algorithms assuming the crash-recovery process abstraction without any access to a stable storage. In fact, the processes that do not crash implement a virtual stable storage abstraction, and this is made possible without knowing in advance which of the processes will not crash in
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
a given execution of the algorithm. • At first glance, one might believe that the crash-stop abstraction can also capture situations where processes crash and recover, by simply having the processes change their identities upon recovery. That is, a process that recovers after a crash, would behave, with respect to the other processes, as if it was a different process that was simply not performing any action. This could easily be done assuming a re-initialization procedure where, besides initializing its state as if it just started its execution, a process would also change its identity. Of course, this process should be updated with any information it might have missed from others, as if indeed it did not receive that information yet. Unfortunately, this view is misleading as we explain below. Again, consider an algorithm devised using the crash-stop process abstraction, and assuming that a majority of the processes do never crash, say at least 4 out of a total of 7 processes composing the system. Consider furthermore a scenario where 4 processes do indeed crash, and process one recovers. Pretending that the latter process is a different one (upon recovery) would mean that the system is actually composed of 8 processes, 5 of which should not crash, and the same reasoning can be made for this larger number of processes. This is because a fundamental assumption that we build upon is that the set of processes involved in any given computation is static and the processes know of each other in advance. In Chapter 7, we will revisit that fundamental assumption and discuss how to build the abstraction of a dynamic set of processes. • A tricky issue with the crash-recovery process abstraction is the inter-face between software modules. Assume that some module at a process, involved in the implementation
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
of some specific distributed abstraction, delivers some message or decision to the upper layer (say the application) and subsequently the process hosting the module crashes. Upon recovery, the module cannot determine if the upper layer (i.e., the application) has processed the message or decision before crashing or not. There are at least two ways to deal with this issue. 1. One way is to change the interface between modules. Instead of delivering a message (or a decision) to the upper layer, the module may instead store the message (decision) in a stable storage that is exposed to the upper layer. It is then up to the upper layer to access the stable storage and exploit delivered information. 2. A different approach consists in having the module periodically deliver-ing the message or decision to the application until the latter explicitely asks for stopping the delivery. That is, the distributed programming *DRAFT* 31 (22/11/2004) 2.3. COMMUNICATION CHAPTER 2. BASICS abstraction implemented by the module is in this case responsible for making sure the application will make use of the delivered information. ## 2.3 Abstracting Communication The link abstraction is used to represent the network components of the distributed system. We assume that every pair of processes is connected by a bidirectional link, a topology that provides full connectivity among the processes. In practice, different topologies may be used to implement this abstraction, possibly using routing algorithms. Concrete examples, such as the ones illustrated in Figure 2.3, include the use of a broadcast medium (such as an Ethernet), a ring, or a mesh of links interconnected by bridges and routers (such as the Internet). Many implementations refine the abstract network view to make use of the properties of the underlying topology. (a) (b) (c) >
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
Title: Fair Exchange URL Source: Markdown Content: # Chapter 5 Fair Exchange # Mohammad Torabi Dashti and Sjouke Mauw # 5.1 What Is Fairness? Fairness is a broad concept, covering a range of qualifications such as impartiality, courtesy, equity, sportsmanship, etc. Here, we focus on fairness in exchanging (electronic) goods, stipulating that none of the partners can take an undue advantage over the other. When is an interaction between two or more people called fair? Let us proceed with a few examples that reflect fairness as it is understood in the security literature. Our examples, as the cryptographic tradition goes, are scenarios involving Alice and Bob. To learn more about these people see [Gor05]. • Alice and Bob want to divide a piece of cake into two parts, one part for Alice and one part for Bob. None of them trusts the other one for this purpose. Alice gets to cut the cake into two pieces, and Bob gets to choose which part he wants. It is in Alice’s interest to maximize the smallest piece of the two. This is because a rational Bob would choose the bigger piece, leaving Alice with the smaller piece. Alice, being a rational person too, prefers to cut the cake into halves. • Alice takes a taxi. She, however, does not want to pay the driver Bob before he takes her to her destination. Bob, not trusting Alice, does not want to take Alice to her destination before she pays. The fee is 100 Euros. Alice rips a 100 Euro bill into halves, and gives a half to Bob. To receive the other half, it is now in Bob’s interest to take Alice to her destination. Alice, however, has already “spent” her 100 Euros, and does not benefit from not giving the other
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
half to Bob, once Bob takes her to her destination. Do these scenarios describe fair interactions? We will analyze them more carefully in the following. In the cut-and-choose scenario, indeed there is an assumption that neither Alice nor Bob would take the whole cake and simply run away. Under this assumption, cut and choose is fair, in the sense that Alice and Bob will both be content with the result. None of them has any reason to envy the other one; cf. [BPW07]. In the taxi driver scenario, clearly Bob should take Alice to her destination to get paid. Bob, however, knows that Alice has no interest in not paying him. She has already ripped up her 100 Euro bill, and can as well give the other half to Bob, once she is at her destination. 1 Here, Bob, relying on the assumption that Alice is rational, would take Alice 109 110 CHAPTER 5. FAIR EXCHANGE to her destination. Similarly, Alice, under the assumption that Bob is rational, would rip up the 100 Euro bill. Remark that both parties need to assume that their opponent is rational in this scenario. Indeed, a malicious Alice could harm Bob by not paying him the other half, and a malicious Bob could harm Alice by not taking her to her destination after she has ripped the bill. Note that no such rationality assumption is needed to ensure fairness in the cut-and-choose scenario. If Alice cuts the cake unfairly, it is only Alice who is in a disadvantage. In other words, both Alice and Bob are guaranteed to end up with at least half of the cake, without any assumptions on the rationality of the other party; Alice however must play rational to ensure that she gets at least a half. These examples show
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
that fairness is indeed a subtle issue. In the following, we abstract away various non-technical aspects of fairness, and focus on fairness in electronic exchanges. # 5.2 Fairness in Electronic Exchanges At a high level of abstraction, an action, such as signing a contract, may be considered as a single event even though it is made up of a number of more elementary actions. We say that the execution of such a composed action is atomic if either all of its sub-actions are executed, or none at all. Applying this terminology to electronic exchanges, we understand fairness as the basic property of atomicity, meaning that all parties involved in the interaction receive a desired item in exchange for their own, or none of them does so. The exchange of items is often governed by a set of rules, stating which steps are taken in which order and by whom. Such a set of rules is referred to as a protocol . Fairness here is thus a property of the means of the exchange, e.g., a protocol, rather than the exchanged material per se. The difference between electronic exchange and conventional commerce and barter es-sentially lies in enforceable laws. If Alice pays for a product to Bob and Bob fails to deliver the product (as stated in their contract), then Alice can resort to litigation, which is en-forceable by law. In electronic commerce, however, litigation is often not viable. This is because laws to evaluate and judge based on electronic documents are mostly inadequate, the exchange partners may be subject to different laws (e.g., they may live in different countries), and, more importantly, the accountable real world party behind an electronic agent may not be traceable; cf. [San97]. The current practice of electronic commerce, therefore, heavily relies on trusted third parties.
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
Most vendors on Internet, for instance, offer little beyond browsing their catalogues, while contract signing and payment often go via a credit card company. The trust in these sites is largely built upon the trust users have in the credit card companies, which keep records and provide compensation in case of fraud. Fairness in electronic commerce in fact turns out to be unachievable if there is no presumed trust among the involved parties [EY80]; see Section 5.3.2. We thus focus on fair exchange protocols which rely on trustees. When there is a mediator who is trusted by all the exchange partners, there is a canonical solution to fair exchange. The items subject to exchange can be sent to the trusted entity and then he would distribute them if all the items arrive in time. If some items do not arrive in time, the mediator would simply abandon the exchange. Figure 5.1 shows such an exchange. In the first phase, A sends iA to the mediator T and B sends iB to T . Here iA and iB are the items subject to exchange. In the next phase, T sends iB to A and iA to B.This mechanism is inefficient, as it involves the mediator in every exchange, and therefore does not scale well. The involvement of the trusted party can in fact be reduced to the point that he would need to take actions only when something goes amiss in the exchange (e.g., an item does not arrive in time). Such protocols are preferred when most exchange 5.2. FAIRNESS IN ELECTRONIC EXCHANGES 111 partners are honest and, thus, failed exchanges are infrequent; hence these protocols are called optimistic protocols. Figure 5.1: Exchange using a trusted mediator. # 5.2.1 Fair Exchange Flavors Various flavors of the fair exchange (FE) problem exist
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
in the literature, e.g., fair contract signing (CS), fair payment (FP), fair certified email (CEM), and fair exchange of secrets (ES). Below, we introduce these FE variants via examples: • Fair contract signing (CS): Alice and Bob have agreed on a contract and would like to sign it electronically. 2 Alice gives her signature on the contract to Bob only if she receives the contract signed by Bob. Similarly, Bob signs the contract and passes it to Alice, only if he receives Alice’s signature. In short, they want to simultaneously exchange their signatures. • Fair payment (FP): Alice sees Bob’s electronic book on the Internet and wants to buy it, but she does not want to send her digital coins to Bob before receiving the book and making sure that it is indeed what he has advertised. Similarly, Bob does not want to send his electronic book to Alice before receiving Alice’s coins and making sure that they are genuine. They want to simultaneously exchange their digital items. • Fair certified email (CEM): Alice wants to send an email to Bob in exchange for a receipt. The receipt is a proof that shows Bob has received the email. Therefore, the receipt must uniquely identify the content of the email. Bob is in turn willing to send back the receipt to Alice only if he actually receives Alice’s email. Notice that in this case, Alice and Bob do not aim at simultaneous exchange. This is because of the inherent asymmetry of the problem, namely, the receipt depends on the content of the email. • Fair exchange of secrets (ES): Alice and Bob each possess a secret that is not known to the other one. Alice and Bob would like to exchange their secrets, but neither of them wants to reveal their
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
secret unilaterally. Note that this exchange is meaningful only if Alice and Bob can recognize the expected secrets. That is, they can verify that received data are indeed the other party’s secret. Otherwise, any protocol that distributes random bits would be acceptable, since Alice would think that the junk is actually Bob’s secret, and similarly for Bob. Although these problems are similar and we refer to them collectively as FE, there are subtle differences between them. For instance, CEM and CS are different in simultaneity, and CEM is different from ES in that the receipt of an email is not precisely defined in CEM, and can thus be different from one protocol to another (as it happens to be in practice), 112 CHAPTER 5. FAIR EXCHANGE while ES is to exchange the secrets themselves. It is also notable that in ES the participants are assumed to be able to recognize the other party’s secret. This is a trivial precondition when it comes to CS, because signatures are the subject of exchange, and digital signatures always have a verification algorithm associated to them. Yet another class of FE protocols consists of the non-repudiation protocols (NR). Their aim is to exchange evidences in a fair manner, meaning that Alice receives an evidence of receipt if and only if Bob receives an evidence of origin on a certain document. An evidence of receipt can for instance be formed by Bob signing a document that he has received from Alice, and an evidence of of origin can be formed by Alice signing the document she sends to Bob. The participants are further required to be accountable for (i.e., they cannot deny) the promises they utter in the course of the exchange. We do not distinguish NR and CEM protocols in this document, since these
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
are conceptually very similar. The challenge in NR protocols is to exchange the evidences in a fair way, otherwise, non-repudiation of the evidences can be achieved using standard digital signatures; cf. [ZG97b]. We remark that in fair contract signing, termination is a challenging problem in practice. For instance consider the following scenario. A contract to sell a property P for some amount of money M has a meaning only if it is seen by an authority, e.g., the city hall, to transfer the ownership of the property to the buyer. In this situation, the seller can sign the following statement and send it to the buyer. The seller declares that if the buyer signs this letter, then the buyer will own the property P , and the buyer thereby promises to transfer M dollars to the account of the seller. Now, the buyer cannot have the property P without pledging to pay M dollars to the seller; this exchange is thus fair. The above solution for fairness, however, leaves the seller in a disadvantageous position regarding the termination of the exchange. Namely, the buyer can sign the statement when-ever he wishes. Meanwhile, the seller is the owner of the property only in a weak sense. The seller cannot sell the property to anyone else, and does not know when the property is not his anymore. Nevertheless, the seller knows that if some day the property is owned by the buyer, the seller is eligible to the amount of money mentioned in the statement. This example motivates the timeliness requirement for fair exchange protocols, as described below. # 5.2.2 Fair Exchange Requirements In the literature, there is no consensus on what FE protocols (or its variants) have to provide. Nevertheless, most authors seem to include formulations of fairness and timeliness similar
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
to the ones proposed by [Aso98]. Below, we informally describe these goals for two parties, named A and B: • Fairness states that if A terminates the protocol in a state where A has B’s item, then when B terminates the protocol, B has A’s item, and vice versa. This property is often referred to as strong fairness ; cf. [PVG03]. • Timeliness states that any honest participant can terminate the exchange unilaterally, i.e., without any help from the opponent. Timeliness guarantees that none of the participants can arbitrarily force the other one to wait for the termination of the exchange. Any protocol that achieves these goals is said to solve FE. 35.3. SOLVABILITY OF FAIR EXCHANGE 113 We remark that each variant of FE can have its own specific requirements. For instance, timeliness is sometimes deemed unnecessary for CEM, e.g., see [Mic03]. See [BVV84] for a formal study on the relations among the requirements of the FE variants mentioned above. # 5.3 Solvability of Fair Exchange In this section, we focus on solvability of the FE problem, thus focusing on questions such as: In which network settings can fair exchange be achieved? How many malicious parties can subvert a fair exchange protocol among n parties? etc. We start with a general intro-duction to security protocols, and then consider the solvability of FE in synchronous and asynchronous settings. No trusted entity is assumed in studying solvability in Sections 5.3.2 and 5.3.3. # 5.3.1 Security Protocols A distributed system consists of a finite number of participants who interact by some com-munication primitives, such as sending and receiving messages, accessing a shared memory, etc. Below, we assume communications take place solely through sending and receiving messages over communication channels. A collection of communication channels is called a communication network. We write A
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
→ B : m, when participant A submits message m to the communication network, with the intention that it should be delivered to participant B. A synchronous channel guarantees to deliver messages in a timely manner, with a pre-known time bound, while asynchronous channels deliver messages eventually, but no time bounds are put on them. Channels may in general lose, duplicate, or distort messages. Unless explicitly stated, we do not consider such faulty channels. 4 A protocol assigns an algorithm to each participant. The algorithms may use the commu-nication primitives that are available to the participants to achieve a certain common goal. A synchronous protocol assumes that the participants execute their algorithms in lock-step, i.e., there is a common clock available to all the participants, and that the communication channels are synchronous. Asynchronous protocols do however not assume these properties. A fault tolerant protocol achieves its goal even if some of the participants are faulty. Different failure models are used in distributed systems to characterize how a faulty participant may misbehave. One of the simplest models is crash failure , in which the failed participant simply dies, i.e., ceases to act afterwards. In the Byzantine failure model [LSP82], a faulty participant may deviate from the algorithm assigned to it in any fashion, but its view is local and its effects are local, i.e., it only sees what is passed to it by its neighbors, and it can only send messages to its neighbor participants. Cryptographic or security protocols are fault tolerant protocols which use cryptography to attain their goals. In computer security, the Dolev-Yao model [DY81, DY83], denoted DY , is usually considered as the hostile environment model. 5 In this model, there is one malicious participant (called attacker, intruder, saboteur, etc.), comprising all the outsider and insider corrupted parties,
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
which has control over the entire communication network. 6 It intercepts all messages that have been transmitted and can store them in its knowledge set. It can also remove or delay messages in favor of others being communicated. “[It] is a legitimate user of the network, and thus in particular can initiate a conversation with other users” [DY83]. Security protocols are typically designed to protect the interests of the honest participants, i.e., those who faithfully follow the protocol, in presence of the DY attacker. Honest participants only follow the protocol, and, in general, are not required to 114 CHAPTER 5. FAIR EXCHANGE take any steps to detect or thwart attacks. Protocols must thus be designed to guarantee that if a participant follows the rules of the protocol, then his interests are protected. The DY attacker can be seen as a Byzantine participant which is sitting in the center of a star-like network topology. All other participants therefore communicate through DY ,hence the network being of connectivity 1. 7 Network connectivity indeed plays a role in the possibility of distributed tasks, performed in presence of malicious parties; see [FLM86, Syv97]. # 5.3.2 Solvability of Fair Exchange in Synchronous Systems Even and Yacobi [EY80], and independently Rabin [Rab81], studied simple variants of the FE problem. In [EY80], a notion of mutual signature on a message (the CS problem) is studied. They informally reason that “if the judicator is not active during the ordinary op-eration of the system,” then no two-party protocol can achieve agreement , where agreement means that when a party can compute the signature, the other one can also do so. Their argument goes as: “Assume that, after n communications, [Alice] has sufficient information for efficient calculation of [the mutual signature], but that this is not true for n −
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
1 com-munications. We conclude that [Bob] transmits the nth communication, and therefore the first time [Bob] has sufficient information is after n′ communications, where n′ = n. This contradicts [the definition of agreement].” Rabin considers the similar problem of simultaneous exchange of secrets between two non-trusting entities Alice and Bob (the ES problem). He deduces that the problem is un-solvable: “Any [exchange] protocol must have the form: Alice gives to Bob some information I1, Bob gives to Alice J1, Alice gives to Bob I2, etc. There must exist a first k such that, say, Bob can determine [Alice’s secret] from I1, . . . , I k, while Alice still cannot determine [Bob’s secret] from J1, . . . , J k−1. Bob can withhold Jk from Alice and thus obtain [Alice’s secret] without revealing [his own secret].” Since these problems are instances of FE, their unsolvability implies unsolvability of FE in the corresponding models. Both these arguments clearly stress on the malicious act of withholding the last message. They can thus be summarized as: No two-party protocol with one Byzantine participant, even with synchronous communication channels, can solve FE. This result naturally carries over to asynchronous protocols. We remark that a crucial feature of this model is that no party is trusted by other participant(s). A participant is trusted if and only if it is publicly known that the participant is (and remains) non-faulty. DeMillo, Lynch, and Merritt formalized the impossibility arguments mentioned above in [DLM82]. In [BOGW88] and, independently, in [CCD88], the authors derive general solvability re-sults regarding the secure multi-party computation (SMPC) problem, in complete graph topologies (where every two nodes are connected). SMPC and FE, albeit being differ-ent problems, are tightly related. These results are therefore pertinent to our discussion. In [BOGW88] it is established
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
that, in a fully connected network of synchronous channels, n-party SMPC, and thus FE, is achievable if there are at most t Byzantine participants, with t < n/ 3. They also prove that there exist SMPC problems which, with t ≥ n/ 3 Byzantine participants, are unsolvable for n parties. The results of [EY80, Rab81] clearly show that FE is one of these problems. See [GL02, Mau06] for excellent reviews on further developments in SMPC. We note that the possibility results of [BOGW88, CCD88] do not imply the solvability of FE in the DY model, simply because the connectivity of the network is 1 in the DY model, while these results are stated in complete graph topologies. In fact, reaching distributed consensus , a problem conceptually similar to FE, is impossible if the network connectivity is less than 2 t + 1, with t Byzantine participants [FLM86]. For a formal comparison between 5.4. FAIR EXCHANGE IN THE DOLEV-YAO MODEL 115 FE and distributed consensus in various models see [OT08]. # 5.3.3 Solvability of Fair Exchange in Asynchronous Systems In asynchronous systems, the impossibility result of [FLP85] and its extension [MW87] imply that multi-party FE is unsolvable when at least one of the participants is subject to crash failure. For two-party exchanges, this result has been derived in [PG99] by reducing the distributed consensus problem to FE. It is worth mentioning that the impossibility results of [DLM82, EY80, Rab81] are based on the malicious act of withholding parts of information, whereas [PG99] prove impossibility of FE in the presence of benign, but not “malicious,” failures, as a result of lack of knowledge to decide termination in asynchronous systems. These concern orthogonal difficulties in solving FE, and none of them directly implies the other one. Up until now, we focused on the
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
effects of participant failures, as opposed to channel failures, on solving the FE problem. Below, we consider the case of lossy channels, while assuming that participants are all honest (i.e., they faithfully follow their protocol). In distributed computing, the limitations on reaching agreement in the presence of lossy chan-nels is usually described using the generals paradox [Gra78]: “There are two generals on campaign. They have an objective (a hill) that they want to capture. If they simultane-ously march on the objective they are assured of success. If only one marches, he will be annihilated. The generals are encamped only a short distance apart, but due to technical difficulties, they can communicate only via runners. These messengers have a flaw, every time they venture out of camp they stand some chance of getting lost (they are not very smart.) The problem is to find some protocol that allows the generals to march together even though some messengers get lost.” Gray informally argues that such a protocol does not exist [Gra78]. This has later on been formally proved in, e.g., [HM84, YC79]. The generals’ problem can be reduced to two-party FE by noticing that the generals can use a fair exchange protocol to agree on a time for attack. The impossibility result stated above, thus, implies that FE is unsolvable in the presence of channel failures, when participants are honest. Furthermore, in the presence of channel failures, “any protocol that guarantees that whenever either party attacks the other party will eventually attack, is a protocol in which necessarily neither party attacks” [HM84]. This result implies that, in optimistic FE pro-tocols, resilient channels are unavoidable even when all participants are honest. A channel is resilient if and only if any message inserted into one end of the channel is eventually delivered to the
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
other end. # 5.4 Fair Exchange in the Dolev-Yao Model Fair exchange cannot be achieved in the presence of the DY attacker if there is no trust in the system (see Section 5.3). Many fair exchange protocols thus assume the presence of a trusted third party (TTP). The TTP is further assumed to be connected to protocol participants through resilient channels. We come back to this topic shortly. There are three general constructions for FE, based on the degree of the involvement of trusted third parties. The first group needs no TTPs, e.g., the protocols of [BOGMR90, Blu81, Cle90, EGL85, MR99, Rab81]. See also [FGY92] for a chronological survey on these protocols. These are based on gradual release of information or gradual increase of privileges and require exchanging many messages to approximate fair exchange, as deterministic asynchronous FE with no trusted parties is impossible (see Section 5.3). The idea behind such gradual release protocols is that a party will only have a minimal advantage if he decides to cheat. 116 CHAPTER 5. FAIR EXCHANGE Protocols of the second group need the TTP’s intervention in each exchange, e.g., see [AG02, BT94, CTS95, DGLW96, FR97, ZG96a, ZG96b]. In the literature, these are sometimes called protocols with in-line or on-line TTPs . On-line TTPs, although being involved in each exchange, act only as a light-weight notary, as opposed to in-line TTPs which directly handle the items subject to exchange; cf. [ZG96c]. The protocols of the sec-ond group have a fixed, usually small, number of message exchanges, and are thus more appealing in practice. However, the TTP can easily become a communication bottleneck or a single target of attacks, as it is involved in each exchange. Protocols of [Rab83, RS98] can also be listed in the second group as they require the TTP to
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
be active during each exchange. However, a slight difference is that, intuitively, the TTPs in the latter protocols need not “be aware” of being involved in such exchanges. For instance, the TTP in Rabin’s protocol acts as a beacon, broadcasting signals which can be used by others to perform fair exchange. The third group of FE protocols, known as optimistic protocols, require the TTP’s intervention only if failures, accidentally or maliciously, occur, e.g., see [ASW97, ASW98a, ASW98b, BDM98, CCT05, CTM07, DR03, Eve83, Mic97, Mic03, MK01, PCS03, ZDB99, ZG97a]. Therefore, honest parties that are willing to exchange their items can do so without involving any TTP. Optimistic protocols are called protocols with off-line TTP s since the TTP need not be active at the time the exchange goes on; the TTP can be contacted in a later time. # 5.4.1 Optimistic Fair Exchange We focus on asynchronous two-party optimistic exchange protocols. The DY model is as-sumed for the attacker. The exchange partners A and B are connected via DY . There is a trusted third party T , which is immune to failures. The TTP is connected to A and B via resilient channels. The Resilient Channel Assumption A channel between two participants is resilient if and only if any message inserted into one end of the channel is eventually delivered to the other end. The resilience assumption is an asymptotic restriction, i.e., messages are delivered eventually, but no bounds are placed on the order or the time of delivering these messages. As mentioned after the generals’ paradox in Section 5.3.3, in order to achieve timeli-ness, fair exchange protocols need resilient channels. Intuitively, unilaterally terminating the exchange by a participant corresponds to marching to the hill by a general. A general may safely march to the hill only if he knows
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
the other general would do so. Similarly, a participant may consider the exchange terminated only if she knows the other participant would also do so. In the DY model, however, the communication media are assumed to be under complete control of the intruder. The DY intruder can in particular destroy transmitted messages. For liveness properties, such as timeliness, to hold in the DY intruder model, the assumption that the intruder does not disrupt (some of) the communication channels must therefore be added. Resilient channels are not readily available in most practical situations. Available faulty channels can nonetheless be used to provide resilience, as described below. Assuming resilient channels in security protocol thus helps us to abstract from the underlying mechanisms which actually provide resilience. There are various ways to construct resilient channels from faulty ones. Let us assume that A and B are connected with a faulty channel c which may lose, duplicate, and reorder 5.4. FAIR EXCHANGE IN THE DOLEV-YAO MODEL 117 messages. To distinguish c from a channel that is only temporarily available, we assume that there is a bound on the number of messages that c can discard. We say that a channel is fair lossy if and only if any message that is inserted to one end of the channel an infinite number of times is delivered to the other end of the channel an infinite number of times. 8 If c is a fair lossy channel, which may duplicate and reorder messages, then retransmission and tagging allow A and B to construct a reliable FIFO channel on top of c; e.g., see Stenning’s protocol [Lyn96, Ste76]. In the DY intruder model, it is assumed that the only possible means of communication between A and B is DY . The DY intruder, however, need not be
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
a fair lossy medium and can destroy all the messages that are transmitted through it. Therefore, no reliable channel may be constructed between A and B in the DY model. Nevertheless, the assumption that DY controls all communication media between A and B is often impractical. For instance, in wireless networks, given that jamming is only locally sustainable, A and B can always move to an area where they can send and receive messages. Ultimately, two principals who fail to properly establish a channel over computer networks can resort to other communication means, such as various postal services. These services, albeit being orders of magnitude slower than computer networks, are very reliable and well protected by law. We thus postulate that any A and B who are willing to communicate can eventually establish a (fair lossy) channel, despite DY ’s obstructions. To add this postulation to the DY model, weakening DY to the extent that it behaves as a fair lossy channel is adequate. This is the essence of the resilient channels assumption. The Structure of Optimistic Protocols We opt for a high level description that underlines the exchange patterns. Exact message contents are abstracted away, and all messages are assumed to contain enough information for protocol participants to distinguish different protocol instantiations, and different roles in protocols. Detailed specification of these issues is orthogonal to our current purpose. Optimistic protocols typically consist of three sub-protocols: the main or optimistic sub-protocol, the abort sub-protocol, and the recovery sub-protocol. Figure 5.2 depicts a generic main sub-protocol between A and B. The regions in which the other two sub-protocols are alternative possibilities are numbered (1–4) in the figure. In the main sub-protocol that does not involve the TTP, the agents first commit to release their items and then they actually release them.
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
The items subject to exchange, and commitments are respectively denoted by iA, i B and cA(iA), c B (iB ). In Figure 5.2 we have m1 = cA(iA), m2 = cB (iB ), m3 = iA,and m4 = iB . If no failures occur, the participants exchange their items successfully using the main sub-protocol. Figure 5.2: Generic four-message protocol. 118 CHAPTER 5. FAIR EXCHANGE If an expected message does not arrive in time, or the arrived message does not conform to the protocol, then the participant expecting that message can resort to the TTP using abort or recovery sub-protocols. These sub-protocols help the participant to reach a fair state and subsequently terminate. Here we introduce the notion of resolve patterns , which is useful in describing optimistic FE protocols. Consider again the generic four-message protocol shown in Figure 5.2. A resolve pattern determines which of the abort and resolve sub-protocols are available to participants when they are waiting for a message from their opponent in the main sub-protocol; namely, the alternative sub-protocols envisaged for points 1, 2, 3, and 4 in Figure 5.2. Four different symbols can be assigned to a point in the resolve pattern: abort (a), recovery (r), quit (q), and none (−). Intuitively, occurrence of the symbol a means that at that point the participant can initiate an abort sub-protocol, thereby requesting the TTP to abort the exchange protocol. Likewise, occurrence of an r means that the participant can initiate a recovery sub-protocol, thereby requesting the TTP to help him recover from a situation in which it has received a commitment from the other participant without having received the other participant’s item. Occurrence of a q means that in case the expected message does not arrive in time, the participant can safely quit the exchange without contacting
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
the TTP. Naturally, if no message has been exchanged, the participant quits the protocol, e.g., B in Figure 5.2 quits the exchange if he does not receive the first message in time. A ‘none’ option ( −) indicates that the participant has no alternatives but following the optimistic protocol. It turns out that ‘none’ options undermine termination of asynchronous optimistic FE protocols. This is intuitive because participants may crash and never send the message their opponent is waiting for. When communicating with the TTP (using resolve sub-protocols), however, participants know that the message they send to and expect to receive from the TTP will be delivered in a finite time. This is due to resilience of the channels, and the fact that the TTP is immune to failures (see TTP assumptions, above). We use tuples for representing resolve patterns. For instance, a resolve pattern for the protocol of Figure 5.2 can be ( q, a, r, r), listing the symbols attached to points 1, 2, 3, and 4, respectively. The resolve sub-protocols (abort/recovery) involve the TTP. In order to simplify the reasoning we assume that the participant sends its message history (all messages sent and received up to now by the participant in the current execution of the protocol) to the TTP, and based on these the TTP either returns an abort token A, or a recovery token R. Token A often has no intrinsic value; it merely indicates that the TTP will never send an R token in the context of the current exchange. Token R should, however, help a participant to recover to a fair state. Although it is impossible for B alone to derive the item iA from the commitment cA(iA) (and similar for iB ), it is often assumed that the TTP can generate iA from
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
cA(iA), and iB from cB (iB ), and that R contains iA and iB . In case the TTP cannot do so, usually an affidavit from the TTP is deemed adequate; cf. weak fairness [PVG03]. The resilient channels guarantee that, in case of failures, protocol participants can ultimately consult the TTP. Participant A can run the recovery protocol if the opponent B has committed to ex-change, but A has not received B’s item, and vice versa. A participant aborts (cancels) the exchange if she does not receive the opponent’s commitment to the exchange. The TTP logic matching the resolve pattern ( q, a, r, r) for the protocol of Figure 5.2 is shown in Figure 5.3. For each exchanged item, the finite state Mealy machine of the TTP is initially in the undisputed state sU. If the TTP receives a valid abort request (from A)while being at state sU, then it sends back an abort token, and moves to aborted state sA.Similarly, if the TTP is in state sU, and receives a valid resolve request (from either A or B), then it sends back R, containing iA and iB , and moves to recovered state sR. When the 5.5. A SELECTIVE LITERATURE REVIEW 119 Figure 5.3: Abstract Mealy machine of TTP. TTP is in either of sA or sR states, no matter if it receives an abort or a recovery request on this exchange, it consistently replies with A or R, respectively. 9 In state sR, the TTP typically stores R (which contains iA and iB ). This is because, if B sends a recovery request, and then A sends an abort request, the TTP needs to send back R to A. However, the TTP needs cB (iB ) to generate iB , and thus construct R. An abort request
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
by A nevertheless does not contain cB (iB ). Therefore, once the TTP computes R for an exchange, it stores R in its secure storage, for possible future uses. In Figure 5.3, a and r stand for valid abort and recovery requests, while A and R stand for the corresponding abort and recovery tokens, respectively. Remark that depending on the current state of the TTP a participant may receive an abort token A even if it sends a resolve request r to the the TTP, and vice versa. # 5.5 A Selective Literature Review Below, we review some of the main ideas and results on solving the FE problem in the DY model. This review is selective. In particular, we do not touch upon various FE protocols that were developed to go beyond fair exchange requirements and satisfy an extended set of functional or security goals (some of these are, however, discussed in subsequent sections). Synchronous protocols are also mostly absent from our review. For general surveys on the topic see several Ph.D. dissertations that have been written on this topic, e.g., [Aso98, Cha03, Gon05, Kre03, Nen05, Oni06, Sch00, Tor08]. Generatable and Revocable Items. Pivotal to the working of optimistic protocols is the nature of the items that are subject to exchange. It has been shown in [SW02] that optimistic FE is impossible if the exchanged items are neither generatable nor revocable . In general, no such restriction applies to FE protocols with in-line or on-line TTPs though. An item is generatable if the TTP can generate the item from a participant’s commitment to release that item, and an item is revocable if the TTP can revoke the validity of that item. In general, digital items are neither generatable nor revocable. However, cryptographic tools, such as verifiable encryption, can make
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
certain digital items generatable. For instance, see [ASW98b, Ate04, Che98, DJH07, DR03, PCS03] for techniques to enable the TTP to generate participants’ signatures from their commitments; see also [RR00]. In contrast, there are not many digital items that can be revoked by the TTP (see below). The above-mentioned impossibility result of [SW02] comes as no surprise when noticing that if a wronged Bob resorts to the TTP, he wishes (at least) one of the following services: Either the TTP can generate the item that he has expected, which is impossible if the item is not generatable, or the TTP can revoke the item that he has lost (i.e., currently being in the possession of Alice), which is impossible if the item is not revocable. The TTP can, however, provide Bob with an affidavit declaring that Bob has indeed been cheated (by Alice). In this case, Bob only achieves weak fairness [Aso98], which might not satisfy Bob. 120 CHAPTER 5. FAIR EXCHANGE Below, we explore how such affidavits can be used to provide strong fairness in CS, CEM, and NR protocols. The goal is to provide strong fairness without using costly cryptographic tools such as verifiable encrypted signatures. The idea is to exploit a freedom that is inherent to the definitions of CS, CEM, and NR. In these FE variants, the protocol (designer) is free to define what constitutes, e.g., a mutually signed contract, a signed receipt, or evidence of origin. Therefore, these protocols devise dispute resolution procedures to evaluate (or interpret) the digital assets that are collected in the protocol. Dispute resolution procedures can thereby be tailored to grade affidavits from the TTP as, for instance, a valid evidence of origin. This idea has been used in many FE protocols such as [ASW98a, CCT05, CTM07, GRV05, KMZ02, ZDB99, ZG97a]. Note
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
that these protocols enforce the structure of the exchanged items, hence being called invasive [ASW98a]. Non-invasive protocols are more favorable, but come at high computation costs, as they rely on heavy cryptographic tools, as in, e.g., the signature exchange protocols of [ASW98b]. A partial remedy to invasiveness is to make the TTP invisible [Mic97], so that there would not be any difference between the evidences collected in optimistic runs and those issued by the TTP. Note that the structure of the evidences is still determined by the protocol, hence the result may be an invasive protocol (e.g., as in [Mic03]). However, the exchanged items would not reveal whether the TTP was involved in the exchange. For protocols with invisible or transparent TTPs, see, e.g., [ASW98a, Ate04, Mic97, Mic03, MK01, MS02]. As is phrased by Asokan, “typically, non-invasiveness implies invisibility of third party” [Aso98]. Now we turn to fair exchange of revocable items. Generally, it is hard to revoke digital items. However, certain payment systems can in principle provide revocable coins, e.g., see [JY96, Vog03]. Fair payment protocols which employ revocable money (orders) are presented in [ASW98a, Vog03]. A separate group of protocols for exchanging revocable items exploits the freedom in the definition of CS, CEM, and NR, just as mentioned earlier. These not only prescribe a tailored dispute resolution procedure to grade the TTP’s messages as valuable evidences, but they also require the TTP to in some situations participate in the dispute resolution phase of the protocol in order to revoke evidences collected by the participants. Examples of protocols following this idea are [Eve83, FPH00, FPH02, FPH04, MD02, WBZ04, Zho04]. These protocols require three messages in their exchange sub-protocols, compared to optimistic protocols for generatable items that require four messages. It has been shown in [Sch00] that three messages is
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
the minimum number of messages in exchange sub-protocols, given that the TTP is allowed to participate in the dispute resolution phase, while this number is four if the TTP is not allowed to do so. Requiring the TTP’s intervention in the evidence verification phase can be a drawback for these protocols because evidences carry no weight until the TTP declares that they have not been revoked. 10 Idempotent and Non-Idempotent Items. Most FE protocols assume that the items subject to exchange are idempotent [Aso98], meaning that receiving or possessing an item once is the same as receiving it multiple times. For example, once Alice gets access to Bob’s signature on a contract, receiving it again some time later does not add anything to Alice’s knowledge. The idempotency assumption reflects the mass reproducibility of dig-ital items. However, there exist protocols for exchanging digital non-idempotent items. Electronic vouchers [FE03, FKT +99] are prominent examples of non-idempotent items. Depending on the implementation, right tokens in digital rights management systems can as well be considered as digital non-idempotent items; e.g., see [84, TKJ08]. The current approach to securely use non-idempotent items is to limit their distribution to trusted computing devices, which are currently becoming more prevalent. Protocols for handling 5.5. A SELECTIVE LITERATURE REVIEW 121 non-idempotent items, being FE protocols or not, usually require that items are neither created nor destroyed in the course of the protocol; e.g., see [FKT +99, TIHF04]. This re-sembles the money atomicity property in electronic commerce, stating that money is neither destroyed nor generated in exchanges [Tyg96]. Using trusted devices in FE is not limited to exchanging non-idempotent items. These are used for exchanging idempotent items as well, mainly in order to increase protocols’ efficiency or flexibility. Examples are [Tor09] to reduce the number of messages to three in
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
the optimistic sub-protocol, [VPG01] for exchanging time-sensitive items, and [TMH06] for optimistic exchange of non-revocable, non-generatable items; recall that optimistic FE requires that at least one of the items be either revocable or generatable [SW02]. 11 See also [AGGV05, AV04, ES05, FFD +06, GR06] on using trusted devices in FE. Bounds on the Number of Messages. The premise of optimistic FE is that failures are infrequent, and consequently fallback sub-protocols are executed rarely. Therefore, a mean-ingful measure of efficiency in these protocols is the number of messages exchanged in the main optimistic sub-protocol. Several results regarding optimal efficiency of asynchronous two-party optimistic CS and CEM protocols have been derived in [PSW98, Sch00]. The main results regarding the optimal number of messages in exchange sub-protocols are men-tioned above, namely, three messages when the TTP is allowed to intervene in the dispute resolution phase, and four messages otherwise. Therefore, protocols that require only three messages in the exchange sub-protocol and do not rely on TTP’s intervention in the dispute resolution phase do not satisfy the requirements of fair exchange. For instance, the protocols of [Mic03], with three messages in the main sub-protocol, do not provide timeliness. Fair exchange between trusted devices requires three messages in the optimistic protocol when the items subject to exchange are idempotent [Tor09]. For exchanging non-idempotent items three messages in the optimistic sub-protocol are sufficient, given that the trusted devices have access to an unlimited secure storage; otherwise, four messages in the optimistic sub-protocol are sufficient and necessary [Tor09]. These results are summarized in Table 5.1. Note that exchanging non-idempotent among non-trusted devices is inherently insecure. Table 5.1: Optimal number of messages in two-party optimistic sub-protocol. Computing devices Items non-idempotent idempotent non-trusted − 4trusted (unlimited secure storage) 3 3trusted (limited storage) 4 3It is shown [PSW98, Sch00]
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
that the TTP needs to be stateful , i.e., to keep states of disputed exchanges, to guarantee fairness in asynchronous optimistic protocols. From a practical point of view, this result is of great relevance. Optimistic FE not only requires TTPs for recovering from unfair transient states, it needs TTPs which maintain persistent databases, containing the states of disputed exchanges, for virtually an indefinite amount of time. Naturally, in long runs, TTPs may crash or be compromised. 12 Mechanisms to limit the damages of these defects are described below. Before that, we remark that the optimistic protocols with stateless TTPs are either unfair, such as [Ate04, Mic03, NZB04] which do not provide timeliness, 13 or rely on synchronous communication channels, such as [ES05]. 122 CHAPTER 5. FAIR EXCHANGE Accountability and Robustness of the Trustee. Malicious TTPs can inevitably sub-vert an exchange protocol; this is indeed the definition of trusted parties [And01]. To demo-tivate malicious TTPs from cheating on protocol participants, Asokan introduces protocols in which TTPs are verifiable [Aso98]. Given that corrupted TTPs do not simply disappear, a protocol with verifiable TTP allows wronged participants to prove TTP’s misbehavior to an external court. Accountability is thus a prohibition mechanism, relying on the assumption that a TTP prefers not being detected as malicious. This is a tenable assumption because external courts might be able to impose financial penalties on the TTP, the TTP may be concerned about its reputation, etc. Verifiability and transparency of TTPs are however not mutually attainable as is noted by Asokan; e.g., see [GJM99] for a concrete protocol where these two requirements clash. To reduce the dependency of protocols on availability and sanity of a single trusted party, distributed TTPs can be used. In [AdG01] parts of the TTP’s work are delegated to intermediary semi-trusted agents to reduce
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
the TTP’s burden, and in [RRN05, SXL05] secret sharing schemes are used so that, to subvert the protocol, an attacker needs to com-promise several TTPs. Note that distributed TTPs in general need to run some atomic commit protocol to ensure the consistency of their (distributed) state. We recall that (1) attaining fairness in optimistic asynchronous protocols is impossible without state-ful TTPs [Sch00], and (2) atomic commit protocols are nearly as expensive as fair ex-change [AFG +04, LNJ01, RRN05, Tan96, Tyg96]. Related to distributed TTPs, Ito, Iwai-hara, and Kambayashi in [IIK02] assume that participants have limited trust in TTPs and propose algorithms to determine if a rational agent would engage in an exchange using cascades of TTPs. In the context of fair exchange protocols in which the TTP is involved in every exchange (online TTPs), Franklin and Reiter use a secret sharing scheme to limit what a TTP can learn about exchanged materials [FR97]. They assume that the TTP does not collude with any of the participants, but has its own interests in the matter. Weaker Notions of Fairness. There are several alternatives to FE that do not need TTPs at all, but can provide only a weak notion of fairness. The concept of rational exchange of Syverson [Syv98] seeks to achieve fairness, with no TTPs, assuming that the parties are rational, i.e., they try to maximize their benefits. This assumption is in contrast to the pessimistic view prevalent in the security community that honest parties should be protected even from self-damaging attackers. The idea is “not to enforce compliance with the protocol, but to remove incentives to cheat;” cf. [Jak95]. A few scenarios in which rational exchange can be of practical use are mentioned in [Syv98]. See also the taxi-driver example of Section 5.1. Game theory can provide valuable insights
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
into the properties of exchange protocols, when assuming that their participants are rational agents, rather than categorizing them as malicious and honest parties, who blindly act regardless of their interests. For more on this approach see [ADGH06, BHC04, CMSS05, IIK02, IZS05, San97, SW02, TW07]. Concurrent signatures proposed in [CKP04], and further investigated in [SMZ04, TSS06, WBZ06], provide a weak alternative to fair exchange. These generally do not require any TTP interventions. The idea is that Alice and Bob produce two ambiguous signatures that become bound to their corresponding signers only when a keystone is released by Alice. The main shortcoming of the construct is that Bob has no control over the termination of the protocol, and, moreover, Alice can secretly show Bob’s signature to other parties before publishing the keystone; cf. the notion of abusefree protocols [GJM99]. A few scenarios in which this level of fairness is adequate are mentioned in [CKP04]. NOTES 123 Multiparty Protocols. Multiparty fair exchange protocols are notoriously hard to de-sign and analyze. The early protocols, such as [Aso98, GM99], have mostly been found flawed [CKS04, MR08a]. Mukhamedov and Ryan introduce a class of startling attacks on multiparty CS, dubbed abort chaining attacks, which truly demonstrate the subtlety of these protocols. Minimal number of messages, although known for two-party FE protocols [Sch00, Tor09], in multi-party cases are under study. Building upon the idea of abort chaining attacks it is shown by [MRT09] that an n-party asynchronous fair contract protocol requires at least n2 + 1 messages in the optimistic sub-protocol. This result is obtained by connecting the multiparty FE problem to the combinatorial problem of finding shortest permutation sequences [Adl74]. Designing Optimistic Fair Exchange Protocols. To conclude this chapter, we point out some of the resources that can be of use when designing FE protocols. Many
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
of the prudent advice [AN96] and attack scenarios known for authentication and key distribution protocols [Car94, CJ97] are pertinent to FE protocols as well. Papers specifically focusing on FE are unfortunately scarce. We note that compilations of FE protocols are almost non-existent, [KMZ02] being a notable exception. New protocols are constantly devised with subtle differences between their assumptions, methods, and goals, thus making it difficult to oversee general techniques. As of design methodologies, [Aso98, PVG03] discuss constructing generic FE protocols and [GRV05] provides templates for conservative NR protocols. The collections of attacks on NR and CEM protocols, presented, respectively, in [Lou00] and [SWZ06], give designers an opportunity to assess their new protocols against known attacks. These are however not well classified, and in particular flaws stemming in the interaction between protocols and cryptographic apparatuses used in them are mostly omitted; see [DR03] for an example of such attacks on FE protocols. There has been a considerable amount of work on formal verification of fair exchange protocols. See, for instance, the dissertations [Car09, Kre03, Tor08], and also [BP06, GR03, KK05, KKT07, KKW05, SM02, WH07]. However, we are not aware of any comprehensive guide or survey on existing formal techniques for verifying FE protocols. This would be desirable for practitioners. # Acknowledgments The authors are grateful to Bruno Conchinha Montalto for proofreading the article. Mo-hammad Torabi Dashti has been supported by the FP7-ICT-2007-1 Project no. 216471, “AVANTSSAR: Automated Validation of Trust and Security of Service-Oriented Architec-tures.” # Notes > 1This of course does not imply that Alice would give the other half to Bob. Alice can choose not to pay, as it will not change her profit vs. loss balance. Remark that if Alice can use the other half of the bill to convince another taxi driver in a similar scenario later,
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
indeed Alice would benefit from not giving the other half to Bob. To avoid such situations, Bob must ensure that Alice rips a bill into two halves afresh. > 2Fair and private contract negotiation protocols are discussed in, e.g., [FA05]. > 3Fairness, as defined in this article, is a safety property, while timeliness is a liveness property. Intuitively, a safety property states that something bad does not happen, while a liveness property stipulates that something good will happen [AS85]. > 4As is described later, the attacker is modeled as a participant that can inject messages into the channels and remove messages from (some of) the channels, even if the channels are assumed to be non-faulty. 124 NOTES > 5 For a critique on the DY model in face of the emerging mobile ad-hoc protocols, see, e.g., [Gli07]. > 6 Any number of DY attackers can be modeled as a single DY attacker by merging their knowledge sets [SM00]. > 7 A network has connectivity c if and only if at least c nodes need to be removed to disconnect the network. In the DY model removing the attacker node would disconnect the network. > 8 This corresponds to the strong loss limitation condition in [Lyn96]. A weaker variant of this requirement states that if an infinite number of messages are sent to the channel, then some infinite subset of them are delivered. > 9 Inconsistent (but correct) logics for the TTP have been used, e.g., in [MR08b], where the TTP may reply R to a correct participant, after realizing that it has previously replied A to a malicious party. > 10 Such protocols are sometimes called non-monotonic [Ate04]. > 11 The protocol of [VPG01] does not provide timeliness, as is pointed out in [Vog03], and the protocol of [TMH06] is
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
susceptible to a replay attack (we skip describing the attack, as it would require a detailed description of the protocol, and the attack is also rather obvious). The ideas behind these protocols can however be salvaged with some changes. > 12 The notion of compromisable trustee may seem to be paradoxical. We note that being trusted does not imply being trustworthy ; e.g., see [Gol06]. > 13 These protocols in fact require channels that can buffer messages for virtually an indefinite amount of time, thus merely delegating the “stateful-ness” to a different entity. # References [AdG01] G. Ateniese, B. de Medeiros, and M. Goodrich. TRICERT: A distributed certified email scheme. In NDSS ’01 . Internet Society, 2001. [ADGH06] I. Abraham, D. Dolev, R. Gonen, and J. Halpern. Distributed computing meets game theory: Robust mechanisms for rational secret sharing and mul-tiparty computation. In PODC ’06 , pages 53–62. ACM Press, 2006. [Adl74] L. Adleman. Short permutation strings. Discrete Math. , 10:197–200, 1974. [AFG +04] G. Avoine, F. Freiling, R. Guerraoui, K. Kursawe, S. Vaudenay, and M. Vukolic. Reducing fair exchange to atomic commit. Technical Report 200411, EPFL, Lausanne, Switzerland, 2004. [AG02] M. Abadi and N. Glew. Certified email with a light on-line trusted third party: Design and implementation. In WWW ’02 , pages 387–395. ACM Press, 2002. [AGGV05] G. Avoine, F. G¨ artner, R. Guerraoui, and M. Vukolic. Gracefully degrading fair exchange with security modules. In EDCC ’05 , volume 3463 of Lecture Notes in Computer Science , pages 55–71. Springer, 2005. [AN96] M. Abadi and R. Needham. Prudent engineering practice for cryptographic protocols. IEEE Trans. Softw. Eng. , 22(1):6–15, 1996. [And01] R. Anderson. Security Engineering: A Guide to Building Dependable Dis-tributed Systems . John Wiley & Sons, 2001. [AS85] B. Alpern and F. Schneider. Defining liveness. Inf. Process. Lett. ,
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
21(4):181– 185, 1985. [Aso98] N. Asokan. Fairness in electronic commerce . Ph.D. thesis, University of Waterloo, Canada, 1998. [ASW97] N. Asokan, M. Schunter, and M. Waidner. Optimistic protocols for fair ex-change. In CCS ’97 , pages 8–17. ACM Press, 1997. REFERENCES 125 [ASW98a] N. Asokan, V. Shoup, and M. Waidner. Asynchronous protocols for optimistic fair exchange. In IEEE Security and Privacy ’98 , pages 86–99. IEEE CS, 1998. [ASW98b] N. Asokan, V. Shoup, and M. Waidner. Optimistic fair exchange of digital signatures (extended abstract). In EUROCRYPT ’98 , volume 1403 of LNCS ,pages 591–606. Springer, 1998. Extended version in IEEE Journal on Selected Areas in Communications , 18(4): 593–610, 2000. [Ate04] G. Ateniese. Verifiable encryption of digital signatures and applications. ACM Trans. Inf. Syst. Secur. , 7(1):1–20, 2004. [AV04] G. Avoine and S. Vaudenay. Fair exchange with guardian angels. In WISA ’03 ,volume 2908 of Lecture Notes in Computer Science , pages 188–202. Springer, 2004. [BDM98] F. Bao, R. Deng, and W. Mao. Efficient and practical fair exchange protocols with off-line TTP. In IEEE Security and Privacy ’98 , pages 77–85. IEEE CS, 1998. [BHC04] L. Butty´ an, J. Hubaux, and S. Capkun. A formal model of rational exchange and its application to the analysis of Syverson’s protocol. J. Comput. Secur. ,12(3-4):551–587, 2004. [Blu81] M. Blum. Three applications of the oblivious transfer: Part I: Coin flipping by the telephone; part II: How to exchange secrets; part III: How to send cer-tified electronic mail. Technical report, Dept. EECS, University of California, Berkeley, 1981. [BOGMR90] M. Ben-Or, O. Goldreich, S. Micali, and R. Rivest. A fair protocol for signing contracts. IEEE Trans. on Information Theory , 36(1):40–46, 1990. [BOGW88] M. Ben-Or, S. Goldwasser, and A. Wigderson. Completeness theorems for non-cryptographic fault-tolerant distributed computation. In STOC ’88 , pages 1–10. ACM Press, 1988.
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
[BP06] G. Bella and L. Paulson. Accountability protocols: Formalized and verified. ACM Trans. Inf. Syst. Secur. , 9(2):138–161, 2006. [BPW07] S. Brams, K. Pruhs, and G. Woeginger, editors. Fair Division . Num-ber 07261 in Dagstuhl Seminar Proceedings. Internationales Begegnungs-und Forschungszentrum f¨ ur Informatik (IBFI), Schloss Dagstuhl, Germany, Dagstuhl, Germany, 2007. [BT94] A. Bahreman and D. Tygar. Certified electronic mail. In NDSS ’94 , pages 3–19. Internet Society, 1994. [BVV84] M. Blum, U. Vazirani, and V. Vazirani. Reducibility among protocols. In CRYPTO ’83 , pages 137–146. Plenum Press, 1984. [Car94] U. Carlsen. Cryptographic protocols flaws. In CSFW ’94 , pages 192–200. IEEE CS, 1994. [Car09] R. Carbone. LTL Model-Checking for Security Protocols . Ph.D. thesis, Uni-versity of Genova, Italy, 2009. [CCD88] D. Chaum, C. Cr´ epeau, and I. Damgard. Multiparty unconditionally secure protocols. In STOC ’88 , pages 11–19. ACM Press, 1988. 126 NOTES [CCT05] J. Cederquist, R. Corin, and M. Torabi Dashti. On the quest for impartiality: Design and analysis of a fair non-repudiation protocol. In ICICS ’05 , volume 3783 of Lecture Notes in Computer Science , pages 27–39. Springer, 2005. [Cha03] R. Chadha. A formal analysis of exchange of digital signatures . Ph.D. thesis, University of Pennsylvania, 2003. [Che98] L. Chen. Efficient fair exchange with verifiable confirmation of signatures. In ASIACRYPT ’98 , volume 1514 of Lecture Notes in Computer Science , pages 286–299. Springer, 1998. C. Chong, S. Iacob, P. Koster, J. Montaner, and R. van Buuren. License transfer in OMA-DRM. In ESORICS ’06 , volume 4189 of Lecture Notes in Computer Science , pages 81–96. Springer, 2006. [CJ97] J. Clark and J. Jacob. A survey of authentication protocol literature (version 1.0), 1997. citeseer.ist.psu.edu/clark97survey.html. [CKP04] L. Chen, C. Kudla, and K. Paterson. Concurrent signatures. In EURO-CRYPT ’04 , volume 3027 of Lecture Notes in Computer Science
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
, pages 287– 305. Springer, 2004. [CKS04] R. Chadha, S. Kremer, and A. Scedrov. Formal analysis of multi-party con-tract signing. In CSFW ’04 , pages 266–265. IEEE CS, 2004. [Cle90] R. Cleve. Controlled gradual disclosure schemes for random bits and their applications. In CRYPTO ’89 , volume 435 of Lecture Notes in Computer Science , pages 573–588. Springer, 1990. [CMSS05] R. Chadha, J. Mitchell, A. Scedrov, and V. Shmatikov. Contract signing, optimism, and advantage. J. Log. Algebr. Program. , 64(2):189–218, 2005. [CTM07] J. Cederquist, M. Torabi Dashti, and S. Mauw. A certified email protocol using key chains. In SSNDS ’07 , pages 525–530. IEEE CS, 2007. [CTS95] B. Cox, J. Tygar, and M. Sirbu. NetBill security and transaction protocol. In 1st Usenix Workshop in Electronic Commerce , pages 77–88. USENIX Associ-ation, 1995. [DGLW96] R. Deng, L. Gong, A. A. Lazar, and W. Wang. Practical protocols for certified electronic mail. J. Network Syst. Manage. , 4(3):279–297, 1996. [DJH07] Y. Dodis, P. Joong Lee, and D. Hyun Yum. Optimistic fair exchange in a multi-user setting. In PKC ’07 , volume 4450 of Lecture Notes in Computer Science , pages 118–133. Springer, 2007. [DLM82] R. DeMillo, N. Lynch, and M. Merritt. Cryptographic protocols. In STOC ’82 , pages 383–400. ACM Press, 1982. [DR03] Y. Dodis and L. Reyzin. Breaking and repairing optimistic fair exchange from PODC 2003. In DRM ’03 , pages 47–54. ACM Press, 2003. [DY81] D. Dolev and A. Yao. On the security of public key protocols (extended abstract). In FOCS ’81 , pages 350–357. IEEE CS, 1981. [DY83] D. Dolev and A. Yao. On the security of public key protocols. IEEE Trans. on Information Theory , IT-29(2):198–208, 1983. REFERENCES 127 [EGL85] S. Even, O. Goldreich, and A. Lempel. A randomized protocol for signing contracts. Commun. ACM , 28(6):637–647, 1985. [ES05]
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
P. Ezhilchelvan and S. Shrivastava. A family of trusted third party based fair-exchange protocols. IEEE Trans. Dependable Secur. Comput. , 2(4):273–286, 2005. [Eve83] S. Even. A protocol for signing contracts. SIGACT News , 15(1):34–39, 1983. [EY80] S. Even and Y. Yacobi. Relations among public key signature systems. Tech-nical Report 175, Computer Science Dept., Technion, Haifa, Israel, March. 1980. [FA05] K. Frikken and M. Atallah. Achieving fairness in private contract negotiation. In FC ’05 , volume 3570 of Lecture Notes in Computer Science , pages 270–284. Springer, 2005. [FE03] K. Fujimura and D. Eastlake. Requirements and design for voucher trading system (VTS). RFC 3506 (Informational), 2003. [FFD +06] M. Fort, F. Freiling, L. Draque Penso, Z. Benenson, and D. Kesdogan. Trust-edPals: Secure multiparty computation implemented with smart cards. In ESORICS ’06 , volume 4189 of Lecture Notes in Computer Science , pages 34– 48. Springer, 2006. [FGY92] M. Franklin, Z. Galil, and M. Yung. An overview of secure distributed comput-ing. Technical Report TR CUCS-008-92, Department of Computer Science, Columbia University, March 1992. [FKT +99] K. Fujimura, H. Kuno, M. Terada, K. Matsuyama, Y. Mizuno, and J. Sekine. Digital-ticket-controlled digital ticket circulation. In Proc. the 8th USENIX Security Symposium , pages 229–240. USENIX Association, 1999. [FLM86] M. Fischer, N. Lynch, and M. Merritt. Easy impossibility proofs for dis-tributed consensus problems. Distrib. Comput. , 1(1):26–39, 1986. [FLP85] M. Fischer, N. Lynch, and M. Paterson. Impossibility of distributed consensus with one faulty process. J. ACM , 32(2):374–382, 1985. [FPH00] J. Ferrer-Gomila, M. Payeras-Capell` a, and L. Huguet-i-Rotger. An efficient protocol for certified electronic mail. In ISW ’00 , volume 1975 of Lecture Notes in Computer Science , pages 237–248. Springer, 2000. [FPH02] J. Ferrer-Gomila, M. Payeras-Capell` a, and L. Huguet-i-Rotger. A realistic protocol for multi-party certified electronic mail. In ISC ’02 , volume 2433
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
of Lecture Notes in Computer Science , pages 210–219. Springer, 2002. [FPH04] J. Ferrer-Gomila, M. Payeras-Capell` a, and L. Huguet-i-Rotger. Optimality in asynchronous contract signing protocols. In TrustBus ’04 , volume 3184 of Lecture Notes in Computer Science , pages 200–208. Springer, 2004. [FR97] M. Franklin and M. Reiter. Fair exchange with a semi-trusted third party (extended abstract). In CCS ’97 , pages 1–5. ACM Press, 1997. [GJM99] J. Garay, M. Jakobsson, and P. MacKenzie. Abuse-free optimistic contract signing. In CRYPTO ’99 , volume 1666 of Lecture Notes in Computer Science ,pages 449–466. Springer, 1999. 128 NOTES [GL02] S. Goldwasser and Y. Lindell. Secure computation without agreement. In DISC ’02 , volume 2508 of Lecture Notes in Computer Science , pages 17–32. Springer, 2002. [Gli07] V. Gligor. On the evolution of adversary models in security protocols: From the beginning to sensor networks. In ASIACCS ’07 , page 3. ACM Press, 2007. [GM99] J. Garay and P. MacKenzie. Abuse-free multi-party contract signing. In Proceedings of the 13th International Symposium on Distributed Computing ,pages 151–165, London, UK, 1999. Springer-Verlag. [Gol06] D. Gollmann. Why trust is bad for security. In STM ’05 , volume 157 of ENTCS , pages 3–9, 2006. [Gon05] N. Gonz´ alez-Deleito. Trust relationships in exchange protocols . Ph.D. thesis, Universit´ e Libre de Bruxelles, 2005. [Gor05] J. Gordon. Alice and Bob. In Bruce Christianson, Bruno Crispo, James A. Malcolm, and Michael Roe, editors, Security Protocols Workshop , volume 4631 of Lecture Notes in Computer Science , pages 344–345. Springer, 2005. [GR03] S. G¨ urgens and C. Rudolph. Security analysis of (un-) fair non-repudiation protocols. In FASec ’02 , volume 2629 of Lecture Notes in Computer Science ,pages 97–114. Springer, 2003. [GR06] B. Garbinato and I. Rickebusch. A topological condition for solving fair ex-change in Byzantine environments. In ICICS ’06
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
, volume 4307 of Lecture Notes in Computer Science , pages 30–49. Springer, 2006. [Gra78] J. Gray. Notes on data base operating systems. In Operating Systems, An Advanced Course , volume 60 of Lecture Notes in Computer Science , pages 393–481. Springer, 1978. [GRV05] S. G¨ urgens, C. Rudolph, and H. Vogt. On the security of fair non-repudiation protocols. Int. J. Inf. Sec. , 4(4):253–262, 2005. [HM84] J. Halpern and Y. Moses. Knowledge and common knowledge in a distributed environment. In PODC ’84 , pages 50–61. ACM Press, 1984. [IIK02] C. Ito, M. Iwaihara, and Y. Kambayashi. Fair exchange under limited trust. In TES ’02 , volume 2444 of Lecture Notes in Computer Science , pages 161–170. Springer, 2002. [IZS05] K. Imamoto, J. Zhou, and K. Sakurai. An evenhanded certified email system for contract signing. In ICICS ’05 , volume 3783 of Lecture Notes in Computer Science , pages 1–13. Springer, 2005. [Jak95] M. Jakobsson. Ripping coins for fair exchange. In EUROCRYPT ’95 , volume 921 of Lecture Notes in Computer Science , pages 220–230. Springer, 1995. [JY96] M. Jakobsson and M. Yung. Revokable and versatile electronic money. In CCS ’96 , pages 76–87. ACM Press, 1996. [KK05] D. K¨ ahler and R. K¨ usters. Constraint solving for contract-signing protocols. In CONCUR ’05 , volume 3653 of Lecture Notes in Computer Science , pages 233–247. Springer, 2005. REFERENCES 129 [KKT07] D. K¨ ahler, R. K¨ usters, and T. Truderung. Infinite state AMC-model checking for cryptographic protocols. In LICS ’07 , pages 181–192. IEEE CS, 2007. [KKW05] D. K¨ ahler, R. K¨ usters, and T. Wilke. Deciding properties of contract-signing protocols. In STACS ’05 , volume 3404 of Lecture Notes in Computer Science ,pages 158–169. Springer, 2005. [KMZ02] S. Kremer, O. Markowitch, and J. Zhou. An intensive survey of non-repudiation protocols.
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
Computer Communications , 25(17):1606–1621, 2002. [Kre03] S. Kremer. Formal Analysis of Optimistic Fair Exchange Protocols . Ph.D. thesis, Universit´ e Libre de Bruxelles, 2003. [LNJ01] P. Liu, P. Ning, and S. Jajodia. Avoiding loss of fairness owing to failures in fair data exchange systems. Decision Support Systems , 31(3):337–350, 2001. [Lou00] P. Louridas. Some guidelines for non-repudiation protocols. SIGCOMM Com-put. Commun. Rev. , 30(5):29–38, 2000. [LSP82] L. Lamport, R. Shostak, and M. Pease. The Byzantine generals problem. ACM Trans. Program. Lang. Syst. , 4(3):382–401, 1982. [Lyn96] N. Lynch. Distributed Algorithms . Morgan Kaufmann Publishers, 1996. [Mau06] U. Maurer. Secure multi-party computation made simple. Discrete Applied Mathematics , 154(2):370–381, 2006. [MD02] J. Monteiro and R. Dahab. An attack on a protocol for certified delivery. In ISC ’02 , volume 2433 of Lecture Notes in Computer Science , pages 428–436. Springer, 2002. [Mic97] S. Micali. Certified email with invisible post offices, 1997. Presented at RSA Security Conference. [Mic03] S. Micali. Simple and fast optimistic protocols for fair electronic exchange. In PODC ’03 , pages 12–19. ACM Press, 2003. [MK01] O. Markowitch and S. Kremer. An optimistic non-repudiation protocol with transparent trusted third party. In ISC ’01 , volume 2200 of Lecture Notes in Computer Science , pages 363–378. Springer, 2001. [MR99] O. Markowitch and Y. Roggeman. Probabilistic non-repudiation without trusted third party. In Proc. 2nd Workshop on Security in Communication Network , 1999. [MR08a] A. Mukhamedov and M. Ryan. Fair multi-party contract signing using private contract signatures. Inf. Comput. , 206(2-4):272–290, 2008. [MR08b] Aybek Mukhamedov and Mark Dermot Ryan. Fair multi-party contract sign-ing using private contract signatures. Inf. Comput. , 206(2-4):272–290, 2008. [MRT09] S. Mauw, S. Radomirovic, and M. Torabi Dashti. Minimal message complexity of asynchronous multi-party contract signing. In CSF ’09 , pages 13–25. IEEE CS, 2009. [MS02] O. Markowitch and
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
S. Saeednia. Optimistic fair-exchange with transparent signature recovery. In FC ’01 , volume 2339 of Lecture Notes in Computer Science , pages 339–350. Springer, 2002. 130 NOTES [MW87] S. Moran and Y. Wolfstahl. Extended impossibility results for asynchronous complete networks. Inf. Process. Lett. , 26(3):145–151, 1987. [Nen05] A. Nenadi´ c. A security solution for fair exchange and non-repudiation in e-commerce . Ph.D. thesis, University of Manchester, 2005. [NZB04] A. Nenadi´ c, N. Zhang, and S. Barton. Fair certified email delivery. In SAC ’04 , pages 391–396. ACM Press, 2004. [Oni06] J. Onieva. Multi-party Non-repudiation Protocols and Applications . Ph.D. thesis, University of Malaga, Spain, 2006. [OT08] S. Orzan and M. Torabi Dashti. Fair exchange is incomparable to consensus. In John S. Fitzgerald, Anne Elisabeth Haxthausen, and H¨ usn¨ u Yenig¨ un, editors, ICTAC ’08 , volume 5160 of Lecture Notes in Computer Science , pages 349– 363. Springer, 2008. [PCS03] J. Park, E. Chong, and H. Siegel. Constructing fair-exchange protocols for e-commerce via distributed computation of RSA signatures. In PODC ’03 ,pages 172–181. ACM Press, 2003. [PG99] H. Pagnia and F. G¨ artner. On the impossibility of fair exchange without a trusted third party. Technical Report TUD-BS-1999-02, Department of Com-puter Science, Darmstadt University of Technology, Darmstadt, Germany, March 1999. [PSW98] B. Pfitzmann, M. Schunter, and M. Waidner. Optimal efficiency of optimistic contract signing. In PODC ’98 , pages 113–122. ACM Press, 1998. Extended version as technical report RZ 2994 (#93040), IBM Z¨ urich Research Lab, February 1998. [PVG03] H. Pagnia, H. Vogt, and F. G¨ artner. Fair exchange. The Computer Journal ,46(1):55–7, 2003. [Rab81] M. Rabin. How to exchange secrets with oblivious transfer. Technical Report TR-81, Aiken Computation Lab, Harvard University, May 1981. [Rab83] M. Rabin. Transaction protection by beacons. Journal of Computer and System Sciences , 27(2):256–267, 1983. [RR00]
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
I. Ray and I. Ray. An optimistic fair exchange e-commerce protocol with automated dispute resolution. In EC-WEB ’00 , volume 1875 of Lecture Notes in Computer Science , pages 84–93. Springer, 2000. [RRN05] I. Ray, I. Ray, and N. Natarajan. An anonymous and failure resilient fair-exchange e-commerce protocol. Decision Support Systems , 39(3):267–292, 2005. [RS98] J. Riordan and B. Schneier. A certified email protocol. In ACSAC ’98 , pages 347–352. IEEE CS, 1998. [San97] T. Sandholm. Unenforced e-commerce transactions. IEEE Internet Comput-ing , 1(6):47–54, 1997. [Sch00] M. Schunter. Optimistic fair exchange . Ph.D. thesis, Universit¨ at des Saarlan-dese, 2000. REFERENCES 131 [SM00] P. Syverson and C. Meadows. Dolev-Yao is no better than Machiavelli. In WITS ’00 , pages 87–92, 2000. [SM02] V. Shmatikov and J. Mitchell. Finite-state analysis of two contract signing protocols. Theor. Comput. Sci. , 283(2):419–450, 2002. [SMZ04] W. Susilo, Y. Mu, and F. Zhang. Perfect concurrent signature schemes. In ICICS ’04 , volume 3269 of Lecture Notes in Computer Science , pages 14–26. Springer, 2004. [Ste76] N. Stenning. A data transfer protocol. Computer Networks , 1(2):99–110, 1976. [SW02] T. Sandholm and X. Wang. (Im)possibility of safe exchange mechanism design. In 8th national conference on artificial intelligence , pages 338–344. AAAI, 2002. [SWZ06] M. Shao, G. Wang, and J. Zhou. Some common attacks against certified email protocols and the countermeasures. Computer Communications , 29(15):2759– 2769, 2006. [SXL05] M. Srivatsa, L. Xiong, and L. Liu. ExchangeGuard: A distributed protocol for electronic fair-exchange. In IPDPS ’05 , page 105b. IEEE CS, 2005. [Syv97] P. Syverson. A different look at secure distributed computation. In CSFW ’97 , pages 109–115. IEEE CS, 1997. [Syv98] P. Syverson. Weakly secret bit commitment: Applications to lotteries and fair exchange. In CSFW ’98 , pages 2–13. IEEE CS, 1998. [Tan96] L. Tang. Verifiable transaction atomicity for
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
electronic payment protocols. In ICDCS ’96 , pages 261–269. IEEE CS, 1996. [TIHF04] M. Terada, M. Iguchi, M. Hanadate, and K. Fujimura. An optimistic fair exchange protocol for trading electronic rights. In CARDIS ’04 , pages 255– 270. Kluwer, 2004. [TKJ08] M. Torabi Dashti, S. Krishnan Nair, and H. Jonker. Nuovo DRM Paradiso: Designing a secure, verified, fair exchange DRM scheme. Fundam. Inform. ,89(4):393–417, 2008. [TMH06] M. Terada, K. Mori, and S. Hongo. An optimistic NBAC-based fair exchange method for arbitrary items. In CARDIS ’06 , volume 3928 of Lecture Notes in Computer Science , pages 105–118. Springer, 2006. [Tor08] M. Torabi Dashti. Keeping Fairness Alive: Design and formal verification of fair exchange protocols . Ph.D. thesis, Vrije Universiteit Amsterdam, 2008. [Tor09] M. Torabi Dashti. Optimistic fair exchange using trusted devices. In SSS ’09 ,volume 5873 of Lecture Notes in Computer Science , pages 711–725. Springer, 2009. [TSS06] D. Tonien, W. Susilo, and R. Safavi-Naini. Multi-party concurrent signatures. In ISC ’06 , volume 4176 of Lecture Notes in Computer Science , pages 131–145. Springer, 2006. 132 NOTES [TW07] M. Torabi Dashti and Y. Wang. Risk balance in exchange protocols. In Asian ’07 , volume 4846 of Lecture Notes in Computer Science , pages 70–77. Springer, 2007. [Tyg96] J. Tygar. Atomicity in electronic commerce. In PODC ’96 , pages 8–26. ACM Press, 1996. [Vog03] H. Vogt. Asynchronous optimistic fair exchange based on revocable items. In FC ’03 , volume 2742 of Lecture Notes in Computer Science , pages 208–222. Springer, 2003. [VPG01] H. Vogt, H. Pagnia, and F. G¨ artner. Using smart cards for fair exchange. In WELCOM ’01 , volume 2232 of Lecture Notes in Computer Science , pages 101–113. Springer, 2001. [WBZ04] G. Wang, F. Bao, and J. Zhou. On the security of a certified email scheme. In INDOCRYPT
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
’04 , volume 3348 of Lecture Notes in Computer Science , pages 48–60. Springer, 2004. [WBZ06] G. Wang, F. Bao, and J. Zhou. The fairness of perfect concurrent signatures. In ICICS ’06 , volume 4307 of Lecture Notes in Computer Science , pages 435– 451. Springer, 2006. [WH07] K. Wei and J. Heather. A theorem-proving approach to verification of fair non-repudiation protocols. In FAST ’06 , volume 4691 of Lecture Notes in Computer Science , pages 202–219. Springer, 2007. [YC79] Y. Yemini and D. Cohen. Some issues in distributed processes communication. In Proc. of the 1st International Conf. on Distributed Computing Systems ,pages 199–203, 1979. [ZDB99] J. Zhou, R. Deng, and F. Bao. Evolution of fair non-repudiation with TTP. In ACISP ’99 , volume 1587 of Lecture Notes in Computer Science , pages 258– 269. Springer, 1999. [ZG96a] J. Zhou and D. Gollmann. Certified electronic mail. In ESORICS ’96 , volume 1146 of Lecture Notes in Computer Science , pages 160–171. Springer, 1996. [ZG96b] J. Zhou and D. Gollmann. A fair non-repudiation protocol. In IEEE Security and Privacy ’96 , pages 55–61. IEEE CS, 1996. [ZG96c] J. Zhou and D. Gollmann. Observations on non-repudiation. In ASIACRYPT ’96 , volume 1163 of Lecture Notes in Computer Science , pages 133–144. Springer, 1996. [ZG97a] J. Zhou and D. Gollmann. An efficient non-repudiation protocol. In CSFW ’97 , pages 126–132. IEEE CS, 1997. [ZG97b] J. Zhou and D. Gollmann. Evidence and non-repudiation. J. Netw. Comput. Appl. , 20(3):267–281, 1997. [Zho04] J. Zhou. On the security of a multi-party certified email protocol. In ICICS ’04 , volume 3269 of Lecture Notes in Computer Science , pages 40–52. Springer, 2004.
|
{
"page_id": null,
"source": 7326,
"title": "from dpo"
}
|
Title: Prove that root 2 is an irrational number.[Solved] URL Source: Markdown Content: Prove that root 2 is an irrational number.[Solved] =============== ![Image 1: cuemath_logo2 ⇒ 2q 2 = 4x 2 ⇒ q 2 = 2x 2 ⇒ q 2 is an even number. Therefore, q is also even. Since p and q both are even numbers, they have 2 as a [common multiple]( which means that p and q are not co-prime numbers as their [HCF]( is 2. This leads to the contradiction that root 2 is a rational number in the form
|
{
"page_id": null,
"source": 7329,
"title": "from dpo"
}
|
of p/q with "p and q both co-prime numbers" and q ≠ 0. ### Thus, √2 is an irrational number by the contradiction method. **☛ Also Check:**Prove that Root 2 is Irrational Number]( [FAQs]( MATHS WORKSHEETS [Kindergarten Maths Worksheets]( [Maths Worksheet for Grade 1]( [Maths Worksheet for Grade 2]( [Maths Worksheet for Grade 3]( [Maths Worksheet for Grade 4]( [Maths Worksheet for Grade 5]( [Maths Worksheet for Grade 6]( [Maths Worksheet for Grade 7]( [Maths Worksheet for Grade 8]( [Maths Worksheet for Grade 9]( [Maths Worksheet for Grade 10]( CURRICULUM [1st Grade Maths]( [2nd Grade Maths]( [3rd Grade Maths]( [4th Grade Maths]( [5th Grade Maths]( [6th Grade Maths]( [7th Grade Maths]( [8th Grade Maths]( ABOUT US [Our Mission]( [Our Journey]( [Our Team]( MATH TOPICS [Numbers]( [Algebra]( [Geometry]( [Measurement]( [Commercial Maths]( [Data]( [Trigonometry]( [Calculus]( [Maths Formulas]( [Calculators]( [Multiplication Tables]( [NCERT Solutions]( [NCERT Solutions for Grade 7]( [NCERT Solutions for Grade 8]( [NCERT Solutions for Grade 9]( [NCERT Solutions for Grade 10]( INTERNATIONAL [United States]( [United Kingdom]( [Canada]( [Dubai]( [Australia]( [France]( [Germany]( [Indonesia]( [Italy]( [Netherlands]( [Sri Lanka]( [Singapore]( [Saudi Arabia]( [Oman]( [Bahrain]( [Qatar]( [Norway]( [Sweden]( [Ireland]( FOLLOW CUEMATH [Facebook]( [Youtube]( [Instagram]( [Twitter]( [LinkedIn]( [Tiktok]( MATHS PROGRAM [Maths Program]( [Home Tuitions]( [Home Tutors]( [Private Tutors]( [Tuition Tutors]( [Online Tuitions]( [Online Maths Courses]( [Math Tutors]( MATHS WORKSHEETS [Kindergarten Maths Worksheets]( [Maths Worksheet for Grade 1]( [Maths Worksheet for Grade 2]( [Maths Worksheet for Grade 3]( [Maths Worksheet for Grade 4]( [Maths Worksheet for Grade 5]( [Maths Worksheet for Grade 6]( [Maths Worksheet for Grade 7](
|
{
"page_id": null,
"source": 7329,
"title": "from dpo"
}
|
Maths Worksheet for Grade 8]( [FAQs]( CURRICULUM [1st Grade Maths]( [2nd Grade Maths]( [3rd Grade Maths]( [4th Grade Maths]( [5th Grade Maths]( [6th Grade Maths]( [7th Grade Maths]( [8th Grade Maths]( []( [Terms and Conditions]( Policy](
|
{
"page_id": null,
"source": 7329,
"title": "from dpo"
}
|
Title: A proof that the square root of 2 is irrational number URL Source: Markdown Content: A proof that the square root of 2 is irrational number =============== [![Image 1: Home - HomeschoolMath.net]( Free worksheets * By Grades * [1st grade]( * [2nd grade]( * [3rd grade]( * [4th grade]( * [5th grade]( * [6th grade]( * [7th grade]( * Elementary * [Number Charts]( * [Addition]( * [Multiplication]( * [Division]( * [Long division]( * [Basic operations]( * [Measuring]( * [Telling time]( * [Place value]( * [Rounding]( * [Roman numerals]( * Money * [US Money]( * [Canadian]( * [Australian]( * [British]( * [European]( * [S. African]( * Fractions & related * [Add, subtract, multiply, and divide fractions]( * [Mixed numbers vs. fractions]( * [Simplify]( * [Compare]( * [Equivalent fractions]( * [Prime factorization & factors]( * [GCF & LCM]( * [Fraction Calculator]( * Decimals & Percent * [Add, subtract, multiply, and divide decimals]( * [Multiplication]( * [Division]( * [Fractions to decimals]( * [Percents to decimals]( * [Percentage of a number]( * [Percent word problems]( * Geometry * [Classify triangles]( * [Classify quadrilaterals]( * [Circle worksheets]( * [Area & perimeter of rectangles]( * [Area of triangles & polygons]( * [Coordinate grid, including moves & reflections]( * [Volume & surface area]( * Pre-algebra * [Exponents]( * [Square Roots]( * [Order of operations]( * [Scientific notation]( * [Proportions]( * [Ratio word problems]( * [Write expressions]( * [Evaluate expressions]( * [Simplify expressions]( * [Linear equations]( * [Linear inequalities]( * [Graphing & slope]( * [Equation calculator]( * [Equation editor]( [Free lessons]( Games & activities * Elementary Math Games * [Addition and subtraction]( * [Place value]( * [Clock]( * [Money]( * [Measuring]( * [Multiplication]( * [Division]( * [Math facts practice]( * [The four operations]( * [Factoring and number theory]( * [Geometry topics]( * Middle/High School * [Fractions](
|
{
"page_id": null,
"source": 7329,
"title": "from dpo"
}
|
* [Decimals]( * [Percent]( * [Integers]( * [Exponents]( * [Statistics & Graphs]( * [Probability]( * [Geometry topics]( * [Algebra]( * [Calculus]( * [Trigonometry]( * [Logic and proof]( * For all levels * [Favorite math puzzles]( * [Favorite challenging puzzles]( * [Math in real world]( * [Problem solving & projects]( * [For gifted children]( * [Math history]( * [Math games and fun websites]( * [Interactive math tutorials]( * [Math help & online tutoring]( * [Assessment, review & test prep]( * [Online math curricula]( [Curriculum guide]( A proof that the square root of 2 is irrational =============================================== Here you can read a step-by-step proof with simple explanations for the fact that the square root of 2 is an irrational number. It is the most common proof for this fact and is by contradiction. How do we know that square root of 2 is an irrational number? In other words, how do we know that √2 doesn't have a pattern in its decimal sequence? Maybe the pattern is very well hidden and is really long, billions of digits? Here is where mathematical proof comes in. The proof that √2 is indeed irrational is usually found in college level math texts, but it isn't that difficult to follow. It does not rely on computers at all, but instead is a "proof by contradiction": if √2 WERE a rational number, we'd get a contradiction. I encourage all high school students to study this proof since it illustrates so well a typical proof in mathematics and is not hard to follow. A proof that the square root of 2 is irrational ----------------------------------------------- Let's suppose √2 is a rational number. Then we can write it √2 = _a/b_ where _a_, _b_ are whole numbers, _b_ not zero. We additionally assume that this _a/b_ is simplified to lowest
|
{
"page_id": null,
"source": 7329,
"title": "from dpo"
}
|
terms, since that can obviously be done with any fraction. Notice that in order for _a/b_ to be in simplest terms, both of _a_ and _b_ cannot be even. One or both must be odd. Otherwise, we could simplify _a/b_ further. From the equality √2 = _a/b_ it follows that 2 = _a_ 2/_b_ 2, or _a_ 2 = 2 · _b_ 2. So the square of _a_ is an even number since it is two times something. From this we know that _a_ itself is also an even number. Why? Because it can't be odd; if _a_ itself was odd, then _a_ · _a_ would be odd too. Odd number times odd number is always odd. Check it if you don't believe me! Okay, if _a_ itself is an even number, then _a_ is 2 times some other whole number. In symbols, _a_ = 2k where k is this other number. We don't need to know what k is; it won't matter. Soon comes the contradiction. If we substitute _a_ = 2k into the original equation 2 = _a_ 2/b 2, this is what we get: 2=(2k)2/b 2 2=4k 2/b 2 2*b 2=4k 2 b 2=2k 2 This means that _b_ 2 is even, from which follows again that _b_ itself is even. And that is a contradiction!!! WHY is that a contradiction? Because we started the whole process assuming that _a/b_ was simplified to lowest terms, and now it turns out that _a_ and _b_ both would be even. We ended at a contradiction; thus our original assumption (that √2 is rational) is not correct. Therefore √2 cannot be rational. * * * ### See also What is a mathematical proof?) Grade 1 * [Using a 100-bead abacus in elementary math]( *
|
{
"page_id": null,
"source": 7329,
"title": "from dpo"
}
|
Teaching tens and ones]( * Comparing 2-digit numbers) Grade 1 * Missing addend concept (0-10)]( * Add a 2-digit number and a single-digit number mentally) Grade 3 * Multiplication concept as repeated addition) Grade 3 * Division as making groups]( * [Divisibility]( Grade 4 * [How to teach long division]( * [Long division as repeated subtraction]( * [Why long division works]( * [Zero in dividend]( * [Remainder
|
{
"page_id": null,
"source": 7329,
"title": "from dpo"
}
|
& long division]( * Two-digit divisor) * Understanding fractions) * Lines, rays, and angles * Review: Area of Polygons * Surface Area * Decimals Lessons) * Decimals videos]( * Decimal place value (1 decimal digit)]( * Decimal place value (2 decimal digits)]( * Add & subtract (1 decimal digit)]( * [Add and subtract decimals — practice]( * [Comparing decimals]( * [Multiply a decimal by a whole number]( * [Multiply decimals by decimals]( * [Divide decimals—mental math]( * [Divide decimals by decimals]( *
|
{
"page_id": null,
"source": 7329,
"title": "from dpo"
}
|
Multiply and divide decimals by 10, 100, and 1000) * How to teach proportions) * Four habits of highly effective math teaching]( * Keeping math skills sharp in the summer;) Powered By 00:00/00:53 10 Sec 1.2M 12 Welcome to home school math Next Stay ![Image 3]( 4]( 5]( 6](
|
{
"page_id": null,
"source": 7329,
"title": "from dpo"
}
|
Title: URL Source: Markdown Content: # Distributed Algorithms Fall 2020 ## Consensus 6th exercise session, 26/10/2020 Matteo Monti Jovan Komatovic 1FloodSet Algorithm (1/2) The agreement problem for crash failures has a very simple algorithm, called FloodSet. Processes just propagate all the values in the input set V that they have ever seen and use a simple decision rule at the end. The flooding algorithm, due to Dolev and Strong, gives a straightforward solution to synchronous agreement for the crash failure case. It runs in f+1 rounds assuming f crash failures. > 2 ## FloodSet Algorithm (2/2) The algorithm: ● Each process maintains variable W i ⊆ V, initially {v i }. ● f+1 rounds, consisting of: > ○Broadcast W i,○Add all received elements to W i. ● After that, if W i = {v i } (i.e. a singleton) decide v i , otherwise decide v 0 (default value). The goal: Prove the algorithm is correct (guided proof) > 3 ## Exercises 1 Definition : Let W i (r) be the value of variable W at process i after r rounds. > 4 Lemma 1: If no process fails during a particular round r, 1≤r≤f+1, then W i (r) = W j (r), ∀i, j non-faulty after round r. Lemma 2 : Suppose that W i (r) = W j (r) ∀i, j non-faulty after round r. Then, ∀r’, r≤r’ ≤f+1, the same holds, that is, W i (r’) = W j (r’) ∀i, j non-faulty after round r’. Exercises 1 (Solution) > 5 Proof of lemma 1 : Assume no processes fail during round r, and let I be the set of not-failed processes after r-1 and r. Since every process in I (and only these) send W to all other processes at round r, by the algorithm
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
construction we have that at the end of round r, W i (r) is the union of all W j (r-1) , ∀j ∈ I. Proof of lemma 2 : We use induction on the number of rounds. Base case is the assumption on the lemma. For the induction step, you just need to note that all processes are broadcasting the same set, and therefore do not make any changes to W.Exercises 2 > 6 Lemma 3: If processes i, j are non-faulty after f+1 rounds, then W i (f+1) = W j (f+1). Theorem : Floodset solves consensus, i.e., Agreement, Validity and Termination hold. Note: The property of validity in the consensus problem comes in two flavors. ● A: If all processes have the same initial value v, then v is the only possible decision value. ● B (stronger): The decision value is the initial value of some process. Exercises 2 (Solution 1/2) > 7 Proof of lemma 3: Since there at at most f failures, then there exists a round r such that no faults occur during that round. Then, Lemma 1 implies that W i (r) = W j (r) , ∀i, j non-faulty after round r, and Lemma 2 implies that W i (f+1) = W j (f+1) , ∀i, j non-faulty after round f+1 .Exercises 2 (Solution 2/2) > 8 Proof of theorem :● Termination: Follows from the termination rule of the algorithm. ● Validity: If all processes have the same initial value v, then any message ever transmitted will always contain { v}, therefore W i (r) = { v} ∀i non-faulty after r≤f+1 rounds. This implies the decision value will be v.● Agreement: Since all processes decide after f+1 rounds, Lemma 3 implies that any two processes that decide have the same value
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
for W.Exercise 3 What is the communication complexity of the FloodSet algorithm in: ● number of messages, ● bits, given that b is the number of bits required to represent the elements of V? Is the decision rule (last bullet of the algorithm) so critical? In other words, is there any alternative decision rule we can have? If so, name one. > 9 ## Exercise 3 (Solution) The communication complexity of the FloodSet algorithm in: ● number of messages: O( ( f+1)n 2 )● number of bits: O( ( f+1)n 3 )b About the decision rule: Since FloodSet guarantees that all non-faulty processes obtain the same W after f+1 rounds, other decision rules would also work correctly, as long as all the processes apply the same rule. For instance, if the value set V has a total ordering, the all processes could simply choose the minimum value in W. This rule guarantees the stronger validity. That is not necessarily true for the decision rule given in FloodSet, because v0 might not be the initial value of any process. 10 Exercise 4 (1/2) - Bonus A strange setting for consensus ( synchronous case) Consider a network that is organized as a 2-dimensional grid, such that every process has up to 4 neighbors. The width of the grid is w and the height is h. The grid is big, meaning that w+h is much smaller than w*h. While there are faulty and correct processes in the network, it is assumed that two correct processes are always connected through at least one path of correct processes. In every round processes may send a message to each of its neighbors, the size of the message is not limited. > 11 ## Exercise 4 (2/2) - Bonus a) Assume there is no faulty process. Write
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
a protocol to reach consensus. Optimize your protocol according to speed. b) How many rounds does your protocol require? c) Assume there are w+h faulty processes. In the worst-case scenario, how many rounds does the protocol require now? > 12 ## Exercise 4 (Solution 1/2) a) The goal if the protocol is for every process to know the input of all the other processes. Each process internally allocates an array of size w*h , where each entry of the array represents the input of one process that initially is set to a sentinel value ‘?’. The process fills the array until no ‘?’ are left, then the process can make its decision (e.g. the minimal value received). Whenever a process gets new information, it sends its updated array to all its four neighbors. At the beginning, the “new information” is its own input. b) The number of required rounds is the length of the longest shortest path between any two processes. In the case of the grid, this is w+h . > 13 c) The problem reduces to building the longest path on a connected grid by removing a given number of nodes. ## Exercise 4 (Solution 2/2)
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
Title: Parameterized verification of leader/follower systems via first-order temporal logic URL Source: Markdown Content: 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 Practical first-order temporal reasoning. In: International Symposium on Temporal Representation and Reasoning, pp. 156–163. IEEE"), 16 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"), 18 Deductive verification of cache coherence protocols. In: Proceedings of the 3rd Workshop on Automated Verification of Critical Systems AVoCS, 3: 177–186")] is an approach to parameterized verification, proposed as an alternative to _regular model checking for parameterized and infinite-state systems_ [1 Regular Model Checking for LTL(MSO). In: International Conference on Computer Aided Verification, LNCS, vol. 3114, pp. 348–360. Springer"), 2 Proving liveness by backwards reachability. In: International Conference on Concurrency Theory, LNCS, vol. 4137, pp. 95–109. Springer")] and _constraint-based verification using counting abstractions_ [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"), 14 On the verification of broadcast protocols. In: Symposium on Logic
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
in Computer Science, pp. 352–359. IEEE Computer Society Press")]. The model checking approach has been applied to several scenarios 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 temporal logic is incomplete [29 Incompleteness of first-order temporal logic with until. Theoretical Comput Sci 57(2–3):317–325")] and generally undecidable [22 Decidable fragments of first-order temporal logics. Annals Pure Appl Logic 106(1–3):85–134")], a certain syntactic restriction to it, referred to as _monodic_ first-order temporal logic, is finitely axiomatizable [31 Axiomatizing the monodic fragment of first-order temporal logic. Annals Pure Appl logic 118(1–2):133–145")] and (if one restricts its first-order part to a decidable fragment of first-order logic) decidable [22 Decidable fragments of first-order temporal logics. Annals Pure Appl Logic 106(1–3):85–134")]. Roughly speaking, a first-order temporal logic formula \(\varphi \) is said to be monodic if every sub-formula of \(\varphi \) appearing within the scope of a temporal operator has at most one free variable. As shown in [13 Practical first-order temporal reasoning. In: International Symposium on Temporal Representation and Reasoning, pp. 156–163. IEEE"), 16 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")], monodic first-order temporal logic is expressive enough to specify various types of systems commonly appearing in practice. In particular, [( "Dixon C, Fisher M,
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
Konev B, Lisitsa A (2008) Practical first-order temporal reasoning. In: International Symposium on Temporal Representation and Reasoning, pp. 156–163. IEEE"), 16 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")] show how to encode in said logic an abstract protocol model, first appearing 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")], for networks of arbitrarily many, identical finite-state machines communicating via broadcast messages. Using this approach, one is able 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 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"), 13 Practical first-order temporal reasoning. In: International Symposium on Temporal Representation and Reasoning, pp. 156–163. IEEE"), 16 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")], but can be applied to a wider class
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
of protocols, such as cache coherence, atomic commit, consensus, and synchronization protocols. Sect.5 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 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"), 13 Practical first-order temporal reasoning. In: International Symposium on Temporal Representation and Reasoning, pp. 156–163. IEEE"), 16 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")] 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
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
any information to the leader, apart from the _possibility_ of a consensus _in the future_ (assuming the leader has not received any “no” messages). To 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 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 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"), 13 Practical first-order temporal reasoning. In: International Symposium on Temporal Representation and Reasoning,
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
pp. 156–163. IEEE"), 16 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")] 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 Sect5.1) has to record the messages it receives from its followers (\(a_1\), \(a_2\), \(a_3\)) Full size image first-order temporal logic. In Sect.5 Distributed Algorithms. Morgan Kaufmann Publishers Inc., San Francisco, CA, USA")], the two-phase commit [6 Concurrency control and recovery in database systems. Addison-Wesley, Boston"), 19 Consensus on transaction commit. ACM Trans Database Syst (TODS) 31(1):133–160")], and Control-MAC . In Sect.6) are predicate symbols \(P_0, P_1, \ldots \), each of fixed arity (0-ary or nullary predicate symbols are allowed and correspond to propositions); variables \(x_0, x_1, \ldots \), constants \(c_0, c_1, \ldots \); the propositional constants \(\top \) (true) and \(\bot \)
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
(false); the usual Boolean connectives (\(\lnot , \vee , \wedge , \rightarrow , \leftrightarrow \)); the quantifiers \(\forall \) (for all) and \(\exists \) (exists); and the temporal operators \(\Box \) (always in the future), \(\Diamond \) (sometime in the future), !Image 2, !Image 3, and !Image 4. The syntax of \(\textsf {FOTL}\) is as follows: * \(\top \) and \(\bot \) are atomic \(\textsf {FOTL}\)-formulae; * if _P_ is an _n_-ary predicate symbol and \(t_1, \ldots , t_n\) are variables or constants, then \(P(t_1,\dots ,t_n)\) is an atomic \(\textsf {FOTL}\)-formula; * if \(\varphi \) and \(\psi \) are \(\textsf {FOTL}\)-formulae, so are \(\lnot \varphi \), \(\varphi \wedge \psi \), \(\varphi \vee \psi \), \(\varphi \rightarrow \psi \), and \(\varphi \leftrightarrow \psi \); * if \(\varphi \) is an \(\textsf {FOTL}\)-formula and _x_ is a variable, then \(\forall x \, \varphi \) and \(\exists x \, \varphi \) are \(\textsf {FOTL}\)-formulae; * if \(\varphi \) and \(\psi \) are \(\textsf {FOTL}\)-formulae, then so are \(\Box \varphi \), \(\Diamond \varphi \), !Image 5 Full size image is an \(\textsf {FOTL}\)-formula, we denote its length by \(\Vert \varphi \Vert \). \(\textsf {FOTL}\)-formulae are interpreted in _first-order temporal structures_, i.e.sequences \({\mathfrak {M}}= {\mathfrak {A}}_0, {\mathfrak {A}}_1, \ldots \) of first-order structures over _the same_ domain _A_. That is, given a non-empty set _A_, \({\mathfrak {A}}_n = \langle A, I_n \rangle \) (\(n \in {\mathbb {N}}\)), where is \(I_n\) an interpretation of predicate and constant symbols over _A_, assigning to each predicate symbol _P_ a relation \(P^{{\mathfrak {A}}_n}\) on _A_ of the same arity as _P_ (if _P_ is a nullary predicate, \(P^{{\mathfrak {A}}_n}\) is simply one of the
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
propositional constants \(\top \) or \(\bot \)), and to each constant symbol _c_ an element \(c^{{\mathfrak {A}}_n}\) of _A_. We require that the interpretation of constants be _rigid_, i.e.\(I_n(c) = I_m(c)\), for all \(n, m \in {\mathbb {N}}\). An _assignment_\({\mathfrak {a}}\) in _A_ is a function from the set of variables \(\{ x_0, x_1, \ldots \}\) to _A_. The _truth_ relation \(({\mathfrak {M}}, {\mathfrak {A}}_n) \models ^{\mathfrak {a}}\varphi \) (or simply \({\mathfrak {A}}_n \models ^{\mathfrak {a}}\varphi \) if \({\mathfrak {M}}\) is clear from context) in \({\mathfrak {M}}= {\mathfrak {A}}_0, {\mathfrak {A}}_1, \ldots \) is defined in Fig.2 is _true_ in \({\mathfrak {M}}\) if there exists an assignment \({\mathfrak {a}}\) such that \({\mathfrak {A}}_0 \models ^{\mathfrak {a}}\varphi \). 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 \(\varphi \) of the form !Image 9, \(\Box \psi \), !Image 10\) are monodic, while the formula !Image 13 (abbr.MFOTL). \(\textsf {FOTL}\) is incomplete (not recursively axiomatizable) [29 Incompleteness of first-order temporal logic with until. Theoretical Comput Sci 57(2–3):317–325")] and undecidable [22 Decidable fragments of first-order temporal logics. Annals Pure Appl Logic 106(1–3):85–134")]. In contrast, \(\textsf {MFOTL}\) is finitely axiomatizable [31 Axiomatizing the monodic fragment of first-order temporal logic. Annals Pure Appl logic 118(1–2):133–145")], and, if its first-order part is restricted to a decidable
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
fragment of first-order logic, decidable [22 Decidable fragments of first-order temporal logics. Annals Pure Appl Logic 106(1–3):85–134")]. Of particular interest to us are the monadic fragment and the two-variable fragment of \(\textsf {MFOTL}\), both decidable and EXPSPACE-complete [21 On the computational complexity 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")]. (Most of the formulas we require can be written in monadic \(\textsf {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 \(\textsf {MFOTL}\): TeMP [23 Temp: A temporal monodic prover. In: International Joint Conference on Automated Reasoning, LNCS, vol. 3097, pp. 326–330. Springer")] and TSPASS [26 Fair derivations in monodic temporal reasoning. In: International Conference on Automated Deduction, pp. 261–276. Springer"), 27 Implementing a fair monodic temporal logic prover. AI Commun 23(2–3):69–96")]. These provers implement a form of temporal resolution called _fine-grained resolution_ [8 Monodic temporal resolution. ACM Trans Comput Logic 7(1):108–150"), 24 Mechanising first-order temporal resolution. Inf Comput 199(1–2):55–86")]. (See [12 Using temporal logics of knowledge for specification and verification-a case study. J Appl Logic 4(1):50–78"), 15 First-order temporal verification in practice. J Autom Reason 34(3):295–321")] for some applications of TeMP and [3 Deductive verification of
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
simple foraging robotic behaviours. Int J Intell Comput Cybern 2(4):604–643"),4 Abstract accountability language: translation, compliance and application. In: Asia-Pacific Software Engineering Conference, pp. 214–221. IEEE"),5 Checking accountability with a prover. In: Computer Software and Applications Conference, vol. 2, pp. 83–88. IEEE"), 20 Causality in message-based contract violations: a temporal logic “whodunit”. In: International Enterprise Distributed Object Computing Conference, pp. 171–180. IEEE")] 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 \({\mathfrak {M}}= {\mathfrak {A}}_0, {\mathfrak {A}}_1, \ldots \) are _expanding_, i.e.\({\mathfrak {A}}_n = \langle A_n, I_n \rangle \), where \(A_n \subseteq A_{n+1}\) (\(n \in {\mathbb {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 [30 Decidable fragments of first-order modal logics. J Symb Logic 66(3):1415–1438")]. [24 Mechanising first-order temporal resolution. Inf Comput 199(1–2):55–86"), 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 Temporal verification of fault-tolerant protocols. In: Methods, Models and Tools for Fault Tolerance, pp. 44–56. Springer"), ( "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
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
of Liverpool")] report on characterizing finite domains using \(\textsf {MFOTL}\). In particular, [17 Temporal verification of fault-tolerant protocols. In: Methods, Models and Tools for Fault Tolerance, pp. 44–56. Springer")] reports that each of the following three axioms enforces finite domains (and is derivable from each of the other two): 1. (F1)!Image 14!Image 15!Image 16 [17 Temporal verification of fault-tolerant protocols. In: Methods, Models and Tools for Fault Tolerance, pp. 44–56. Springer")] also reports that for classes of protocols satisfying a certain “stabilization principle” (FloodSet in Sect.5.1, 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 \(\textsf {MFOTL}\) leads to the loss of recursive enumerability [9 Equality and monodic first-order temporal logic. Studia Logica 72(2):147–156"), 31 Axiomatizing the monodic fragment of first-order temporal logic. Annals Pure Appl logic 118(1–2):133–145")]. This is a limitation that affects applications (such as the Control-MAC protocol in Sect.5.3\) and \(\exists ^{> 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 \(\exists x P(x) \wedge \forall x \forall y ((P(x) \wedge P(y)) \rightarrow x = y)\) and \(\exists x \exists y (P(x) \wedge P(y) \wedge \lnot (x = y))\) respectively, where \(P(\cdot )\) is a unary predicate. (We also use \(\exists ^{\geqslant
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
1} x \, P(x)\) in place of \(\exists x P(x)\) sometimes for emphasis.) Due to the aforementioned limitation, \(\exists ^{=1} x \, P(x)\) and \(\exists ^{> 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(\cdot , \cdot )\) satisfying axioms (E1)-(E4) below: 1. (E1) \(\forall x \, E(x, x)\) 2. (E2) \(\forall xy (E(x, y) \rightarrow E(y, x))\) 3. (E3) \(\forall xyz ( E(x, y) \wedge E(y, z) \rightarrow E(x, z))\) 4. (E4) \(\forall x_1 \cdots x_n y_1 \cdots y_n (\bigwedge _{i=1}^n E(x_i, y_i) \wedge P(x_1, \ldots , x_n) \rightarrow P(y_1, \ldots , y_n))\) In a temporal setting, one needs in addition axiom (E5) below, enforcing the condition that equal objects remain equal across time: 1. (E5)!Image 18 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 \(\chi \) containing equality is valid. (For our purposes, \(\chi \) will be of the form \(\varphi \rightarrow \psi \), where \(\varphi \) describes a protocol and \(\psi \) a correctness condition for that protocol.) It should be clear that if \(\textsf {EqAx} \rightarrow [\chi ]_E\) is valid, where \(\textsf {EqAx}\) is the conjunction of formulas (E1)-(E4) and \([\chi ]_E\) is the result of replacing in \(\chi \) all occurences of \(x=y\) with _E_(_x_,_y_), then \(\chi \) is valid. (Any proof of \(\chi \) in the axiomatic system (E1)-(E4) is trivially a proof of \(\chi \) in the axiomatic system (E1)-(E5), and the latter system fully captures equality.) Thus, one is left with a _correct_ but _incomplete_ approach
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
to check the validity of a monodic formula \(\chi \) containing equality: one uses TeMP or TSPASS to check whether \(\textsf {EqAx} \rightarrow [\chi ]_E\) is valid; if the prover concludes that it is, then one knows that \(\chi \) is valid; if the prover concludes that \(\textsf {EqAx} \rightarrow [\chi ]_E\) is not valid, then the validity of \(\chi \) remains unknown. 3 Distributed machines ---------------------- In the following setting we 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+1\) machines 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 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
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
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 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 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 \(\mu \) (where \(\mu \) is an arbitrary label) is
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
_ingoing_, we write \(\mu \) with a _left-pointing arrow_ on top (!Image 19 is _outgoing_, we write \(\mu \) with a _right-pointing arrow_ on top (\(\vec {\mu }\)). The leader’s inbox corresponding to a message !Image 20 we introduce the following notation. Transitions in which the leader _reacts to an inbox_!Image 22, \(^{= 1}\), \(^{\geqslant 1}\), \(^{> 1}\), or \(^\textsf {all}\) (written as a superscript). Thus, we write: (i)!Image 24 !Image 26 !Image 28 !Image 30!Image 32 (Sect.3.2 and \(\textsf {enbl}_\tau \) formulas (Sect.4.1: \(\vec
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
{\mu }\) denotes the transition in which the leader broadcasts \(\mu \). _Local_ transitions are simply denoted with a plain label (no arrow on top). Similar notation is used for followers reacting to a message (!Image 34), as well as for their local transitions (no arrow on top). For examples using the above notation see Sect.5, and \(T^L_\text {local} = \{ \ell _1, \ldots , \ell _t \}\) be sets of symbols (note that !Image 36 are _different_ symbols); let !Image 37 is a finite set, the set of _states_ of \(L\); * \(Q^L_\text {init} \subseteq Q^L\) are the _initial states_ of \(L\); * \(T^L= {\overline{T}}^L_\text {in} \cup T^L_\text {out} \cup T^L_\text {local} \cup \{ \textit{idle}\}\) is the set of _transitions_ of \(L\); and * \(\delta ^L\subseteq Q \times (T^L\setminus \{ \textit{idle}\}) \times Q\) is the _transition relation_ of \(L\). Intuitively, \(T^L_\text {in}\) is the set of all possible ingoing messages to _L_, thus, according to the notational conventions in Sect.3.1 is the set of all available labels for transitions in which _L_ reacts to an inbox; \(T^L_\text {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_\text {local}\) is the set of _L_’s local actions, and, also, the set of all available labels for _L_’s local transitions. The transition \(\textit{idle}\) is a special transition the leader takes when it
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
is unable to take any other transition. We define the _size_ of _L_, denoted \(\Vert L\Vert \), to be the quantity \(|Q^L|+|T^L|+|\delta ^L|\). For some example leaders see Sect.5 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 = \{ a_1, \ldots , 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 !Image 38 and !Image 40). Intuitively, _q_ is \(L\)’s state at a given moment of time and !Image 41) is \(L\)’s inbox corresponding to the message !Image 42) is to be viewed as a record of those followers (elements of _A_) from which _L_ has received a message !Image 44 If !Image 46\) denotes the state _q_ and \(\iota ({\mathfrak {c}})\) denotes the _r_-tuple !Image 47\) (short for _enabled_) the set of transitions \(\tau \in T^L\setminus \{ \textit{idle}\}\) such that \(\langle q, \tau , q' \rangle \in \delta ^L\), for some \(q' \in Q^L\), and either \(\tau \in T^L_\text {out} \cup T^L_\text {local}\) or one of the following holds: 1. (a) !Image 49 !Image 52 ![Image 55](
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
(!Image 56 !Image 58 !Image 61\) as an _enabled_ transition. Intuitively, \(\tau \in enb ( {\mathfrak {c}} )\) if \(\tau \) is one of the available transitions for _L_ when _L_’s configuration is \({\mathfrak {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 \(\tau \in T^L\), we define the relation \(\preceq ^\tau \) over _r_-tuples \(\langle I^1, \ldots , I^r \rangle \), \(\langle J^1, \ldots , J^r \rangle \), where \(I^j, J^j \subseteq A\) (\(1 \le j \le r\)), as follows: 1. (a) if !Image 64 iff \(I^j \subseteq J^j\) (for all \(1 \le j \le r\)); 2. (b) if !Image 69 iff \(J^i = \emptyset \) and \(I^j \subseteq J^j\) (for all \(1 \le j \le r\), \(j \ne i\)). A _run_ for \(L\) over _A_ is a sequence \({\mathfrak {R}}=
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
\{ \langle {\mathfrak {c}}_n, \tau _n \rangle \}_{n \in {\mathbb {N}}}\), where !Image 74) is an l-configuration and \(\tau _n \in T^L\) (\(n \in {\mathbb {N}}\)), such that: \(q_0 \in Q^L_\text {init}\), !Image 75); for all \(n \in {\mathbb {N}}\), \(\iota ({\mathfrak {c}}_n) \preceq ^{\tau _n} \iota ({\mathfrak {c}}_{n+1})\) (persistence); and, for all \(n \in {\mathbb {N}}\), 1. (a) \(\tau _n \in enb ( {\mathfrak {c}}_n )\) and \(\langle \sigma ({\mathfrak {c}}_n), \tau _n, \sigma ({\mathfrak {c}}_{n+1}) \rangle \in \delta ^L\); or 2. (b) \( enb ( {\mathfrak {c}}_n ) = \emptyset \), \(\tau _n = \textit{idle}\), and \(\sigma ({\mathfrak {c}}_n) = \sigma ({\mathfrak {c}}_{n+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 or becomes idle if none exists. Inboxes can grow at any moment of time as a result 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 be a run for _L_ over a set _A_. For all \(n \in {\mathbb {N}}\), if !Image 76 are _different_ symbols). A _follower_ is a quadruple $$\begin{aligned} F= \langle Q^F, Q^F_\text {init}, T^F, \delta ^F\rangle , \end{aligned}$$ where
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
* \(Q^F\) is a finite set, the set of _states_ of \(F\); * \(Q^F_\text {init} \subseteq Q^F\) are the _initial states_ of \(F\); * \(T^F= T^F_\text {in} \cup T^F_\text {out} \cup T^F_\text {local} \cup \{ \textit{idle}\}\) is the set of _transitions_ of \(F\); and * \(\delta ^F\subseteq Q^F\times (T^F\setminus \{ \textit{idle}\}) \times Q^F\) is the _transition relation_ of \(F\). Intuitively, the sets \(T^F_\text {in}\), \(T^F_\text {out}\), and \(T^F_\text {local}\) are respectively the sets of all possible ingoing messages, possible outgoing messages, and local actions of _F_; thus, according to the notational conventions in Sect.3.1, \(T^F_\text {out}\), and \(T^F_\text {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 \(\textit{idle}\) is a special transition each follower takes when it is unable to take any other transition. We define the _size_ of _F_, denoted \(\Vert F\Vert \), to be the quantity \(|Q^F|+|T^F|+|\delta ^F|\). For some example followers see Sect.5 is a pair \(\langle q, {\mathcal {I}}\rangle \), where \(q \in Q^F\) and \({\mathcal {I}}\subseteq T^F_\text {in}\). Intuitively, _q_ is _F_’s state at a given moment of time and \({\mathcal {I}}\subseteq T^F_\text {in}\) is its inbox at that moment of time. At any moment of time, \({\mathcal {I}}\) is to be viewed as a record of messages (from the leader) to which _F_ has not yet reacted. If \({\mathfrak {c}}= \langle q, {\mathcal {I}}\rangle \) is an f-configuration, we denote by \( enb ( {\mathfrak {c}} )\) (short for _enabled_) the set of transitions \(\tau \in T^F\setminus \{ \textit{idle}\}\) such
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
that \(\langle q, \tau , q' \rangle \in \delta ^F\), for some \(q' \in Q^F\), and either (a) \(\tau \in T^F_\text {out} \cup T^F_\text {local}\) or (b) !Image 87\) if \(\tau \) is one of the available transitions for _F_ when _F_’s configuration is \({\mathfrak {c}}\). Thus, all transitions in which a message is sent and all local transitions are enabled, whereas transitions in which the follower reacts to a message are enabled only if the corresponding message is present in \({\mathcal {I}}\). As in the leader’s case, we want to enforce at each moment of time a form of persistence for the inbox \({\mathcal {I}}\), i.e.that \({\mathcal {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 \(\tau \in T^F\), we define the relation \(\preceq ^\tau \) over sets \(I, J \subseteq T^F_\text {in}\) as follows: 1. (a) if \(\tau \not \in T^F_\text {in}\), \(I \preceq ^\tau J\) iff \(I \subseteq J\); 2. (b) if !Image 89, where \({\mathfrak {c}}_n = \langle q_n, {\mathcal {I}}_n \rangle \) (\(n \in {\mathbb {N}}\)) is an f-configuration and \(\tau _n \in T^F\) (\(n \in {\mathbb {N}}\)), such that: \(q_0 \in Q^F_\text {init}\), \({\mathcal {I}}_0 = \emptyset \); for all \(n \in {\mathbb {N}}\), \({\mathcal {I}}_n \preceq ^{\tau _n} {\mathcal {I}}_{n+1}\) (persistence); and, for all \(n \in {\mathbb {N}}\), 1. (a) \(\tau _n \in enb ( {\mathfrak {c}}_n )\) and \(\langle q_n, \tau _n, q_{n+1} \rangle \in \delta ^F\); or 2.
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
(b) \( enb ( {\mathfrak {c}}_n ) = \emptyset \), \(\tau _n = \textit{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, unless explicitly deleted when a transition in \(T^F_\text {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 be a run for _F_. For all \(n \in {\mathbb {N}}\), if !Image 92), and !Image 93, we write \(T_1 \backsimeq T_2\) when the sets \(T_1\) and \(T_2\) are equal modulo removing the arrows, i.e.\(T_1 \backsimeq T_2\) when !Image 96. (Likewise \(T_2 \backsimeq T_1\).) A _distributed machine_ is a pair \(M = \langle L, F\rangle \), where _L_ is a leader, _F_ is a (replicated) follower, \(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}\). (The latter two constraints are to ensure that each message \(\vec {\mu }\) broadcast by the leader is a valid ingoing message !Image 97 sent by a follower, the leader has a corresponding inbox. The one before the latter two is to
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
avoid ambiguities in the logical translation presented in Sect.4 be a distributed machine and \(A = \{ a_1, \ldots , a_k \}\) (\(k > 0\)) be a set, referred to as the _universe_ of _M_. Intuitively, each \(a \in A\) is identified with a (replicated) follower _F_. A _run_ for _M_ over _A_ is a \((k+1)\)-tuple \({\mathfrak {R}}= \langle {\mathfrak {R}}^0, {\mathfrak {R}}^1, \ldots , {\mathfrak {R}}^k \rangle \), where \({\mathfrak {R}}^0 = \{ \langle {\mathfrak {c}}^0_n, \tau ^0_n \rangle \}_{n \in {\mathbb {N}}}\) (!Image 98 (\(1 \le i \le k\)) (\({\mathfrak {c}}^i_n = \langle q^i_n, {\mathcal {I}}^i_n \rangle \)) is a run for _F_, such that the following conditions hold: 1. (A1) If \(\tau ^0_n = \vec {\mu }\in T^L_\text {out}\) (\(n \in {\mathbb {N}}\)), then, for each _i_ (\(1 \le i \le k\)), there exists \(n' > n\) such that !Image 100), if !Image 101), there exists \(n' n\) such that !Image 102, \(n \in {\mathbb {N}}\)), there exists \(n' < n\) such that \(\tau ^i_{n'} = \vec {\mu }\). Intuitively, (A1) states that if the leader broadcasts a message \(\vec {\mu }\), a message !Image 104 has
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
been broadcast by the leader at some point in the past. Similarly, (A2) states that if a follower \(a \in A\) sends a message \(\vec {\mu }\) to the leader, _a_ will eventually appear in the inbox !Image 106 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: 1. (S1) If \(\tau ^0_n = \vec {\mu }\in T^L_\text {out}\) (\(n \in {\mathbb {N}}\)), then, for each _i_ (\(1 \le i \le k\)), !Image 108), if !Image 109 (\(n \in {\mathbb {N}}\)). 2. (S2) For each _i_ (\(1 \le i \le k\)), if \(\tau ^i_n = \vec {\mu }\in T^F_\text {out}\), then !Image 111), then \(\tau ^i_n = \vec {\mu }\) (\(n \in {\mathbb {N}}\)). 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 = \langle L, F \rangle \) (asynchronous or synchronous) is _runnable_ if there is a run for _M_ over some universe \(A = \{ a_1, \ldots , a_k \}\) (\(k > 0\)). ### Remark 1 The behaviour of a synchronous distributed
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
machine when the delivery of a message 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 coincides 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 \(\textsf {Spec}(M)\) (with \(\Vert \textsf {Spec}(M)\Vert \) quadratic in \(\Vert M\Vert \)) such that _M_ is runnable if and only if \(\textsf {Spec}(M)\) is satisfiable. (As we see in Sect.4.5\) sentence !Image 114 To this end, let \(M = \langle L, F\rangle \) be an asynchronous distributed machine. \(\textsf {Spec}(M)\) is defined over the signature \(\Sigma ^M\) 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; for each symbol \(\vec {\mu }\in T^L_\text {out}\), a nullary predicate \(\textsf {past}_{\vec {\mu }}\); for each symbol \(\vec {\mu }\in T^F_\text {out}\), a unary predicate \(\textsf {past}_{\vec {\mu }}(\cdot )\); a nullary predicate \({{\textsf{t}}}{{\textsf{l}}}_{\tau }\) for each \(\tau
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
\in T^L\); and a unary predicate \({{\textsf{t}}}{{\textsf{f}}}_{\tau }(\cdot )\) for each \(\tau \in T^F\). For each \(q \in Q^L\), \({{\textsf{s}}}{{\textsf{l}}}_{q}\) (short for _state leader_) is to be viewed as stating that the leader is at state _q_. For each \(q \in Q^F\), \({{\textsf{s}}}{{\textsf{f}}}_{q}(a)\) (short for _state follower_) is to be viewed as stating that follower _a_ is at state _q_. For each !Image 116. For each \(\vec {\mu }\in T^L_\text {out}\), \(\textsf {past}_{\vec {\mu }}\) is to be viewed as stating that the leader has in the past broadcast a message \(\vec {\mu }\). For each \(\vec {\mu }\in T^F_\text {out}\), \(\textsf {past}_{\vec {\mu }}(a)\) is to be viewed as stating that follower _a_ has in the past sent a message \(\vec {\mu }\) to the leader. For each \(\tau \in T^L\), \({{\textsf{t}}}{{\textsf{l}}}_{\tau }\) (short for _transition leader_) is to be viewed as stating that the leader takes transition \(\tau \). For each \(\tau \in T^F\), \({{\textsf{t}}}{{\textsf{f}}}_{\tau }(a)\) (short for _transition follower_) is to be viewed as stating that follower _a_ takes transition \(\tau \). We now proceed to write the constituent parts of \(\textsf {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: $$\begin{aligned} \textsf {ustatel}&\,:=\, \bigvee _{q \in Q^L} \big ( {{\textsf{s}}}{{\textsf{l}}}_{q} \,\wedge \!\!\!\! \bigwedge _{q' \in Q^L \setminus
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
\{ q \}} \!\!\!\! \lnot {{\textsf{s}}}{{\textsf{l}}}_{q'} \big ), \\ \textsf {utransl}&\,:=\, \bigvee _{\tau \in T^L} \big ( {{\textsf{t}}}{{\textsf{l}}}_{\tau } \,\wedge \!\!\!\! \bigwedge _{\tau ' \in T^L \setminus \{ \tau \}} \!\!\!\! \lnot {{\textsf{t}}}{{\textsf{l}}}_{\tau '} \big ). \end{aligned}$$ 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: !Image 124 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 !Image 125 is taken. In the following definition we slighty abuse the notation \({{\textsf{t}}}{{\textsf{l}}}_{\tau }\) (\(\tau \in T^L\)) for brevity: we write \({{\textsf{t}}}{{\textsf{l}}}_{\tau _1, \ldots , \tau _j}\) (\(\tau _1, \ldots , \tau _j \in T^L\)) as a shorthand for \({{\textsf{t}}}{{\textsf{l}}}_{\tau _1} \vee \cdots \vee {{\textsf{t}}}{{\textsf{l}}}_{\tau _j}\). Let !Image 130 describe the necessary conditions for a transition to be enabled. They are part of the formulas that describe the step-by-step execution of the leader. For each \(\tau \in T^L \setminus \{ \textit{idle} \}\), let !Image 131 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: !Image 132 \end{aligned}$$ describes the leader’s whole operation. It is clear that \(\Vert \textsf {leader}\Vert = {\mathcal
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
{O}}(\Vert L\Vert ^2)\). ### 4.2 The followers’ execution Next, we write a collection of formulas describing the execution of each follower. The following formulas (short for _unique state follower_ and _unique transition follower_ respectively) state that the states and transitions of follower _x_ are unique: $$\begin{aligned} \textsf {ustatef}(x)&\,:=\, \bigvee _{q \in Q^F} \big ( {{\textsf{s}}}{{\textsf{f}}}_{q}(x) \,\wedge \!\!\!\! \bigwedge _{q' \in Q^F \setminus \{ q \}} \!\!\!\! \lnot {{\textsf{s}}}{{\textsf{f}}}_{q'}(x) \big ), \\ \textsf {utransf}(x)&\,:=\, \bigvee _{\tau \in T^F} \big ( {{\textsf{t}}}{{\textsf{f}}}_{\tau }(x) \,\wedge \!\!\!\! \bigwedge _{\tau ' \in T^F \setminus \{ \tau \}} \!\!\!\! \lnot {{\textsf{t}}}{{\textsf{f}}}_{\tau '}(x) \big ). \end{aligned}$$ The next formula (short for _initial follower_) describes the initial conditions for the execution of follower _x_, i.e.that follower _x_ starts at an initial state with its inbox empty: !Image 133 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 \(\tau \in T^F_\text {in}\) (which deletes the corresponding message) is taken. Let !Image 134 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 \(\tau \in T^F\), let !Image 135 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 \(\textsf {stepf}(x)\) be the logical disjunction of the following two formulas: !Image 136 \,:=\, \textsf {initf}(x) \wedge \Box \big ( \textsf {ustatef}(x) \wedge \textsf {utransf}(x) \wedge \textsf{persf}_{ }(x) \wedge \textsf {stepf}(x) \big ) \end{aligned}$$ describes the leader’s
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
whole operation. It is clear that \(\Vert \textsf {follower}(x)\Vert = {\mathcal {O}}(\Vert F\Vert ^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 \(\textsf {Spec}(M)\). The following two formulas enforce the intended semantics for the predicates \(\textsf {past}_{\vec {\mu }}\) (\(\vec {\mu }\in T^L_\text {in}\)) and \(\textsf {past}_{\vec {\mu }}(\cdot )\) (\(\vec {\mu }\in T^F_\text {in}\)). Recall from the beginning of this section that \(\textsf {past}_{\vec {\mu }}\) (\(\vec {\mu }\in T^L_\text {in}\)) is to be read as “a message \(\vec {\mu }\) has in the past been broadcast by the leader” and \(\textsf {past}_{\vec {\mu }}(x)\) (\(\vec {\mu }\in T^F_\text {in}\)) as “follower _x_ has in the past sent a message \(\vec {\mu }\) to the leader”. Thus, \(\textsf {past}_{\vec {\mu }}\) must be false until (and when) the leader takes transition \({{\textsf{t}}}{{\textsf{l}}}_{\vec {\mu }}\) (if it ever does) and true thereafter; and likewise for \(\textsf {past}_{\vec {\mu }}(x)\) and \({{\textsf{t}}}{{\textsf{f}}}_{\vec {\mu }}(x)\). Let \(\textsf {pastm}\) (short for _past messages_) be the logical conjunction of the following two formulas: !Image 137 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 (resp.\(T^F_\text {out} \backsimeq T^L_\text {in}\)), the symbol !Image 139 exists. Likewise, the nullary predicate \(\textsf {past}_{\vec {\mu }}\) (resp.unary
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
predicate \(\textsf {past}_{\vec {\mu }}(\cdot )\)) appearing in the second conjunct of bcastla (resp.sendfa) exists. Finally, the following formula \(\textsf {neta}\) (short for _network asynchronous_) describes the operation of the asynchronous network comprising the leader and its followers: $$\begin{aligned} \textsf {neta} \,:=\, \textsf {pastm} \wedge \Box (\textsf {bcastla} \wedge \textsf {sendfa}). \end{aligned}$$ It is clear that \(\Vert \textsf {neta}\Vert = {\mathcal {O}}(\Vert L\Vert + \Vert F\Vert )\). We are now ready to give a full logical description of _M_. Let $$\begin{aligned} \textsf {Spec}(M) \,:=\, \textsf {leader} \wedge \forall x \, \textsf {follower}(x) \wedge \textsf {neta}. \end{aligned}$$ With regard to size, it follows that \(\Vert \textsf {Spec}(M)\Vert = {\mathcal {O}}(\Vert M\Vert ^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 \(\vec {\mu }\) is sent then a message !Image 142) at some point in the future (possibly at different times by different recipients), we simply state that if \({{\textsf{t}}}{{\textsf{l}}}_{\vec {\mu }}\) or \({{\textsf{t}}}{{\textsf{f}}}_{\vec {\mu }}(x)\) (for any follower _x_) holds true at any moment then !Image 143. 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 or a \(\overleftarrow{nogo}\) message to enter or not enter respectively a critical section, and, at a given round of the protocol, it receives both a \(\overleftarrow{go}\) and a \(\overleftarrow{nogo}\) message, the first being the intended message and the second being a re-delivery
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
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 \(\textsf {Spec}(M)\) is satisfiable. ### Lemma 3 Let \(M = \langle L, F \rangle \) be an asynchronous distributed machine and \(\textsf {Spec}(M)\) as above. If _M_ is runnable, then \(\textsf {Spec}(M)\) is satisfiable over a finite domain. ### Proof Let \(A = \{a_1, \ldots , a_k \}\) (\(k > 0\)) and let \({\mathfrak {R}}= \langle {\mathfrak {R}}^0, {\mathfrak {R}}^1, \ldots , {\mathfrak {R}}^k \rangle \) be a run for _M_ over _A_. Thus, \({\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_. Recall that for each \(n \in {\mathbb {N}}\), assuming that !Image 145); and \({\mathfrak {c}}^i_n = \langle q^i_n, {\mathcal {I}}^i_n \rangle \) (\(1 \le
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
i \le k\)), where \({\mathcal {I}}^i_n \subseteq T^F_\text {in}\) (\(1 \le i \le k\)). Let \(\Sigma ^M\) be as in the beginning of this section. We construct from \({\mathfrak {R}}\) a sequence \({\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_, such that \(\textsf {Spec}(M)\) is true in \({\mathfrak {M}}\). For each \(n \in {\mathbb {N}}\), let \({\mathfrak {A}}_n\) be such that: 1. (a) for each \(q \in Q^L\), \({{\textsf{s}}}{{\textsf{l}}}_{q}^{{\mathfrak {A}}_n} = \top \) if \(q = q^0_n\), otherwise \({{\textsf{s}}}{{\textsf{l}}}_{q}^{{\mathfrak {A}}_n} = \bot \); 2. (b) for each !Image 148 for each \(\vec {\mu }\in T^L_\text {out}\), \(\textsf {past}_{\vec {\mu }}^{\,{\mathfrak {A}}_n} = \top \) if \(\tau ^0_{n'} = \vec {\mu }\) for some \(n' < n\), otherwise \(\textsf {past}_{\vec {\mu }}^{\,{\mathfrak {A}}_n} = \bot \); 4. (d) for each \(\tau \in T^L\), \({{\textsf{t}}}{{\textsf{l}}}_{\tau }^{{\mathfrak {A}}_n} = \top \) if \(\tau ^0_n = \tau \), otherwise \({{\textsf{t}}}{{\textsf{l}}}_{\tau }^{{\mathfrak {A}}_n} = \bot \); 5. (e) for each \(q \in Q^F\), \({{\textsf{s}}}{{\textsf{f}}}_{q}^{{\mathfrak {A}}_n} = \{ a_i \in A \mid q^i_n = q \}\); 6. (f) for each !Image 150 for each \(\vec {\mu }\in T^F_\text {in}\), \(\textsf {past}_{\vec {\mu }}^{\,{\mathfrak {A}}_n} = \{a_i \in A \mid \exists \; n' < n \text {~s.t.~} \tau ^i_{n'} = \vec {\mu }\}\); 8. (h) for each \(\tau \in T^F\), \({{\textsf{t}}}{{\textsf{f}}}_{\tau }^{{\mathfrak {A}}_n} = \{ a_i \in A \mid \tau ^i_n = \tau \}\). We now show that \(\textsf {leader}\), \(\forall x \, \textsf {follower}(x)\), and \(\textsf {neta}\) are all true in \({\mathfrak {M}}\). It then follows that \(\textsf {Spec}(M)\) is true in \({\mathfrak {M}}\). Starting with the leader, it is easily obtained from the definition of a run for _L_ together with
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
(a), (b), and (d) that \({\mathfrak {A}}_0 \models \textsf {initl}\) and, for all \(n \in {\mathbb {N}}\), \({\mathfrak {A}}_n \models \textsf {ustatel}\) and \({\mathfrak {A}}_n \models \textsf {utransl}\). To show that, for all \(n \in {\mathbb {N}}\), \({\mathfrak {A}}_n \models \textsf {persl}\), let !Image 152, !Image 158, which, in turn, implies due to (b) that !Image 163, !Image 169, if !Image 173 that !Image 175 is then evident. To show that, for all \(n \in {\mathbb {N}}\), \({\mathfrak {A}}_n \models \textsf {stepl}\), we consider two cases. If \( enb ( {\mathfrak {c}}^0_n ) \ne \emptyset \), we have \(\tau ^0_n \in enb ( {\mathfrak {c}}^0_n )\). Thus, from (a) and (d), \({\mathfrak {A}}_n \models {{\textsf{s}}}{{\textsf{l}}}_{q^0_n}\), \({\mathfrak {A}}_n \models {{\textsf{t}}}{{\textsf{l}}}_{\tau ^0_n}\), and !Image 177 and (b) that \({\mathfrak {A}}_n \models \textsf{enbl}_{ \tau ^0_n }\). Consequently, !Image 178 satisfies the first disjunct of \(\textsf {stepl}\). If \( enb ( {\mathfrak {c}}^0_n ) = \emptyset \), we have \(\tau ^0_n = \textit{idle}\) and \(q^0_n = \sigma ({\mathfrak {c}}^0_n) = \sigma ({\mathfrak {c}}^0_{n+1}) = q^0_{n+1}\). Thus, from (a) and (d), \({\mathfrak {A}}_n \models {{\textsf{s}}}{{\textsf{l}}}_{q^0_n}\), \({\mathfrak {A}}_n \models {{\textsf{t}}}{{\textsf{l}}}_{\textit{idle}}\), and ![Image 179]( Further, it is straightforward to establish from the definition of
|
{
"page_id": null,
"source": 7332,
"title": "from dpo"
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.