Split (1)

train · 617k rows

text stringlengths 2 132k	source dict
be the ( + 1)st operation of L. Let op be invoked by process p. The following cases are possible: – op is a read (a): the snapshot taken at op ’s linearization point contains all successful transfers concerning a in L. By the induction hypothesis, the resulting balance is non-negative. – op is a failed transfer (a, b...	{ "page_id": null, "source": 7322, "title": "from dpo" }
that, in a more demanding model than shared memory with crash faults (particularly the Byzantine message passing model), solving consensus among k processes is necessary, but not necessar-ily sufficient for implementing k-shared asset transfer. # 5 Asset transfer in message passing We established our theoretical result...	{ "page_id": null, "source": 7322, "title": "from dpo" }
corresponding account’s owner. The message being broad-cast carries, in addition to the transfer itself, references to the transfer’s dependencies. As secure broadcast only provides liveness if the sender is correct, faulty processes might not be able to perform any transfers. However, due to secure broadcast’s deliver...	{ "page_id": null, "source": 7322, "title": "from dpo" }
on the Byzan-tine message passing model, adapt our asset-transfer object accordingly (Sect. 5.1) and present its broadcast-based implementation (Sect. 5.2). 5.1 Byzantine message passing model A process is Byzantine if it deviates from the algorithm it is assigned, either by halting prematurely, in which case we say th...	{ "page_id": null, "source": 7322, "title": "from dpo" }
a nutshell, sequential consistency resembles lineariz-ability with real-time constraints removed. Each process observes a sequence of events consistent with the sequential specification, but the effects of other processes’ invocations need not respect real-time order with respect to the process’ own invocations. One ca...	{ "page_id": null, "source": 7322, "title": "from dpo" }
has a fully asynchronous implementation. It provides uniform reliable delivery despite Byzantine faults and so-called source order among delivered messages. The source order property, being weaker than FIFO, guarantees that messages from the same source are delivered in the same order by all correct pro-cesses. More pr...	{ "page_id": null, "source": 7322, "title": "from dpo" }
to using vector clocks for implementing causal order among events . To ensure the authenticity of operations—so that no pro-cess is able to debit another process’s account—we assume that processes sign all their messages before broadcasting them. In practice, similar to Bitcoin and other transfer sys-tems, every proces...	{ "page_id": null, "source": 7322, "title": "from dpo" }
operation via the secure broadcast primitive (line 4). This message includes the three basic arguments of a transfer operation as well as seq [ p] + 1 and depen-dencies deps . Each correct process in the system eventually delivers this message via secure broadcast (line 8). Note that, given the assumption of no process...	{ "page_id": null, "source": 7322, "title": "from dpo" }
validated (line 24). Third, the balance of account q must not drop below zero (line 25). Finally, the reported dependencies of op (encoded in h of line 26) must have been validated and exist in hist [q]. Lemma 3 In any infinite execution of the algorithm (Fig. 4), every operation performed by a correct process eventual...	{ "page_id": null, "source": 7322, "title": "from dpo" }
holds. Thus, p eventually validates T and completes the opera-tion by returning true in line 20. Theorem 3 The algorithm in Fig. 4 implements an asset-transfer object type. Proof Fix an execution E of the algorithm, let H be the cor-responding history. Let V denote the set of all messages that were delivered (line 8)...	{ "page_id": null, "source": 7322, "title": "from dpo" }
pair transfer (q, d, y); true .By construction, every operation transfer (q, d, y) in S is preceded by a sequence of transfers that ensure that the bal-ance of q does not drop below y (line 25). In particular, S includes all outgoing transfers from the account of q per-formed previously by q itself. Additionally S may ...	{ "page_id": null, "source": 7322, "title": "from dpo" }
that the balance operation only consults local state without syn-chronizing with other processes. What prevents the implementation from being fully lin-earizable is the following situation. A process p returns from a successful transfer operation o after having deliv-ered its own broadcast message m. Then, some other p...	{ "page_id": null, "source": 7322, "title": "from dpo" }
their outgo-ing transfers. In a nutshell, the function of an SMR service is to receive inputs from clients, establish a total order on those inputs and compute functions of the resulting sequence that it returns to clients. In particular, the account owners submit their issued transfers to the service, which assigns mo...	{ "page_id": null, "source": 7322, "title": "from dpo" }
each broadcast message is equipped with a sequence number (generated by the BFT service, as we will see below). – Account order: If a benign process p delivers messages m (with sequence number s) and m′ (with sequence num-ber s′) such that m and m′ are associated with the same account and s < s′, then p delivers m befo...	{ "page_id": null, "source": 7322, "title": "from dpo" }
the service is consistent, the transfer receives a unique sequence number s. Note that the decided tuple (a, t, s) should be signed by a quorum of owners: this will be used by the other processes in the system to ensure that the sequence number has been indeed agreed upon by the own-ers of a. The process executes the p...	{ "page_id": null, "source": 7322, "title": "from dpo" }
smart contracts, for certain forms of which consensus is indeed necessary. However, our approach allows for arbitrary operations, if those operations affect groups of the participants that can solve consensus among themselves. Potential safety or live-ness violations of those operations (in case this group gets comprom...	{ "page_id": null, "source": 7322, "title": "from dpo" }
the first to formally define the asset transfer problem as a shared object type, study its consensus number, and propose algorithms building on top of standard abstractions that are amenable to a real deployment in cryptocurrencies. > Funding Open Access funding provided by EPFL Lausanne. Declarations > Conflict of int...	{ "page_id": null, "source": 7322, "title": "from dpo" }
M., Cocco, S.W., Yellick, J.: Hyperledger fabric: A distributed operating system for permissioned blockchains. In: Proceedings of the Thirteenth EuroSys Conference, EuroSys ’18, pp. 30:1– 30:15. ACM, New York (2018). 3190538 5. Antoniadis, K., Guerraoui, R., Malkhi, D., Seredinschi, D.A.: State machine replication is ...	{ "page_id": null, "source": 7322, "title": "from dpo" }
byzantine fault tolerant systems tolerate byzantine faults. In: NSDI, pp. 153–168. USENIX Association, Berkeley (2009) 16. Collins, D., Guerraoui, R., Komatovic, J., Kuznetsov, P., Monti, M., Pavlovic, M., Pignolet, Y., Seredinschi, D., Tonkikh, A., Xygkis, A.: Online payments by merely broadcasting messages. In: 2020 ...	{ "page_id": null, "source": 7322, "title": "from dpo" }
M., Seredinschi, D.A.: Blockchain proto-cols: the adversary is in the details. In: Symposium on Foundations and Applications of Blockchain (2018). 2018/assets/papers/fab18_submission_04.pdf 26. Gupta, S.: A non-consensus based decentralized financial transac-tion processing model with support for efficient auditing. M...	{ "page_id": null, "source": 7322, "title": "from dpo" }
internet-level consensus. Stellar Development Foundation (2015) 39. Nakamoto, S.: Bitcoin: a peer-to-peer electronic cash system (2008) 40. Pedone, F., Schiper, A.: Handling message semantics with generic broadcast protocols. Distrib. Comput. 15 (2), 97–107 (2002) 41. Rapoport, P., Leal, R., Griffin, P., Sculley, W.: T...	{ "page_id": null, "source": 7322, "title": "from dpo" }
Title: The Consensus Number of a Cryptocurrency URL Source: Markdown Content: > arXiv:1906.05574v1 [cs.DC] 13 Jun 2019 # The Consensus Number of a Cryptocurrency ∗ # (Extended Version) # Rachid Guerraoui rachid.guerraoui@epfl.ch EPFL Lausanne, Switzerland # Petr Kuznetsov petr.kuznetsov@telecom-paristech.fr LTCI, Télé...	{ "page_id": null, "source": 7322, "title": "from dpo" }
implementa-tion that is both simpler and more efficient than state-of-the-art consensus-based solutions. Our results are applicable to both the permissioned (private) and permissionless (public) setting, as nor-mally their differentiation is hidden by the abstractions on top of which our algorithms are based. ## CCS CO...	{ "page_id": null, "source": 7322, "title": "from dpo" }
known for its notorious difficulty. It has no deterministic solution in asynchronous systems if just a single participant can fail . Partially synchronous consen-sus algorithms are tricky to implement correctly [1, 12, 15] and face tough trade-offs between performance, security, and energy-efficiency [5, 8, 23, 46]. No...	{ "page_id": null, "source": 7322, "title": "from dpo" }
need to agree with any other process—thus the consensus number 1. Other processes only validate the owner’s decisions, ensuring that causal relations across accounts are respected. We describe a simple as-set transfer implementation using atomic-snapshot memory . A withdrawal from an account is validated by relating th...	{ "page_id": null, "source": 7322, "title": "from dpo" }
nodes and not among all nodes in the system. In particular, should these k nodes be faulty, the rest of the accounts will not be affected. To summarize, we argue that treating the asset transfer problem as a concurrent data structure and measuring its hardness through the lense of distributed computing help understand ...	{ "page_id": null, "source": 7322, "title": "from dpo" }
We assume that ∆ is total on the first three elements. A history is a sequence of invocations and responses, each invo-cation or response associated with a process identifier. A sequential history is a history that starts with an invocation and in which ev-ery invocation is immediately followed with a response associat...	{ "page_id": null, "source": 7322, "title": "from dpo" }
H \|p. A history is complete if it has no incomplete invocations. A completion of H is a history ¯H that is identical to H except that every incomplete invocation in H is either removed or completed by inserting a matching response somewhere after it. > 2The Consensus Number of a Cryptocurrency An invocation o1 precedes...	{ "page_id": null, "source": 7322, "title": "from dpo" }
N assigns the initial bal-ance to each account. • Operations and responses of the type are defined as O = {transfer (a, b, x) : a, b ∈ A , x ∈ N} ∪ { read (a) : a ∈ A} and R = {true , false } ∪ N. • ∆ is the set of valid state transitions. For a state q ∈ Q, a process p ∈ Π, an operation o ∈ O, a response r ∈ R and a n...	{ "page_id": null, "source": 7322, "title": "from dpo" }
original paper , we assume for the mo-ment that an asset-transfer object has at most one owner per ac-count: ∀a ∈ A : \|μ(a)\| ≤ 1. Later we lift this assumption and con-sider more general k-shared asset-transfer objects with arbitrary owner maps μ (Section 4). For the sake of simplicity, we also restrict ourselves to tr...	{ "page_id": null, "source": 7322, "title": "from dpo" }
To read the balance of an account a, the process simply takes a snapshot S and returns the initial balance plus the sum of incoming amounts minus the sum of all outgoing amounts. We denote this number by balance (a, S). As we argue below, the result is guaranteed to be non-negative, i.e., the opera-tion is correct with...	{ "page_id": null, "source": 7322, "title": "from dpo" }
that returned, and • All invocations of transfer in E that completed the update operation (line 5). Let H be the history of E. We define a completion of H and, for each o ∈ Ops , we define a linearization point as follows: • If o is a read operation, it linearizes at the linearization point of the snapshot operation in...	{ "page_id": null, "source": 7322, "title": "from dpo" }
successful transfer (a, b, x): by the algorithm, before the linearization point of op , process p took a snapshot. Let Lk , k ≤ ℓ, be the prefix of Lℓ that only contain operations linearized before the point in time when the snapshot was taken by p.We observe that Lk includes a subset of all incoming trans-fers on a an...	{ "page_id": null, "source": 7322, "title": "from dpo" }
the case with an arbitrary owner map μ. We show that an asset-transfer object’s consensus number is the maximal number of processes sharing an account. More precisely, the con-sensus number of an asset-transfer object is max a ∈A \|μ(a)\| .We say that an asset-transfer object, defined on a set of accounts A with an owner...	{ "page_id": null, "source": 7322, "title": "from dpo" }
succeeds, the remaining balance on a will uniquely identify process p.To satisfy the above conditions, we initialize the balance of account a to 2k and have each process p ∈ { 1, . . . , k } transfer 2k −p (line 2). Note that transfer operations invoked by distinct processes p, q ∈ > 4The Consensus Number of a Cryptocu...	{ "page_id": null, "source": 7322, "title": "from dpo" }
known to have consensus number exactly k , a wait-free algorithm implementing k-shared asset-transfer using only registers and k-consensus objects implies that the consensus number of k-shared asset-transfer is not more than k.The algorithm reducing k-shared asset-transfer to k-consensus is given in Figure 3. Before pr...	{ "page_id": null, "source": 7322, "title": "from dpo" }
in a snapshot AS (denoted by (tx , success ) ∈ AS ) if there exists an entry e in AS such that (tx , success ) ∈ AS [e].To execute a transfer o outgoing from account a, a process p first announces o in a register Ra that can be written by p and read by any other process. This enables a “helping” mechanism needed to ens...	{ "page_id": null, "source": 7322, "title": "from dpo" }
(t x , success ) ∈ hist then > 16 return true > 17 else > 18 return false Upon read (a): > 19 return balance (a, AS .snapshot ()) collect(a) : > 20 collected = ∅ > 21 for all i = Π do > 22 if Ra [i].r ead () , ⊥ then > 23 collected = collected ∪ { Ra [i].r ead ()} > 24 return collected proposal (( a, b, q, x ), snapsho...	{ "page_id": null, "source": 7322, "title": "from dpo" }
instance of k-consensus is chosen as follows. Process p picks the “oldest” col-lected but not yet committed operation (based on the round num-ber round a attached to the transfer operation when a process an-nounces it; ties are broken using process IDs). Then p takes a snap-shot of AS and checks whether account a has s...	{ "page_id": null, "source": 7322, "title": "from dpo" }
op-erations o such that some process completed the update operation (line 11) in E with an argument including o (the atomic snapshot and k-consensus operation has been linearized). Intuitively, we in-clude in Ops all operations that took effect , either by returning a response to the user or by affecting other operatio...	{ "page_id": null, "source": 7322, "title": "from dpo" }
of L. Let Lℓ be the legal prefix of the first ℓ operation and op be the (ℓ + 1)st operation of L. Let op be invoked by process p. The following cases are possible: • op is a read (a): the snapshot taken at op ’s linearization point contains all successful transfers concerning a in Lℓ . By the induction hypothesis, the ...	{ "page_id": null, "source": 7322, "title": "from dpo" }
TRANSFER IN MESSAGE PASSING We established our theoretical results in a shared memory system with crash failures, proving that consensus is not necessary for implementing an asset transfer system. Moreover, a natural gener-alization of such a system where up to k processes have access to atomic operations on the same a...	{ "page_id": null, "source": 7322, "title": "from dpo" }
the system state. Every transfer operation only entails a single invocation of se-cure broadcast and our algorithm does not send any additional messages. Our algorithm inherits the complexity from the un-derlying secure broadcast implementation, and there is plenty of such algorithms optimizing complexity metrics for v...	{ "page_id": null, "source": 7322, "title": "from dpo" }
it is as-signed, either by halting prematurely, in which case we say that the process is crashed , or performing actions that are not prescribed by its algorithm, in which case we say that the process is malicious .Malicious processes can perform arbitrary actions, except for ones that involve subverting cryptographic ...	{ "page_id": null, "source": 7322, "title": "from dpo" }
that were executed by correct processes in E. An asset-transfer object in message passing guarantees that each invocation issued by a correct process is followed by a matching response in H ,and that there exists ¯H , a completion of H , such that: (1) Let ¯H t denote the sub-history of successful transfers of ¯H perfo...	{ "page_id": null, "source": 7322, "title": "from dpo" }
If processes p and q are correct and p delivers m, then q delivers m. • Validity: If a correct process p broadcasts m, then p delivers m. • Source order: If p and q are benign and both deliver m from r and m′ from r , then they do so in the same order. Operation. To perform a transfer tx , a process p securely broad-ca...	{ "page_id": null, "source": 7322, "title": "from dpo" }
maintains, for each process q, an integer seq [q] reflecting the number of transfers which process q initiated and which process p has validated and applied. Process p also maintains, for every process q, an integer rec [q] reflecting the number of transfers pro-cess q has initiated and process p has delivered (but not...	{ "page_id": null, "source": 7322, "title": "from dpo" }
> 2if balance (a,hist [p] ∪ deps ) 3return false > 4broadcast ([( a,b,x,seq [p]+1),deps ]) > 5deps =∅ > 6operation read (a) > 7return balance (a,hist [a] ∪ deps ) > 8upon deliver (q,m) > 9let mbe [( q,d,y,s),h] > 10 if s=rec [q]+1then > 11 rec [q]=rec [q]+1 > 12 toValidate =toValidate ∪ {( q,m)} > 13 upon (q,[t,h]) ∈ t...	{ "page_id": null, "source": 7322, "title": "from dpo" }
is outgoing for p, i.e., it is the currently pending transfer operation invoked by p,then the response true is returned (line 20). > 8The Consensus Number of a Cryptocurrency To perform a read (a) operation for account a, process p simply computes the balance of this account based on the local history hist [a] (line 28...	{ "page_id": null, "source": 7322, "title": "from dpo" }
is no such transfer) but before issuing T (lines 4 and 5). As process p is correct, it operates on its own account, respects the sequence numbers, and issues a transfer only if it has enough balance on the account. Thus, when it is delivered by p, T must satisfy the first three conditions of the Valid predicate (lines ...	{ "page_id": null, "source": 7322, "title": "from dpo" }
a correct process to toValidate set only if the previous message from q added to toValidate had sequence number i − 1 (line 10). Furthermore, a mes-sage m = [( q, d, y, s), h] is validated at a correct process only if all messages in h have been previously validated (line 26). Therefore, is acyclic and thus can be ex...	{ "page_id": null, "source": 7322, "title": "from dpo" }
it to a total order. Let Sp be the sequential history build in the same way as S above. Similarly, we can see that Sp is legal and, by construction, consistent with the local history of all operations of p (including reads and failed transfers). By Lemma 3, every operation invoked by a correct process even-tually compl...	{ "page_id": null, "source": 7322, "title": "from dpo" }
for the whole set of sys-tem participants. Furthermore, communication complexity of such an implementation is polynomial in k and not in N , the number of processes. Account order in secure broadcast. Consider even the case where the threshold of one third of Byzantine owners is exceeded, where the account may become b...	{ "page_id": null, "source": 7322, "title": "from dpo" }
order. If the owners of an account send conflicting messages for the same sequence num-ber, the account may block. However, and most importantly, even a compromised account is always prevented from double spend-ing. Liveness of operations on a compromised account is not guar-anteed, but safety and liveness of other ope...	{ "page_id": null, "source": 7322, "title": "from dpo" }
44]. Decentralized systems for the pub-lic setting are open to the world. To prevent malicious parties from overtaking the system, these systems rely on Sybil-proof tech-niques, e.g., proof-of-work , or proof-of-stake . The above-mentioned solutions, whether for the permissionless or the permis-sioned environment, seek...	{ "page_id": null, "source": 7322, "title": "from dpo" }
history is managed by the corresponding account owner with-out depending on a global view of the system. Histories are loosely coupled through a causality relation established by dependencies among transfers. The important insight that an asynchronous broadcast-style ab-straction suffices for transfers appears in the l...	{ "page_id": null, "source": 7322, "title": "from dpo" }
K., Guerraoui, R., Malkhi, D., and Seredinschi, D.-A. State Ma-chine Replication Is More Expensive Than Consensus. In 32nd International Symposium on Distributed Computing (DISC 2018) (Dagstuhl, Germany, 2018), U. Schmid and J. Widder, Eds., vol. 121 of Leibniz International Proceedings in In-formatics (LIPIcs) , Schlo...	{ "page_id": null, "source": 7322, "title": "from dpo" }
Association, pp. 153–168. Decker, C., Seidel, J., and Wattenhofer, R. Bitcoin meets strong consistency. In Proceedings of the 17th International Conference on Distributed Computing and Networking (New York, NY, USA, 2016), ICDCN ’16, ACM, pp. 13:1–13:10. Duan, S., Reiter, M. K., and Zhang, H. Beat: Asynchronous bft m...	{ "page_id": null, "source": 7322, "title": "from dpo" }
1993, ch. 5, pp. 97– 145. Hearn, M. Corda: A distributed ledger. Corda Technical White Paper, 2016. Herlihy, M. Wait-free synchronization. TOPLAS 13 , 1 (1991), 123–149. Herlihy, M. P., and Wing, J. M. Linearizability: A correctness condition for concurrent objects. ACM Trans. Program. Lang. Syst. 12 , 3 (July 1990)...	{ "page_id": null, "source": 7322, "title": "from dpo" }
Leal, R., Griffin, P., and Sculley, W. The Ripple Protocol, 2014. Sompolinsky, Y., and Zohar, A. Accelerating Bitcoin’s transaction process-ing: fast money grows on trees, not chains. IACR Cryptology ePrint Archive, 2013:881, 2013. Sousa, J., Bessani, A., and Vukolic, M. A byzantine fault-tolerant ordering service fo...	{ "page_id": null, "source": 7322, "title": "from dpo" }
Title: 06.Consensus copy URL Source: Markdown Content: # Consensus and # Reliable Broadcast # Broadcast If a process sends a message , then every process eventually delivers m m # Broadcast If a process sends a message , then every process eventually delivers p0 p1 p2 p3 m m # Broadcast If a process sends a message , ...	{ "page_id": null, "source": 7323, "title": "from dpo" }
process eventually decides some value v v v v v vProperties of # send(m) and receive(m) Benign failures: Validity If sends to , and , , and the link between them are correct, then eventually receives Uniform* Integrity For any message , receives at most once from , and only if sent to * A property is uniform if it appl...	{ "page_id": null, "source": 7323, "title": "from dpo" }
3: receive from 4: := 5: decide min( ) Process :pi V = {vi} pj vi vi x j, 0 ≤ j ≤ n−1, j ̸ = i Sj V ∪ SjV V # An execution p1 p2 p3 p4 p1 p2 p3 p4 v1 v2 v3 v4 # An execution p1 p2 p3 p4 p1 p2 p3 p4 v1 v2 v3 v4An execution p1 p2 p3 p4 p1 p2 p3 p4 v1 v2 v3 v4 v1 v4 Suppose at the end of round 1 Can decide? v1 = v3 = v4 p...	{ "page_id": null, "source": 7323, "title": "from dpo" }
A process that receives a proposal in round 1, relays it to others during round 2. Echoing values A process that receives a proposal in round 1, relays it to others during round 2. Suppose hasn’t heard from at the end of round 2. Can decide? p3 p2 p3 # Echoing values A process that receives a proposal in round 1, relay...	{ "page_id": null, "source": 7323, "title": "from dpo" }
: pi v V V ∪ Sj Sj pj vi x V # Termination and # Integrity Termination Initially To execute propose( ) round 1: send { has not already sent } to all 2: for all do 3: receive from 4: := decide(x) occurs as follows: 5: if then 6: decide min( ) V = {vi} vi Sj pj V ∪ SjV k = f +1 V k, 1 ≤ k ≤ f +1 j, 0 ≤ j ≤ n−1, j ̸ = i v...	{ "page_id": null, "source": 7323, "title": "from dpo" }
f + 1 Decides on min(V) --- which is well defined Integrity At most one value: – one decide, and min(V) is unique Only if it was proposed: Initially To execute propose( ) round 1: send { has not already sent } to all 2: for all do 3: receive from 4: := decide(x) occurs as follows: 5: if then 6: decide min( ) V = {vi} v...	{ "page_id": null, "source": 7323, "title": "from dpo" }
6: decide min( ) V = {vi} vi Sj pj V ∪ SjV k = f +1 V k, 1 ≤ k ≤ f +1 j, 0 ≤ j ≤ n−1, j ̸ = i v ∈ V : pi v f +1 f +1 k = j +1 k = 1 # Validity Initially To execute propose( ) round 1: send { has not already sent } to all 2: for all do 3: receive from 4: := decide(x) occurs as follows: 5: if then 6: decide min( ) V = {v...	{ "page_id": null, "source": 7323, "title": "from dpo" }
propose( ) round 1: send { has not already sent } to all 2: for all do 3: receive from 4: := decide(x) occurs as follows: 5: if then 6: decide min( ) V = {vi} vi Sj pj V ∪ SjV k = f +1 V k, 1 ≤ k ≤ f +1 j, 0 ≤ j ≤ n−1, j ̸ = i v ∈ V : pi v r ≥ 1 p v r p0, p 1, . . . , p r pr = p p0 v pk−1 pkv # Agreement Lemma 2: In ev...	{ "page_id": null, "source": 7323, "title": "from dpo" }
∪ SjV k = f +1 V k, 1 ≤ k ≤ f +1 j, 0 ≤ j ≤ n−1, j ̸ = i v ∈ V : pi v p x V f +1 p x V f +1 f +1 Vi = Vj pi pjAgreement Lemma 2: In every execution, at the end of round , for every correct processes and Proof: • Show that if a correct has in its at the end of round , then every correct has in its at the end of round • ...	{ "page_id": null, "source": 7323, "title": "from dpo" }
correct . Let that process be • If , then sends in round ; every correct process receives and adds to its in round • What if ? Agreement follows from Lemma 2, since min is a deterministic function Initially To execute propose( ) round 1: send { has not already sent } to all 2: for all do 3: receive from 4: := decide(x)...	{ "page_id": null, "source": 7323, "title": "from dpo" }
send { has not already sent } to all 2: for all do 3: receive from 4: := decide(x) occurs as follows: 5: if then 6: decide min( ) V = {vi} vi Sj pj V ∪ SjV k = f +1 V k, 1 ≤ k ≤ f +1 j, 0 ≤ j ≤ n−1, j ̸ = i v ∈ V : pi v p x V f +1 p x V f +1 r r = f +1 x V p p∗ r ≤ f p∗ x r+1 ≤ f +1 x x V r+1 p0, . . . , p f +1 = p∗ f ...	{ "page_id": null, "source": 7323, "title": "from dpo" }
2: if p ≠ sender then 3: send m to all 4: halt 5: receive round k messages 6: if received m then 7: deliver(m) 8: if k = f+1 then halt 9: else if k = f+1 10: deliver (SF) 11: halt Terminates in rounds How can we do better? Find a protocol whose round complexity is proportional to –the number of failures that actually o...	{ "page_id": null, "source": 7323, "title": "from dpo" }
then value := else value:= ? Process in round 2: send value to all 3: if delivered in round then halt 4: receive round values from all 5: { \| received no value from in round } 6: if received value ≠ ? then 7: value := 8: deliver value 9: if = sender then value := ? 10: else if or then 11: value := SF 12: deliver value ...	{ "page_id": null, "source": 7323, "title": "from dpo" }
p faulty (p, k ) := faulty (p, k − 1) ∪ faulty (p, k ) p # Validity Let be the set of processes that have failed to send a message to in any round 1: if = sender then value := else value:= ? Process in round 2: send value to all 3: if delivered in round then halt 4: receive round values from all 5: { \| received no valu...	{ "page_id": null, "source": 7323, "title": "from dpo" }
else if or then 11: value := SF 12: deliver value 13: if then halt k−1 1, . . . , k p m p k, 1 ≤ k ≤ f +1 k = f +1 \|faulty (p, k )\| < k k = f +1 v v k q p q k p faulty (p, k ) := faulty (p, k − 1) ∪ faulty (p, k ) pAgreement - 1 Lemma 1 : For any , if a process delivers ≠ SF in round r, then there exists a sequence of ...	{ "page_id": null, "source": 7323, "title": "from dpo" }
received value ≠ ? then 7: value := 8: deliver value 9: if = sender then value := ? 10: else if or then 11: value := SF 12: deliver value 13: if then halt k−1 1, . . . , k p m p k, 1 ≤ k ≤ f +1 k = f +1 \|faulty (p, k )\| < k k = f +1 v v k q p q k p faulty (p, k ) := faulty (p, k − 1) ∪ faulty (p, k ) p # Agreement - 2 ...	{ "page_id": null, "source": 7323, "title": "from dpo" }
receive from process in round must conclude that are all faulty processes But then, CONTRADICTION p0, . . . , p r qj , . . . , q r \|faulty (qj , j )\| ≥ j p0, . . . , p j−1 pk−1 qj qj mp q Lemma 3: It is impossible for and , not necessarily correct or distinct, to set value in the same round to and SF, respectively qp m...	{ "page_id": null, "source": 7323, "title": "from dpo" }
? then 7: value := 8: deliver value 9: if = sender then value := ? 10: else if or then 11: value := SF 12: deliver value 13: if then halt k−1 1, . . . , k p m p k, 1 ≤ k ≤ f +1 k = f +1 \|faulty (p, k )\| < k k = f +1 v v k q p q k p faulty (p, k ) := faulty (p, k − 1) ∪ faulty (p, k ) pAgreement - 3 Let be the earliest ...	{ "page_id": null, "source": 7323, "title": "from dpo" }
k ≤ f +1 k = f +1 \|faulty (p, k )\| < k k = f +1 v v k q p q k p faulty (p, k ) := faulty (p, k − 1) ∪ faulty (p, k ) p r+1  f +1 r+1  f +1 r  f r = f +1 p0, ..., p f +1 p0, ..., p f p0, ..., p f pc c+1 , p c c < r f +1 = pr f +1 f r r # Integrity Let be the set of processes that have failed to send a message to in a...	{ "page_id": null, "source": 7323, "title": "from dpo" }
value:= ? Process in round 2: send value to all 3: if delivered in round then halt 4: receive round values from all 5: { \| received no value from in round } 6: if received value ≠ ? then 7: value := 8: deliver value 9: if = sender then value := ? 10: else if or then 11: value := SF 12: deliver value 13: if then halt k−...	{ "page_id": null, "source": 7323, "title": "from dpo" }
to with respect to , denoted if α1 α2 pi α1 α2 α1 α2 pi α1 ∼pi α2 α1\|pi = α2\|pi # Similarity Definition Let and be two executions of consensus and let be a correct process in both and . is similar to with respect to , denoted if α1 α2 pi α1 α2 α1 α2 pi α1 ∼pi α2 α1\|pi = α2\|pi Note If then decides the same value in both...	{ "page_id": null, "source": 7323, "title": "from dpo" }
α2 pi α1 α2 α1 α2 pi α1 ∼pi α2 α1\|pi = α2\|pi Note If then decides the same value in both executions α1 ∼pi α2 pi Lemma If and is correct, then dec( ) = dec( ) α1 ∼pi α2 pi The transitive closure of is denoted . We say that if there exist executions such that α1 ∼pi α2 α1 ≈ α2 α1 ≈ α2 β1, β2, . . . , βk+1 α1 = β1 ∼pi1 β...	{ "page_id": null, "source": 7323, "title": "from dpo" }
a set of executions where as follows: is obtained from after removing the messages that sends to the -th highest numbered processors (excluding itself) # αi αi αi j 0 ≤ j ≤ n−1 αi j αi pi j # The executions > p0 > pi−1 > pi+1 > pi > pn−1 > 1 > 0 > 0 > 0 > 1 αi > 0 > p0 > pi−1 > pi+1 > pi > pn−1 > 1 > 0 > 0 > 0 > 1 αi >...	{ "page_id": null, "source": 7323, "title": "from dpo" }
1 0 0 0 1 αi αi n−1 p0 pi−1 pi+1 pi pn−1 1 1 0 0 1 ≈ > ≈ βi 0 αi+1 > ≈ # Indistinguishability p0 pi−1 pi+1 pi pn−1 1 0 0 0 1 αi p0 pi−1 pi+1 pi pn−1 1 1 0 0 1 ≈ αi+1	{ "page_id": null, "source": 7323, "title": "from dpo" }
Title: Consensus using omega in asynchronous systems with unknown membership and degenerative Byzantine failures URL Source: Markdown Content: Typesetting math: 100% Skip to main content Skip to article Journals & Books View PDF Download full issue Outline Abstract Keywords 1. Introduction 2. The asynchronous system S...	{ "page_id": null, "source": 7323, "title": "from dpo" }
system with degenerative Byzantine failures. Previous article Next article Keywords Distributed algorithmsConsensusUnknown membershipOmega failure detectorByzantine failures 1. Introduction Consensus is a fundamental agreement problem present, as a building block, at the core of most reliable systems. Consensus states...	{ "page_id": null, "source": 7323, "title": "from dpo" }
is one of these 8 original classes). In a follow-up work, Chandra, Hadzilacos and Toueg proposed Ω as a new class of failure detectors. The Ω failure detector class guarantees that, eventually, the failure detectors of all correct processes permanently return the same correct process. It is shown in that Ω is the wea...	{ "page_id": null, "source": 7323, "title": "from dpo" }
each other because, since they do not crash, they can permanently send messages that eventually and periodically will be received by the other. Conversely, a process which crashes before sending any message will be unknown to every other process in the system. Another failure model very well studied in the literature i...	{ "page_id": null, "source": 7323, "title": "from dpo" }
that every correct process p eventually suspects all processes that are mute to p with respect to 𝐴 . A process p is mute with respect to 𝐴 if p eventually stops sending 𝐴 's messages to at least one process in the system. Consensus is solved in introducing another muteness failure detector class called ◇ ◇ 𝑃 mute...	{ "page_id": null, "source": 7323, "title": "from dpo" }
to be executed in a pure asynchronous system augmented with this failure detector FD , , , , . Note that all previously presented failure detector classes ( ◇ ◇ 𝑃 mute , ◇ ◇ 𝑀 𝐴 , ◇ ◇ 𝑆 ( bz ) and ◇ ◇ 𝑊 ( Byz ) ) cannot be implemented when the membership is unknown because every correct process needs to know every...	{ "page_id": null, "source": 7323, "title": "from dpo" }
mobile ad-hoc networks, sensor networks, etc.). This implies that every process in our system with unknown membership has to dynamically learn about the existence of other processes. Roughly speaking, a process can infer the identity of other processes from the messages it receives during the run. An important handicap...	{ "page_id": null, "source": 7323, "title": "from dpo" }
and maintenance of algorithms because we can focus on the properties to be fulfilled in a certain abstraction based only on the properties supplied by the other , , . So, in our model (as in ) we can interchange different algorithms of the Ω failure detector class with different algorithms of consensus that use Ω witho...	{ "page_id": null, "source": 7323, "title": "from dpo" }
a mute process. Finally, a process can be alive and neither send nor receive messages. In this case we call it an autistic process. Note that mute and autistic processes are difficult to detect by an outside unit. If they never send a message, they are undetectable in a system with unknown membership. Besides, in an as...	{ "page_id": null, "source": 7323, "title": "from dpo" }
introduction of this RFLOB primitive is to simplify the design and understanding of our consensus algorithm. Note that, in the literature, there are several implementations of broadcast primitives with different properties of reliability in systems with Byzantine processes , , , , , , but, to our knowledge, there is n...	{ "page_id": null, "source": 7323, "title": "from dpo" }
which are the minimum connectivity requirements necessary to implement any failure detector of Class Ω. Thus, we show that Consensus is implementable using Ω and RFLOB in a system with degenerative Byzantine failures even with unknown membership. 1.2. Structure of the rest of the paper This paper is organized as follow...	{ "page_id": null, "source": 7323, "title": "from dpo" }
each process 𝑝 𝑖 only knows its own identity (i.e., i) and the size n, but it does not know the identities of the other processes in the system. The only way a process has to infer the identities of other processes is from the messages it receives. Processes communicate by sending and receiving messages through links...	{ "page_id": null, "source": 7323, "title": "from dpo" }
< 𝑛 / 3 processes can be faulty. We consider the following three types of failures. • Crash A process 𝑝 𝑖 ∈ Π is denoted crashed if 𝑝 𝑖 always executes every operation specified by its algorithm until 𝑝 𝑖 eventually fails by crashing permanently (i.e., 𝑝 𝑖 stops taking steps forever). The set of crashed proce...	{ "page_id": null, "source": 7323, "title": "from dpo" }
and receiving operations, so Crashed ⊆ Autistic . Note also that a crashed process is also a mortal Byzantine. However, since not all autistic processes crash, Autistic ⊈ MortalByz , so Deaf ⊈ MortalByz and Mute ⊈ MortalByz . Thus, Faulty = MortalByz ∪ Deaf ∪ Mute . Hence, our failure model is broader than that of . No...	{ "page_id": null, "source": 7323, "title": "from dpo" }
𝑟 . We assume that each process 𝑝 𝑖 can identify the sender process 𝑝 𝑘 of every message m (this can be done, for example, using digital signatures included in the header of m). Hence, if a correct process 𝑝 𝑖 receives a message whose sender address does not correspond to the signature, it will consider that mes...	{ "page_id": null, "source": 7323, "title": "from dpo" }
cannot deviate from their specification except by crashing. Therefore, since our degenerative Byzantine system S also includes the benign crash failures of , this impossibility result holds for S. To circumvent this impossibility, failure detectors were introduced . A failure detector is a distributed device that retur...	{ "page_id": null, "source": 7323, "title": "from dpo" }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.