Split (1)

train · 617k rows

text stringlengths 2 132k	source dict
in humans: 46 (22 pairs of autosomes and two sex chromosomes) .deoxyribonucleic acid (DNA). The molecule contained within chromosomes which encodes the genes responsible for the structure and function of an organism and allows for transmission of genetic information from one generation to the next .dose rate. A measure of the rate at which energy is transferred from radiation to a target; the dose delivered per unit time. Although dose rate could, in principle, be defined over any unit of time (e.g. an annual dose is technically a dose rate), usually the term dose rate is used in the context of short periods of time, e.g. dose per second or dose per hour. > dosimeter, radiation. A physical device that measures exposure to ionizing radiation. > double strand break (DSB). Type of DNA damage; the DNA is cut completely due to scission of the phosphodiester backbone in both strands of the double helix at the same locus or nearby loci. > electron spin resonance (ESR)/electron paramagnetic resonance (EPR). Atechnique for studying chemical species that have one or more unpaired electrons, such as organic and inorganic free radicals or inorganic complexes possessing a transition metal ion. It can be used as a radiation dosimeter. > emergency*. A non-routine situation that necessitates prompt action, primarily to mitigate a hazard or adverse consequences for human health and safety, quality of life, property or the environment. This includes nuclear and radiological emergencies and conventional emergencies such as fires, release of hazardous chemicals, storms or earthquakes. It includes situations for which prompt action is warranted to mitigate the effects of a perceived hazard. nuclear or radiological emergency. An emergency in which there is, or is perceived to be, a hazard due to: (a) The energy resulting from a nuclear chain reaction or from the decay	{ "page_id": null, "source": 7334, "title": "from dpo" }
of the products of a chain reaction; or (b) Radiation exposure. • Points (a) and (b) approximately represent nuclear and radiological emergencies, respectively. However, this is not an exact distinction. • Radiation emergency is used in some cases when an explicit distinction in the nature of the hazard is immaterial (e.g. national radiation emergency plan), and it has essentially the same meaning. > enzyme. A protein molecule that catalyzes chemical reactions of other substances without itself being destroyed or altered upon completing the reactions. > epidemiology. The study of the distribution and determinants of health-related states or events in specified populations, and the application of this study to control of health problems. > exposure. The act or condition of being subject to irradiation. > 217 Exposure should not be used as a synonym for dose. Dose is a measure of the effects of exposure. • Exposure can be divided into categories according to its nature and duration (see exposure situations) or according to the source of the exposure, the people exposed and/or the circumstances under which they are exposed (see exposure, types of). > external exposure. Exposure to radiation from a source outside the body. • Contrasted with internal exposure. > internal exposure. Exposure to radiation from a source within the body. • Contrasted with external exposure. > exposure situations. > acute exposure. Exposure received within a short period of time. Normally used to refer to exposure of sufficiently short duration that the resulting doses can be treated as instantaneous (e.g. less than an hour). > chronic exposure. Exposure persisting in time. The adjective ‘chronic’ relates only to the duration of exposure, and does not imply anything about the magnitude of the doses involved. Normally used to refer to exposures persisting for many years as a result of long lived	{ "page_id": null, "source": 7334, "title": "from dpo" }
radionuclides in the environment. The International Commission on Radiological Protection uses the term prolonged exposure to describe the same concept as chronic exposure. Both terms are contrasted with acute exposure. > false negative. A test result which indicates that an individual is unaffected when he or she is actually affected; i.e. a negative test result in an affected individual. > false positive. A test result which indicates that an individual is affected when he or she is actually unaffected; i.e. a positive test result in a truly unaffected individual. > fast neutrons. Neutrons, the energy of which exceeds some arbitrary level, usually around 1 MeV. > first responders*. The first members of an emergency service to respond at the scene of an emergency. > fission neutrons. Free neutrons, usually produced during nuclear fission, a nuclear reaction in which a heavy nucleus of an atom splits into two approximately equal parts (nuclei of lighter elements), accompanied by the release of a relatively large amount of energy. > fluorescent in situ hybridization (FISH). A technique used to identify the presence of specific chromosomes or chromosomal regions through attachment of fluorescently-labelled DNA probes to denatured chromosomal DNA. > interphase FISH. Probes are introduced directly to the interphase cell. This permits visualization of changes at the level of chromosomal domains. > 218 metaphase FISH. Probes are introduced to the chromosomes in metaphase. This permits visualization of chromosomal aberrations. FISH techniques: multicolour FISH (mFISH). mFISH utilizes ‘whole chromosome paint’ DNA probes which are labelled with a unique combination of fluorescent colours for each of the human chromosomes. pq-mFISH. A variant of mFISH whereby individual chromosome arms are discriminated. fluorochrome. Molecules that are fluorescent when appropriately excited. They are used for FISH cytogenetics to highlight specific chromosomal regions. gamma radiation. Electromagnetic radiation (photons) of high frequency	{ "page_id": null, "source": 7334, "title": "from dpo" }
(very short wavelength) emitted by the nucleus or from the particle decays or annihilation events. Gamma rays penetrate tissue farther than do beta particles or alpha particles, but have a lower linear energy transfer. Heavy materials such as lead or concrete must be used for shielding from gamma radiation. G-banding. See ‘chromosome banding’. genotoxin. Any chemical or physical agent that causes damage to or mutation of genetic material. G-function. A time dependent factor used to modify the dose squared coefficient of the linear quadratic dose response relationship to allow for the effects of dose protraction. gray (Gy). The SI unit of kerma and absorbed dose, equal to 1 J/kg. It replaced the rad. 1Gy = 100 rad. haematopoiesis. The formation of blood cellular components. half-life (T 1/2 ). (1) For a radionuclide, the time required for the activity to decrease, by a radioactive decay process, by half. • Where it is necessary to distinguish this from other half-lives (see (2)), the term radioactive half-life should be used. • The half-life is related to the decay constant, λ, by the expression: λ 2ln 2/1 =T (2) The time taken for the quantity of a specified material (e.g. a radionuclide) in a specified place to decrease by half as a result of any specified process or processes that follow similar exponential patterns to radioactive decay. biological half-life. The time taken for the quantity of a material in a specified tissue, organ or region of the body (or any other specified biota) to halve as a result of biological processes. 219 effective half-life (T eff ). The time taken for the activity of a radionuclide in a specified place to halve as a result of all relevant processes. # ∑= i ieff TT 11where: Ti is the half-life for process i. radioactive half-life.	{ "page_id": null, "source": 7334, "title": "from dpo" }
For a radionuclide, the time required for the activity to decrease, by a radioactive decay process, by half. • The term ‘physical half-life’ is also used for this concept. half-time. The time required for a parameter to fall 50% of its original value. For biological dosimetry application, this term is used to describe the turnover of peripheral blood lymphocytes. harlequin chromosome. A chromosome which has been differentially labelled and stained after uptake of BrdU during two cycles of replication. After appropriate staining one of the sister chromatids appears dark and the other appears light. incorporation. The intake of a radionuclide into the body by inhalation, ingestion or across intact or damaged skin. insertion. A chromosome abnormality in which an acentric piece of one chromosome has been inserted within an arm of another chromosome. inter-comparison exercise. A procedure, used for quality assurance and control. In biological dosimetry materials are exchanged between laboratories for comparative analysis. interphase. Period of a cell cycle between the mitotic divisions in which the cell spends most of its time and performs the majority of its functions such as preparation for cell division. inversion. A chromosomal rearrangement in which a segment of a chromosome has inverted from end to end, and reinserted into the chromosome at the same breakage site. It can be peri- or para-centric depending on whether the centromere is included or not, respectively. in vitro . Observed or performed in the test tube. in vivo . Observed or performed in the living organism. ionization. The physical process whereby one or more orbital electrons are ejected from an atom or molecule, converting them into an electrically charged state (an ion). The process produces a localized release of a large amount of energy, approximately 33eV per ionizing event, which is more than enough to break a	{ "page_id": null, "source": 7334, "title": "from dpo" }
strong chemical bond. isotope. Atoms of one and the same chemical elements with the same number of protons (same atomic number but different nuclear number) and electrons but 220 different number of neutrons. Isotopes are the same chemical but have different nucleonic characteristics. karyotype. Systematic arrangement of the homologous chromosomes pairs of a single cell based on size, centromere position and banding pattern according to a standard classification. kerma, air (kinetic energy released per unit ma ss). The quantity K, defined as: dm dE K tr = where: dE tr is the sum of the initial kinetic energies of all charged ionizing particles liberated by uncharged ionizing particles in a material of mass dm . • Unit: gray (Gy). • Originally an acronym for kinetic energy released in matter, but now accepted as a word. leukocyte. A generalized term describing all types of white blood cells. (e.g. lymphocytes, neutrophils, eosinophils, basophils, plasma cells and monocytes). linear energy transfer (LET) (L Δ). Defined generally as: > ΔΔ ⎟⎠⎞⎜⎝⎛= lddE L where: dE is the energy lost in traversing distance d l , and Δ is an upper bound on the energy transferred in any single collision. • A measure of how, as a function of distance, energy is transferred from radiation to the exposed matter. A high value of linear energy transfer indicates that energy is deposited within a small distance. • L∞ (i.e. with Δ = ∞) is termed the ‘unrestricted linear energy transfer’ in defining the quality factor. • LΔ is also known as the ‘restricted linear collision stopping power’. linear model. Common mathematical model used to describe the biological response to radiation, in which the effect Y is a linear function of dose D: Y = αD. linear quadratic model. Common mathematical model used to describe the biological	{ "page_id": null, "source": 7334, "title": "from dpo" }
response to radiation, in which the effect Y is a linear-quadratic function of dose D: Y = αD + βD2. 221 lymphocyte. A type of white blood cell mainly found in the blood, lymph, and lymphatic tissues that forms the body's immunologically competent cells and their precursors. meta-analysis. Studies where the results of similar, independent investigations on a certain topic are pooled, summarized, and evaluated according to certain parameters. metaphase. Stage of mitosis in the eukaryotic cell cycle in which chromosomes are condensed to their minimum length and align in the middle of the cell before being separated into each of the two daughter cells. micronucleus (MN). A micronucleus is an additional small nucleus found in cells with chromosomal damage. A MN typically originates from a lagging whole chromosome or acentric chromosome fragment at anaphase. The diameter of an MN is usually 1/16 th to 1/3 rd of that of the main nuclei in a mononucleated or binucleated cell. MN have the same texture and staining properties of nuclei. mitogen. Reagent inducing cell proliferation. mitosis. The part of the cell division process in which a eukaryotic cell separates its chromosomes into two identical sets. mitotic index. Percentage of cells in mitosis at any given time. mutagen. Any chemical or physical agent with the property of inducing genetic mutation at the base sequence of the DNA molecule or at the chromosomal level of organization. mutation. Any alteration in a gene from its natural state; may be disease-causing or a benign, normal variant. neutron radiation. Neutrons, one of the components of the atomic nucleus, are electrically neutral elementary particles. They are particularly released during nuclear fission and have a high penetration capacity. nuclear bud. Micronucleus-like bodies attached to the nucleus by a thin nucleoplasmic connection; nuclear abnormality. nuclear division index (NDI). A	{ "page_id": null, "source": 7334, "title": "from dpo" }
measure of the average speed of cell cycling which is taken from the relative number of cells in a population which has reached each successive stage of division, normally to fourth division. nucleoplasmic bridge (NPB). Occurs when the centromeres of dicentric chromosomes or chromatids are pulled to the opposite poles of the cell at anaphase. In the CBMN assay, binucleated cells with NPB can be observed because cytokinesis is inhibited, preventing breakage of the anaphase bridges from which nucleoplasmic bridges are derived. nucleosome. These structures form the fundamental repeating units in the packaging of eukaryotic chromatin within the chromosome. nuclide. Type of atom characterized by proton number (atomic number) and nuclear number. 222 odds ratio. The ratio of two odds, calculated to show the likelihood of zero dose versus a suspected (e.g. badge) or a physical measurement of dose. > OSL dosimeter (optically stimulated luminescence). Type of physical dosimeter which is used to measure exposure to ionizing radiation. > PAINT (Protocol for Aberration Identification and Nomenclature Terminology). Terminology used in FISH analysis for describing chromosomal aberrations. > pan-centromeric probe. DNA probes labelling the centromeric region of each chromosome. > phantom. A device which absorbs and scatters γ- and X-radiation in approximately the same way as the tissues of the body. (e.g. for dosimetry measurements or irradiation of blood samples needed to generate a dose-response calibration curve). > polymerase chain reaction (PCR). A procedure that enzymatically amplifies a DNA sequence through repeated replication by DNA polymerase. > Qdr method. A mathematical analysis of centric ring and dicentric chromosome frequencies which permits dose assessment in cases of suspected partial body exposures. The method permits dose assessment by considering the distribution of dicentrics and rings among just the damaged cells. See also contaminated Poisson method. > Qpcc method. A mathematical analysis identical to	{ "page_id": null, "source": 7334, "title": "from dpo" }
Qdr (above) but based instead on the distribution of prematurely condensed chromosome fragments. > relative biological effectiveness (RBE). A relative measure of the effectiveness of different radiation types at inducing a specified health effect, expressed as the inverse ratio of the absorbed doses of two different radiation types that would produce the same degree of a defined biological end point. > ring, centric/acentric. Aberrant circular chromosome containing/lacking acentromere that has resulted from the joining of two breaks within one chromosome. > röntgen (R). Unit of exposure, equal to 2.58 × 10–4 C/kg (exactly). • Superseded by the SI unit C/kg. > service laboratory. The term refers in the context of this publication to a specialized laboratory dedicated to the performance of biological dosimetry measurements. > sievert (Sv)*. The SI unit of equivalent dose and effective dose, equal to 1 J/kg. > significance , statistical. One talks about statistical significance if a result of a given experiment or study clearly deviates from the expected result. The statistical significance of a result of a given experiment or study is an estimated measure of the degree to which it is ‘true’, i.e. caused by something other than just chance. In general, a deviation between observed and expected results is considered to be significant if this error probability is less than 5 %. > single strand break (SSB). Type of DNA damage in which the DNA is broken only across one strand of the double helix. > 223 sparsely-ionizing/low-LET ionizing radiation. See ‘densely-ionizing/high-LET’ and ‘linear energy transfer’. > stable aberration. A non-lethal chromosomal rearrangement or exchange between or within chromosomes without loss of genetic material during mitosis. > stable cell. Cell without unstable aberrations. It may be entirely undamaged or it may contain stable type aberrations only. > standard deviation (SD). A quantitative measure	{ "page_id": null, "source": 7334, "title": "from dpo" }
of the amount of variation in a sample of measurements from a population, giving an indication of how widely spread are the values in a data set. For data that approximate to a Normal distribution, the standard deviation of a curve parameter indicates how far it is likely to deviate from the true value, which can be ideally thought of as given by the mean of a large population of calibration donors (or experiments) based on large numbers of cells for each one. See also covariance. > standard error of the mean (SEM). A quantitative measure of the amount of variation in a sample of measurements from an approximately Normal population, giving an indication of how far the sample mean is likely to deviate from the true population mean, thus quantifying how accurately the true mean of the population is known. > stochastic effect (of radiation). A radiation induced health effect, the probability of occurrence of which is greater for a higher radiation dose and the severity of which (if it occurs) is independent of dose. Stochastic effects may be somatic effects or hereditary effects, and generally occur without a threshold level of dose. Examples include thyroid cancer and leukaemia. > synchronization. When applied to cell culturing, the process refers to manipulating cells into the same stage of the cell cycle. > telomere. The end of each chromosome arm which consists of tandem repeat TTAGGG sequences that protect against chromosome fusions and formation of dicentric chromosomes. Telomere sequences may be lost with each DNA replication cycle or microdeletions in the sequence. > TLD dosimeter (thermoluminescent). Type of physical dosimeter which is used to measure exposure to ionizing radiation. > translocation. A chromosome alteration in which a whole chromosome or segment of a chromosome becomes attached to or interchanged with another	{ "page_id": null, "source": 7334, "title": "from dpo" }
whole chromosome or segment, the resulting hybrid segregating together at meiosis. > reciprocal translocation (2-way or complete translocation). The exchange of terminal portions of two separate chromosomes. > non-reciprocal translocation (1-way or incomplete translocation). Translocation of a single chromosome segment; no reciprocal exchange. > triage. A process of prioritizing patients based on the severity of their condition. Cytogenetic triage is the use of biological dosimetry results to support medical decisions. > tricentric. Aberrant chromosome bearing three centromeres derived from the joining of parts from three broken chromosomes. For calculation purposes they are > 224 considered as equivalent to two dicentrics and are accompanied by two acentric fragments. > tritiated water. A form of water where the usual hydrogen atoms are replaced with tritium, a radioactive isotope of hydrogen. > unstable aberration. A chromosomal rearrangement in a cell that can be lethal to itself or its daughter cells because it leads to loss of genetic material or unbalanced transmission of genetic material during mitosis. > unstable cell. Cell with an unstable aberration such as a dicentric, ring or acentric fragment. > variance . A statistical measure of distance of values from a central value, calculated as the square of the standard deviation. > X-radiation. S hort-wave electromagnetic radiation (photons) emitted by electrons either in orbitals outside of the nucleus, or while being accelerated to produce Bremsstrahlung-type radiation. They are shorter in wavelength than UV rays and longer than gamma rays. Heavy materials such as lead must be used for shielding from X-rays. > 225 CONTRIBUTORS TO DRAFTING AND REVIEW Ainsbury, E. Health Protection Agency, United Kingdom Barquinero, J.F. Universidad Autónoma de Barcelona, Spain Beinke, C. Bundeswehr Institute of Radiobiology, Germany Blakely, W.F. Armed Forces Radiobiology Research Institute, United States of America Braselmann, H. Helmholz Zentrum, Germany Buglova, E. International Atomic Energy	{ "page_id": null, "source": 7334, "title": "from dpo" }
Agency (IAEA) Carr, Z. World Health Organization (WHO) Di Giorgio, M. Autoridad Regulatoria Nuclear, Argentina Fenech, M. Commonwealth Scientific and Industrial Research Organisation (CSIRO), Australia Garcia Lima, O. Center for Hygiene and Radiation Protection, Cuba Kodama, Y. Radiation Effects Research Foundation, Japan Lindholm, C. Radiation and Nuclear Safety Authority (STUK), Finland Livingston, G. Oak Ridge Associated Universities (ORAU), United States of America Lloyd, D.C. Consultant, United Kingdom Maznyk, N.A. Institute for Medical Radiology of ANSU, Ukraine Prasanna, P.G.S. National Institutes of Health, United States of America Previsani, N. World Health Organization (WHO) Romm, H. Bundesamt für Strahlenschutz (BfS), Germany Roy, L. Institut de Radioprotection et de Sûreté Nucléaire (IRSN), France Voisin, P.J. Institut de Radioprotection et de Sûreté Nucléaire (IRSN), France Vral, A. Ghent University, Belgium Wilkins, R.C. Health Canada, Canada Yoshida, M. Hirosaki University, Japan > 227 ACKNOWLEDGEMENTS OF COMMENTS RECEIVED Azizova, T. Southern Urals Biophysics Institute, Russian Federation Barrios, L. Autonomous University of Barcelona, Spain Bognár, G. National Research Institute for Radiobilogy and Radiohygiene, Hungary Darroudi, F. Leiden University Medical Centre, Netherlands Devantier, Y, Chalk River Laboratories, Canada Espinoza Zevallos, M. Instituto Peruano de Energía Nuclear, Peru Guerrero Carbajal, Y.C. Instituto Nacional de Investigaciones Nucleares, Mexico Güçlü, I. Çekmece Nuclear Research and Training Centre (ÇNAEM), Turkey Hayata, I. Consultant, Japan Martínez-López , W. Instituto de Investigaciones Biológicas Clemente Estable, Uruguay Natarajan, A.T. University of Tuscia, Italy Oliveira, M. Instituto de Radioproteção e Dosimetria, Brasil Palitti, F. University of Tuscia, Italy Pantelias, G. Institute of Radioisotopes and Radiodiagnostics, National Centre for Scientific Research “Demokritos”, Greece Sasaki, M.S. Kyoto University, Japan Sotnik, N. Southern Urals Biophysics Institute, Russian Federation Turai, I. National Research Institute for Radiobiology and Radiohygiene, Hungary Valdivia Pottstock, P. Chilean Nuclear Energy Commission, Chile Vozilova, A. Urals Research Centre for Radiation Medicine (URCRM), Russian Federation Wilkinson, D.	{ "page_id": null, "source": 7334, "title": "from dpo" }
Defence and Research Development Canada, Canada > 229 # @ !" # $ %&'( ) +!,-.-/ + 01%.-2/.3444456 701%.-2/.344'' 0$ 8 5( 0 099 ! " # : ; $) /3/-'&-3'56 701-//>-'3'&. 0 8 5( 0 099 == $% 3.6=-&>456 70.='33='%>=-&>3 0 8 5( 0 099 ) ?! ; .=>-%2! ) " " @.:2:- + 01%.-4&>/%%>56 701%.-4&>4%%3 0 8 5( 0 099 $& ! 0! ? ! + " -%&56 701&/3/'&'/.%&% 0 8 B5( 0 099 B ) % @ "'2./.&.56 701->'2./.&&>3 0 8 5( 0 099 ) $ 6= >: " 6=4>2/. !7.2 + 01--.&/3.&2&256 701--.&/3.2323 0 8 5( 0 099 ; $ .&> $ ?2&/-%! !7 + 01--.&4&3%43/56 71--.&4&3%43/ 0 $ 8 $ 5( 0 099 $ " #* "=F ?F =F ?G,,? .3#=>-..-< + 01&2//'2&23/356 701&2//'2&23/31&2//'2&23/// 0	{ "page_id": null, "source": 7334, "title": "from dpo" }
?8=$ ? 5( 0 099 =$ ? & " * ; ; %4444456 701-%./>44&4/5 08 % G. 6 # ,.>: , * ?4/%&56 7012.../-/'.-.> 0 8$ * ; # ; &>>/&'2>&>%/56 701-23/&'2>&>&' 0 8 5( 0 +( * B! ; .-=% - !=+.3-=33/4 + 01'.--/4>'>'/56 701'.--/4>234/ 0 8 B 5( 0 099 B ( ! $,)-, @ =.J ?: =? !=G .-4=.-3 + 013/>'2.4&356 7013/>'2.4&%5( 0 099 & % #; 4&333&56 701-.D3E>->4/2/2% 08 5( 0 099 * @ >3 " -/433!AA + 01-.42-%'&&3356 701-.42-%.>%2' 0 8 5( 0 099 A ? $ " /&->...56 701-./>/&.>''' 0 8 5( 0 099 ' % # $ %&'( ) +!,-.-/ + 01%.-2/.3444456 701%.-2/.344'' 0$ 8 5( 0 099 ,. ! $ A B @ $ / =.>./; + 01-'%.&-/-.&&56 701-'%./-3.&-> 0 8 $ =B 5( 0 099 $	{ "page_id": null, "source": 7334, "title": "from dpo" }
=B 9$B ( #K B 9: 4>>>%- 0 8 B 8 B 8 B 8 B ( 0 099 B %- "%,# + " ; ? ">>/5DL E01&&/34'4-'-4/56 701&&/34'4-'/3- DE0 8 5DL E0 L 8 5( 0 099 "= #;+ / M 0 8 5( 0 099 -6 $ &% J J .33.4 D E+ 01'33/>-=2%&%1/./2%-='-3/56 701/./2%-=-&'2 0 8 ?5( 0 099 ? % ,)# $ 3.6=-&>456 70.='33='%>=-&>3 0 8 N( 0 099 ) ?! ; './ $ "?? J.-%%2 + 01'''>>.4&43D =E56 701'''>%''>&%D =E 0 8 5( 0 099 , / 0 0 # 1 2 0 3 3 F ! "/2D//>-3E 5 6 701&-./%33/2-3/ 0 8 ? 5 ( 0 099 ?9 11-32071 i n t	{ "page_id": null, "source": 7334, "title": "from dpo" }
E R n At i o n A l At o m i C E n E R g y A g E n C y V i E n n A E P R - b i o D o S i m E t R y2 0 1 1	{ "page_id": null, "source": 7334, "title": "from dpo" }
Title: Gun Evidence Boxes 14 3/4 inch x 7 7/8 inch x 2 1/4 inch (Set of 25) URL Source: Markdown Content: Gun Evidence Boxes 14 3/4 inch x 7 7/8 inch x 2 1/4 inch (Set of 25) \| Evidence Boxes \| Forensic Supplies \| Sirchie =============== The store will not work correctly in the case when cookies are disabled. * [About Us]( * [Support]( * [Privacy Policy]( * Contact us at +1 919-554-2244 or 1-800-356-7311 [Skip to Content]( * [Sign In]( * [Create an Account]( Toggle Nav[![Image 3]( [My Cart]( My Cart CloseYou have no items in your shopping cart. Search Search [Advanced Search]( Search [Menu]( * [Forensics]( * [Latent Print Development]( * [Regular Powders & Brushes]( * [DNA-Free Latent Print Processing]( * [Latent Print Kits]( * [Magnetic Powders & Applicators]( * [Chemical Latent Development]( * [Latent Print Lifting & Backing]( * [Fuming Chambers]( * [RUVIS Systems]( * [RUVIS Kits]( * [KRIMESITE Capture Systems]( * [RUVIS Accessories]( * [Shortwave UV Lights & UV Protection]( * [Alternate Light Sources]( * [Multi-Wavelength ALS Systems]( * [Bluemaxx Systems]( * [ALS Accessory Products]( * [Longwave UV Lights]( * [Dual Wavelength UV Lights]( * [Shortwave UV Lights]( * [Fire & Arson Investigation]( * [Fire & Arson Evidence Collection Tools & Kits]( * [Fire & Arson Evidence Packaging]( * [Fire Scene Evidence Marking]( * [Fire Scene Security]( * [Personal Protection]( * [Scene Lighting]( * [Scene Documentation]( * [Casting & Impression Recovery]( * [Personal Protection]( * [Respirator Masks]( * [Facial Protection]( * [Jumpsuits & Coveralls]( * [Protective Clothing Kits]( * [Shoe Covers]( * [Gloves]( * [Biohazard Protection]( * [Cleaners & Sanitizers]( * [First Aid Products]( * [Crime Scene Documentation & Photography]( * [Crime Scene Security]( * [Crime Scene Lighting]( * [Forensic Measurement]( * [Evidence Marking]( * [Crime Scene Sketching]( * [Ballistics Investigation]( * [Evidence	{ "page_id": null, "source": 7336, "title": "from dpo" }
Photography]( * [Mugshot Photography]( * [All-Weather Writing Products]( * [Physiological Specimen/DNA Collection]( * [Sexual Assault Kits]( * [DNA Specimen Collection Kits]( * [Blood and Urine Collection Kits]( * [Applicator Swabs & Accessories]( * [Blood Collection Tubes & Accessories]( * [DNA-Free Specimen Collection]( * [Presumptive Bodily Fluid Identification]( * [Blood Search, ID & Enhancement]( * [Presumptive Blood Search]( * [Presumptive Blood ID]( * [Blood Evidence Enhancement]( * [Blood Evidence Documentation]( * [Narcotics Investigation]( * [NARK Training]( * [NARKsafe Safety Products]( * [NARK II Presumptive Narcotics Test Pouches]( * [Presumptive Field Kits]( * [NARK II Cocaine ID Swipes]( * [Narcotics Field Test Tubes]( * [Fentanyl & Heroin Identification]( * [Tire, Tool, Footwear Casting & Impressions]( * [Liquid Silicone Casting]( * [Plaster Casting]( * [Shake-N-Cast Casting]( * [Dental Stone Casting Materials]( * [Tire and Footprint Casting Support Products]( * [Dust Print Lifting and Comparison]( * [Toolmark Casting]( * [Casting Kits]( * [Magnifiers & Comparators]( * [Fingerprint Magnifiers]( * [Fingerprint Magnifier Accessories]( * [Illuminated Magnifiers]( * [Misc Magnifiers]( * [Comparators]( * [Regula Magnifiers]( * [Fingerprint Taking]( * [Ink Pads]( * [Palm Printing]( * [Ink Rollers]( * [Fingerprint Ink]( * [Ink Slabs]( * [Ridge Enhancement]( * [Cardholders]( * [Fingerprint Cards]( * [Elimination Printing]( * [Training Materials]( * [Portable Fingerprint Taking]( * [Tabletop Fingerprint Taking]( * [Pedestal Fingeprinting Units]( * [Cleaners]( * [Postmortem Printing]( * [Theft & Fraud Detection]( * [Fluorescent UV Marking]( * [Visible Stain Detection]( * [Questioned Document Analysis]( * [Laboratory Equipment & Supplies]( * [Hot Plates]( * [Stirrers]( * [Bench Rockers]( * [Balances & Scales]( * [Centrifuges]( * [Nalgene Bottles & Jars]( * [Scene Lighting and Flashlights]( * [Gun Shot Residue, Serial Number Restoration, Trace Metals]( * [Gunshot/Explosive Residue Detection]( * [Serial Number Restoration]( * [Evidence Collection Tools & Kits]( * [Evidence Collection Tools]( * [Vacuums/Microparticle Collection]( * [Metal Detection]( * [Evidence Collection	{ "page_id": null, "source": 7336, "title": "from dpo" }
Kits]( * [Arson Evidence Collection]( * [Evidence Packaging, Labeling & Sealing]( * [Evidence Collection Bags & Pouches]( * [Evidence Envelopes]( * [Evidence Boxes]( * [Evidence Collection Containers]( * [Evidence Integrity Tape & Strips]( * [Evidence Identification Labels]( * [Evidence Rule & Label Tape]( * [Evidence Tags]( * [Evidence Lockers]( * [Drying Cabinets, Fuming Chambers, & Workstations]( * [DrySafe Evidence Drying Cabinets]( * [DrySafe Filters & Accessories]( * [CyanoSafe Cyanoacrylate Fuming Chambers]( * [CyanoSafe Filters & Accessories]( * [Latent Print & Downdraft Dusting Stations]( * [Dusting Station Filters & Accessories]( * [Forensic Workstations]( * [Forensic Workstation Filters & Accessories]( * [Close-Out Products]( * [Vehicles]( * [Training]( * [Forensic Investigation & Photography]( * [Bloodstain Pattern Documentation]( * [Introduction to the Science of Fingerprints]( * [Basic Latent Fingerprint Comparison]( * [Advanced Latent Print Ridgeology]( * [Advanced Latent Palm Print Comparison]( * [Mastering the IAI Latent Print Exam]( * [Comprehensive Advanced Latent Print Comparison]( * [Firearms, Ballistics and Shooting Reconstruction]( * [Clandestine Grave Recovery]( * [Forensic Training for Education - Build Your Curriculum]( * [Sirchie Regional Hosted Training]( * [NARK Training]( * [Courtroom Presentation of Forensic Evidence]( * [Property & Evidence Management]( * [Virtual Classes]( * [Search and Rescue]( * [Upcoming Training]( * [Riot and Crowd Control]( * [TacCommander]( * [Premier Helmets]( * [Body Shields]( * [Body Shield Accessories and Parts]( * [906 Series Riot Helmet and Accessories]( * [900LT Series Riot Helmet and Accessories]( * [JCR100 Series Riot Helmet and Accessories]( * [Premier Riot & Crowd Control Gear]( * [Gloves]( * [First Aid Kits]( * [Area/Crowd Control Lighting]( * [Perimeter Security]( * [Support Products]( * [Live Scan]( * [Digital Forensics]( * [Faraday Protection]( * [Electrostatic Dissipation]( * [Mobile Device Forensics]( * [Search and Rescue Response]( * [Search and Rescue Training]( * [Search and Rescue Response Kits]( * [First Aid Kits]( * [Personal Protection	{ "page_id": null, "source": 7336, "title": "from dpo" }
Equipment (PPE)]( * Gloves * Gun Evidence Boxes 14 3/4 inch x 7 7/8 inch x 2 1/4 inch (Set of 25) Gun Evidence Boxes 14 3/4 inch x 7 7/8 inch x 2 1/4 inch (Set of 25) ==================================================================== $49.57 SKU ECB001G Quantity Add to Cart Add to Wish List]( !Image 5: Gun Evidence Boxes 14 3/4 inch x 7 7/8 inch x 2 1/4 inch (Set of 25)]( !Image 7: Gun Evidence Boxes 14 3/4 inch x 7 7/8 inch x 2 1/4 inch (Set of 25)]( !Image 9: Gun Evidence Boxes 14 3/4 inch x 7 7/8 inch x 2 1/4 inch (Set of 25) for storing pistols and handguns. Boxes are pre-printed on the outside for recording necessary chain of	{ "page_id": null, "source": 7336, "title": "from dpo" }
custody and identification information. Holes located in the bottom panel of the box are used to fasten the weapon in place with SIRCHIE's No. ET100 releasable evidence ties. _Shipped flat in sets of 25 each._ Related Products 1. ![Image 10: image]( "Evidence Collection Box 10 3/8 inch x 6 3/8 inch x 4 1/2 inch (Set of 40)")SKU ECB004 $55.34 Add to Cart 2. ![Image 11: Use Sirchie No. ET100 Evidence Ties to secure knife inside box]( "Knife Evidence Boxes 16 inch x 3 inch x 2 inch (Set of 25)")SKU ECB001K $40.98 Add to Cart 3. ![Image 12: image]( "Evidence/Records Box 24 inch x 12 inch x 10 inch (Set of 10)")SKU ECB008 $146.15 DISCONTINUED 4. ![Image 13: Spaces for evidence info and chain of custody printed on box top]( "Miscellaneous Evidence Boxes 14 3/4 inch x 7 7/8 inch x 2 1/4 inch (Set of 25)")SKU ECB001 $49.57 Add to Cart We found other products you might like! 1. ![Image 14: SM1000 Integrity TapeSKU SM1000 $13.27 Add to Cart 2. ![Image 15: Evidence Ties are sold in sets of 100 ea.SKU ET100 $22.24 Add to Cart Join Our Mailing List Be the first to know about new products and special offers. Get email updates from Sirchie. [Sign Up for Sirchie Emails]( ### INFORMATION * Contact us at +1 919-554-2244	{ "page_id": null, "source": 7336, "title": "from dpo" }
or1-800-356-7311 * [About Us]( * [Support]( * [GSA Schedule]( * [ISO 9001:2015 Certified]( * [Job/Career]( ### SHOPPING * [Shop by Category]( * [My Account]( * [View Cart]( * [My Wish Lists]( * [Order Status]( * [Privacy Policy]( * [Terms and Conditions]( [Contact Us]( Copyright © 2013-present Sirchie. All rights reserved. Close Checkout as a new customer Creating an account has many benefits: * See order and shipping status * Track order history * Check out faster [Create an Account]( Checkout using your account Email Address Password Sign In [Forgot Your Password?](	{ "page_id": null, "source": 7336, "title": "from dpo" }
Title: Invalid URL URL Source: Warning: Target URL returned error 400: Bad Request Markdown Content: The requested URL " is invalid. Reference #9.da83817.1749136939.798f946	{ "page_id": null, "source": 7336, "title": "from dpo" }
Title: Distributed Consensus with Process Failures URL Source: Markdown Content: _The following notes are based on the book ``Distributed Algorithms'' by Nancy A. Lynch (Morgan Kaufmann)_ ***************************************************************************** ### Distributed Consensus with Process Failures Failure Models: 1. stopping failure: process stops abruptly 2. Byzantine failure: process exhibits unconstrained behavior _V_ = set of valid initial values for processes Correctness condition for stopping failure model: 1. _Agreement:_ no two processes decide on different values. 2. _Validity:_ if all processes start with the same initial value _v (an element of V)_, then _v_ is the only possible decision value. 3. _Termination:_ all nonfaulty processes eventually decide. ### Conditions: Byzantine Failure Model 1. _Agreement:_ no two nonfaulty processes decide on different values. 2. _Validity:_ if all nonfaulty processes start with the same initial value _v (element of V)_, then _v_ is the only possible decision value for a nonfaulty process. 3. _Termination:_ all nonfaulty processes eventually decide. ### Stopping Failure Model: FloodSet Algorithm * _V_ = input set * _v 0 (element of V)_ = prespecified default value * _W (subset of V)_ = process _i_'s values (initial value at start time) * _f_ faulty processes * broadcast _W_ for each of _f+1_ rounds * add received sets to _W_ * if _\|W\| = 1_ after _f+1_ rounds: decide on _W_'s element * if _\|W\| > 1_: decide on _v 0_ ### Complexity Analysis: FloodSet * _f+1_ rounds * broadcast in each round * _O((f+1)n 2)_ messages * message size = _O(n)_ values * _b_ bits/value * communication bits = _O((f+1)n 3 b)_ ### OptFloodSet Algorithm * reduced communication overheads * _P i_ needs to know exact value of _W i_ iff _\|W i\| = 1_ * if _\|W i\| > 1_, _v 0_ is selected * broadcast initial value in round _1_	{ "page_id": null, "source": 7338, "title": "from dpo" }
* next broadcast (if necessary) at earliest round _r_ if _P i_ knows of a new value * at most two broadcasts per process * _2n 2_ messages, _O(n 2 b)_ comm. bits * alternative: if _V_ is totally ordered, _P i_ broadcasts smallest value seen so far * _O((f+1)n 2 b)_ communication bits ### Exponential Information Gathering (EIG) Lemma 6.11: After _f+1_ rounds of the EIGStop algorithm, the following hold: 1. _val( lambda)i_ is _i_'s input value. 2. If _xj_ is a node label and _val(xj)i = v, an element of V_, then _val(x)j = v_. 3. If _xj_ is a node label and _val(xj)i = null_, then either _val(x)j = null_ or else _j_ fails to send a message to _i_ at round _\|x\| + 1_. Lemma 6.12: After _f+1_ rounds of the EIGStop algorithm, the following hold: 1. If _y_ is a node label, _val(y)i = v, an element of V_, and _xj_ is a prefix of _y_, then _val(x)j = v_. 2. If _v, an element of V,_ appears in the set of _vals_ at any process, then _v = val(lambda)i_ for some _i_. 3. If _v element of V_ appears in the set of _vals_ at process _i_, then there is some label _y_ that does not contain _i_ such that _v = val(y)i_. Lemma 6.13: If processes _i_ and _j_ are both nonfaulty, then _W i = W j_. ### EIGStop: Complexity Analysis * Time complexity = _f+1_ rounds * Communication complexity: * number of messages = _O((f+1)n 2)_ * combined messages counted as one * number of bits = _O(n f+1 b)_ ### OptEIGStop: Optimization * process _i_ broadcasts at most two values * first broadcast = round _1_ * second broadcast = first round _r_ when _i_ receives value different from initial	{ "page_id": null, "source": 7338, "title": "from dpo" }
value * time = _f+1_ rounds * number of messages = _2n 2_ * number of bits = _O(n 2 (b + (f+1) log n))_ ### Byzantine Agreement with Authentication Assumptions: 1. processes able to authenticate their communications using digital signatures 2. a single source generates all initial values and signs them 3. faulty processes cannot forge signatures nonfaulty process: starts in initial state with a single input value signed by source faulty process: starts in some state with some set of input values signed by source EIGStop and OptEIGStop solve the agreement problems ### EIG Algorithm for Byzantine Agreement * _n > 3f_ * uses same EIG tree as EIGStop * process receiving ``ill-formed'' message corrects it * throws away received message containing: * garbage * duplicate values for same node in sending process * after _f+1_ rounds replace null tree values with _v 0_ * a process proceeds bottom-up in its tree * _newval(x)_ for node _x_ is set to: * _val(x)_, if _x_ = leaf node * strict majority of _newvals_ of _x_'s children, otherwise * _v 0,_ if no such majority exists * process _i_'s final decision = _newval(lambda)_ ### EIGByz Algorithm: Properties Lemma 6.15: After _f+1_ rounds of the EIGByz algorithm, the following holds. If _i_, _j_, and _k_ are all nonfaulty processes, with _i not equal to j_, then _val(x)i = val(x)j_ for every label _x_ ending in _k_. Lemma 6.16: After _f+1_ rounds of the EIGByz algorithm, the following holds. Suppose that _x_ is a label ending with the index of a nonfaulty process. Then there is a value _v, an element of V,_ such that _val(x)i = newval(x)i = v_ for all nonfaulty processes _i_. Lemma 6.17: If all nonfaulty processes begin with the same initial value _v, an element of V,_	{ "page_id": null, "source": 7338, "title": "from dpo" }
then _v_ is the only possible decision value for a nonfaulty process.	{ "page_id": null, "source": 7338, "title": "from dpo" }
Title: URL Source: Markdown Content: # Distributed Agreement with Optimal Communication Complexity # Seth Gilbert EPFL # seth.gilbert@epfl.ch # Dariusz R. Kowalski University of Liverpool # D.Kowalski@liverpool.ac.uk Abstract We consider the problem of fault-tolerant agreement in a crash-prone synchronous system. We present a new randomized consensus algorithm that achieves optimal communication efficiency, using only O(n) bits of com-munication, and terminates in (almost optimal) time O(log n), with high probability. The same protocol, with minor modifications, can also be used in partially synchronous networks, guaranteeing correct behavior even in asynchronous executions, while maintaining ef-ficient performance in synchronous executions. Finally, the same techniques also yield a randomized, fault-tolerant gossip protocol that terminates in O(log ∗ n)rounds using O(n) messages (with bit complexity that depends on the data being gossiped). 1 Introduction Fault-tolerant agreement , also known as consensus, is perhaps one of the most fundamental problems in distributed computing. The problem of consensus, first introduced in 1980 [25, 22], is formally defined as follows: Definition 1. (Consensus) Given n processes, at most t of which may crash: each process pi begins with initial value vi ∈ { 0, 1} and decides on an output sat-isfying: (1) Agreement: every process decides the same value; (2) Validity: if a process decides v, then v is some process’s initial value; (3) Termination: every correct process eventually decides, with probability 1. In this paper, we assume that the decision is binary; generalizations for any input value domain are straight-forward, though the communication cost scales with the size of the input values. The Question of Efficiency. In this paper, we ad-dress the question of how efficiently agreement can be achieved. There are two basic metrics: time complexity and communication complexity . Many existing proto-cols achieve optimal time complexity. For example, the FloodSet algorithm [12, 23] terminates	{ "page_id": null, "source": 7338, "title": "from dpo" }
in t+1 rounds, which is optimal for deterministic algorithms. Chor et al. develop a randomized algorithm that takes O(log n) rounds, with high probability, which is almost optimal (under an oblivious adversary); they also show a lower bound of Ω(log n/ log log n) rounds to achieve agreement, with high probability. Unfortunately, these protocols have relatively high communication complexity, as in each round, each pro-cess broadcasts a message to every other process, re-sulting in Θ( n2) messages per round. By contrast, solv-ing consensus requires at least Ω( n) bits of communi-cation, as every process needs to either send or receive one message. In fact, Amdur et al. showed that even in a failure-free execution, Ω( n) message complexity is needed. This leaves a significant gap between the upper and lower bounds. There has been significant progress in addressing this longstanding question (see Figure 1 for key results). Dwork et al. made an important breakthrough: a deterministic consensus protocol with O(n log n) mes-sage complexity and exponential time complexity. Galil et al. improved on this with an algorithm using O(n) messages and superlinear time O(n1+ ε), for any 0 < ε < 1. The best linear-time deterministic algo-rithm to-date is by Chlebus and Kowalski [6, 7], and has O(n log O(1) n) message complexity, but Ω( n2) com-munication complexity. Chlebus et al. have recently improved on this, developing a linear-time deterministic algorithm with O(n log 4 n) communication complexity. Chlebus and Kowalski have also recently devel-oped a new randomized algorithm that, with high prob-ability, takes O(log n) time and O(n log n) communica-tion complexity (subject to an oblivious adversary). A key novelty of this protocol is that it is local , i.e., no process sends more than O(log n) bits (using entirely different techniques than	{ "page_id": null, "source": 7338, "title": "from dpo" }
in this paper). Main Result. In this paper, we present the first con-sensus protocol to achieve both optimal communication complexity and almost optimal time complexity, while tolerating up to f < n/ 2 crash failures. Specifically, we present a randomized consensus protocol that, with high probability, has both O(n) communication complexity and O(log n) round complexity. 965 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. Surprisingly, our algorithm is, perhaps, simpler than many earlier algorithms, relying on the technique of universe reduction to eliminate much of the com-plexity while still achieving efficient performance. (See discussion below for earlier papers on universe reduc-tion.) Instead of solving consensus among all n nodes, which is potentially expensive, we delegate the work of agreement to Θ(log n) special coordinators , chosen at random. These coordinators then execute an existing consensus protocol, and distribute the results. Select-ing these coordinators, maintaining their consistency, and managing the data dissemination are the main chal-lenges that arise in implementing this approach: Coordinator discovery: Once the coordinators have been randomly selected, each must efficiently discover the others, without sending too many messages. (The trivial solution in which each of the Θ(log n) coordina-tors sends a message to every other process announcing its selection requires Θ( n log n) messages.) Moreover, there is some (perhaps small) probability that the dis-covery process fails, resulting in several disconnected cliques of coordinators. The discovery protocol is engi-neered to cope with these problems. Coordinator consistency: As the protocol proceeds, some of the coordinators may fail, by crashing. The protocol must maintain the consistency of the coordi-nators, ensuring that they have a similar (though not necessarily identical) view of the system as they progress through the protocol. Data dissemination: The coordinators must efficiently work together to disseminate the decision to the other processes.	{ "page_id": null, "source": 7338, "title": "from dpo" }
(Again, the trivial solution in which each co-ordinator sends the decision to every process requires Θ( n log n) messages.) In addition, some of the coor-dinators may fail during the protocol. We rely on a fault-tolerant work-sharing paradigm in which the co-ordinators repeatedly exchange information to prevent wasted work. The resulting simple randomized process takes only O(log ∗ n) rounds and O(n) messages to dis-seminate a piece of information. These challenges must be overcome with a minimum of communication. Since we are attempting to achieve O(n) communication complexity, messages must be kept to a minimum. For example, many consensus protocol rely on leader election; however, we cannot even afford to distribute the identity of a leader to every process in the system as that would require O(n) messages each of size log n bits. Secondary Results. A natural question is whether agreement can also be efficiently achieved in a partially synchronous network, i.e., a network that is almost al-ways synchronous, but occasionally suffers from unpre-dictable message delays. Previously , we showed how to transform protocols for synchronous systems into protocols for partially synchronous systems. A similar idea can be used here. Our techniques yield a protocol that achieves O(n) communication complexity when the network is synchronous, and yet still operates correctly even when the network is asynchronous. Another problem of significant recent interest in distributed computing is gossip : each process in the system starts with a rumor ; the goal, in the end, is for every process to learn every rumor. It is well-known that in a synchronous system, a simple randomized rumor-spreading process completes in O(log n) rounds with O(n log n) message complexity. In an important paper, Karp et al. studied a more intricate “push-pull” randomized process which achieves O(n log log n)message complexity in O(log	{ "page_id": null, "source": 7338, "title": "from dpo" }
n) rounds (and showed that among a certain class of algorithms, this was optimal). Using the universe reduction technique, along with the coordinator protocols described in this paper, we show how to achieve fault-tolerant gossip in a synchronous network in only O(log ∗ n) rounds, using only O(n) messages, with high probability 1. Other Related Work. There has been much im-portant research developing consensus protocols (and lower bounds) for other adversarial models, including asynchronous networks and networks subject to Byzan-tine (malicious) failures (see for further references). Of note, recent work by Attiya et al. [4, 3] has (effec-tively) resolved the question of work-optimal consensus in an asynchronous shared memory. Also of note, Geor-giou et al. developed the first consensus algorithm for asynchronous networks that achieved sub-quadratic (but super-linear) message complexity. The technique of universe reduction has been an important tool in developing distributed algorithms; we focus here on prior work related to consensus. Particularly notable are randomized algorithms by Ben-Or et al. and Kapron et al. that use universe reduction to solve Byzantine agreement (i.e., in the presence of malicious participants) in O(log n) expected time, but with relatively high message complexity (of Ω( n2)). Using similar ideas, King et al. show how to elect an honest leader using only O(n log O(1) n) bits of communication. Quite recently, King and Saia have built on their leader election protocol to solve Byzantine agreement (with a probabilistic agreement guarantee) using only ˜O(n3/2) bits of communication; > 1The communication complexity, however, depends on the size of the rumors. Often, however, the goal of gossip is to calculate some aggregate information, for example, the average of all the rumors. In this case, the bit complexity can be kept small. Notice that the same problem of message size	{ "page_id": null, "source": 7338, "title": "from dpo" }
arises in all random rumor spreading protocols. 966 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. Message/Bit Complexity Round Complexity Randomized? FloodSet O(n3) bits O(n) No Optimized FloodSet O(n2) bits O(n) No GMY’95 O(n) messages O(n1+ ε) No GMY’95 O(n) bits 2O(n) No CK’02,CK’06 [6, 7] O(n log O(1) n) messages O(n) No CKS’09 O(n log O(1) n) bits O(n) No CMS’89 O(n2 log n) messages O(log n) Yes CK’09 O(n log n) bits O(log n) Yes Section 3 O(n) bits O(log n) Yes Figure 1: Summary of communication complexity and round complexity of existing consensus protocols compared to the new algorithm presented in this paper. The randomized bounds hold with high probability. this is the first such protocol that breaks the quadratic communication complexity barrier! In this paper, we apply the technique of universe re-duction to a system subject to crash failures, not Byzan-tine failures. Thus some aspects of our protocol are sim-pler, since there is no need to prevent Byzantine partic-ipants from hijacking the selected sub-universe. On the other hand, some aspects are more complicated as care-ful coordination is needed to reach O(n) communication complexity. As one example of the challenges, we can-not even afford the cost of informing everyone as to who is in the selected sub-universe. 2 Model We consider a system consisting of n processes Π = p1, p 2, . . . , p n. Up to f < n/ 2 processes may fail by crashing. An execution is divided into synchronous rounds, and processes communicate by exchanging mes-sages in each round. If a process does not fail by the end of a round, then all of the messages that it sends in that round are delivered. On the other hand, if a process fails during	{ "page_id": null, "source": 7338, "title": "from dpo" }
a round, then an arbitrary subset (possibly all) of its messages for that round are lost, as determined by the adversary. The message complexity of an execution is the total number of messages sent by all processes during the entire execution. The commu-nication complexity of an execution is the total number of bits for all messages. Each process has access to an arbitrary number of random bits. We assume that the round in which a process fails is independent of the random bits, i.e., the adversary is oblivious . Formally, the oblivious adversary chooses, prior to every execution: (i) a function F : Π → Z∪{⊥} specifying in which round each process fails, and (ii) a function M : Π → P(Π) specifying which subset of messages are delivered by a process in the round in which it fails. If a process p never fails, i.e., if F (p) = ⊥,we say that it is correct . We say that a process p is non-failed in round r if it is either correct or F (p) > r . If a message is sent by a faulty process p in round F (p) to a process q ∈ M (p), then it is delivered; if it is sent to a process q′ /∈ M (p) then it is not delivered 2 3 Communication-Optimal Consensus In this section, we present a randomized algorithm for solving consensus using only O(n) messages and O(n)bits of communication. We begin with an overview of the basic structure of the algorithm. We then describe the individual building blocks, and discuss how to assemble them into an efficient solution. The first step, described in Section 3.1, is to choose a set of Θ(log n) coordinators that are responsible for determining the eventual decision. The coordinators are selected	{ "page_id": null, "source": 7338, "title": "from dpo" }
at random, and then participate in a simple discovery process to find the other coordinators. (This discovery process can be viewed as an example of probabilistic quorum systems .) The second step, described in Section 3.2, is for the coordinators to run a consensus protocol amongst themselves; we refer to this as a limited universe consensus protocol , as only > 2Note that the protocols in this paper can in fact tolerate a somewhat stronger adversary, in that it is only necessary that the adversary decide in advance which processes will fail; it can adaptively choose when and how they fail. 967 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. the coordinators participate. Since there are very few coordinators, this can be implemented quite efficiently. The third step, described in Section 3.3., is for the coordinators to disseminate the decision value to the remaining processes. If something goes wrong during any of these steps, the processes abort and execute a fall-back consensus protocol that is less efficient. We now describe each of the components of the protocol in more detail. Throughout, we fix a constant c that is used in the probabilistic analysis. 3.1 Choosing Coordinators. The ChooseC sub-protocol is responsible for selecting a set of coordinators. It is a probabilistic protocol that guarantees, with high probability, that when the protocol completes there are Θ(log n) coordinators, each aware of the entire set of coordinators. More specifically, for each process pi,the sub-protocol returns two outputs: (1) a boolean flag isC i indicating whether process pi is a coordinator, and (2) a list coords i of other coordinators. The sub-protocol guarantees the following properties at the end of the execution: • Self-Inclusion CC : For every process pi, if isC i = true , then pi ∈ coords	{ "page_id": null, "source": 7338, "title": "from dpo" }
i. • Probabilistic Uniformity CC : With high probability, there exists a subset S such that: (i) every process pi ∈ S is a coordinator ( isC i = True ); (ii) every non-failed coordinator at the end of the ChooseC protocol is a member of S; (iii) for each non-failed coordinator pi ∈ S, coords i ⊆ S; (iv) for each non-failed coordinator pi ∈ S, for each process pj ∈ S\coords i, process pj fails by the end of the ChooseC protocol. • Coordinator Set Size CC : With high probability, when the protocol completes, the set of correct coordinators has size Θ(log n). • Termination CC : The protocol completes in O(1) rounds. The probabilistic uniformity condition captures the in-tuition that the set coords i at process pi reflects exactly the set of coordinators; however different processes may have slightly different views of which processes are co-ordinators, due to the fact that some candidate “co-ordinators” may fail during the protocol. Notice that both the probabilistic uniformity and coordinator set size properties hold with high probability. By contrast, the self-inclusion and termination properties hold with probability 1. Sub-protocol description. The ChooseC sub-protocol consists of the following steps: Round 0. Initially, each process pi independently sets isC i to true with probability 8 c log n/n . From this point on, we refer to the processes that set isC to true in this step as coordinators . Round 1. Each coordinator chooses a set of Θ( √n log n) intermediaries (specifically, 2c√n log n intermediaries, for some constant c). Coordinator pi sends a message to each se-lected intermediary containing the identifier “ pi.” Each such message is of size log n bits. Round 2. Each intermediary sends a single response to each message that it received in round 1.	{ "page_id": null, "source": 7338, "title": "from dpo" }
The response of an intermediary pj contains all the mes-sages received by pj in round 1. Each coordinator pi combines the responses it receives from interme-diaries, along with its own identifier, to form the list coords i. Analysis. We first bound the size of the set of coordinators, showing that with high probability, the set of correct coordinators is Θ(log n). Let C0 be the set of processes that set isC = True in Round 0. Let Correct be the set of correct processes that never fail (even after the ChooseC protocol completes). Lemma 3.1. (Coordinator-Set Size) With proba-bility at least 1 − 1/n c: (i) \|C0\| ≤ 16 c log n; and (ii) c log n ≤ \| C0 ∩ Correct \|.Proof. Let Xi be a 0 /1 variable indicating whether isC i = true , and recall that \|Correct \| > n/ 2. Since the adversary is oblivious, Xi is independent of whether process pi ∈ Correct .Since Pr( Xi) = 8c log n/n , we conclude that E(\|C0\|) = 8 c log n, and E(\|C0 ∩ Correct \|) ≥ 4c log n.Thus, by a straightforward Chernoff bound, Pr( \|C0\| ≥ 16 c log n) ≤ 1/n c, and Pr( \|C0 ∩ Correct \| ≤ c log n) ≤ 1/n c. Next, we show that the ChooseC protocol satisfies probabilistic uniformity, i.e., that, every pair of coordi-nators has approximately the same list of coordinators, with high probability. This follows by a straightforward birthday-paradox style analysis. Lemma 3.2. (Probabilistic Uniformity) With probability at least 1 − 1/n c, there exists a subset S such that: (i) every process pi ∈ S is a coordinator (isC i = True ); (ii) every non-failed coordinator at the end of the ChooseC protocol is a member of S; (iii) for each	{ "page_id": null, "source": 7338, "title": "from dpo" }
non-failed coordinator pi ∈ S, coords i ⊆ S;(iv) for each non-failed coordinator pi ∈ S, for each 968 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. process pj ∈ S\coords i, process pj fails by the end of the ChooseC protocol. Proof. Let S be the set of processes that set isC = True in Round 0. It follows that every process pi ∈ S is a coordinator, and that every non-failed coordinator is a member of S. Moreover, it is easy to see that for each coordinator pi ∈ S, coords i ⊆ S, as pi only adds to coords i processes that send messages to intermediaries in Round 1, i.e., pi only adds other coordinators to coords i. It remains to show the final property. Fix some non-failed coordinators pi and pj . In Round 1, both pi and pj send messages to Θ( √n log n)intermediaries. Let I be the set of intermediaries chosen by pi in Round 1. The probability that pj does not choose an intermediary in the set I is at most: ( 1 − \|I\| n )2c√n log n ≤ ( 1 − 2c√n log nn )2c√n log n ≤ ( 12 )4c2 log 2 n ≤ ( 1 n )c+2 This implies that pj ∈ coords i with probability at least 1−1/n c+2 . Taking a union bound over all (n > 2 ) pairs of pi and pj , the probability that there exists some non-failed pi and pj such that pj /∈ coords i by the end of Round 2 is no greater than 1 /n c. From this we conclude that, with high probability, for every coordinator pi, for every pj ∈ S\coords i, pj fails by the end of the ChooseC protocol. Finally,	{ "page_id": null, "source": 7338, "title": "from dpo" }
we conclude that the ChooseC protocol satis-fies the requisite properties: Lemma 3.3. The ChooseC protocol guarantees self-inclusion CC , probabilistic uniformity CC , coordinator-set size CC , and termination CC .Proof. The self-inclusion property follows immediately from the protocol, as every coordinator pi adds itself to coords i in Round 2. The probabilistic uniformity property follows immediately from Lemma 3.2. The coordinator-set size property follows from Lemma 3.1. Termination is immediate by inspection. We bound the communication complexity of ChooseC by simply summing the message costs: Lemma 3.4. With probability at least 1 − 1/n c, the ChooseC protocol has communication complexity O(√n log 4 n).Proof. By Lemma 3.1, there are at most 16 c log n co-ordinators with probability at least 1 − 1/n c. In this case: In Round 1, there are at most 16 c log n coordi-nators, each of which sends 2 c√n log n messages of size log n bits. In Round 2, there are at most 32 c2√n log 2 n responses that result from the Round 1 messages, and each response contains at most 16 c log n identifiers of size log n bits. Summing the bit complexities leads to the desired bound. 3.2 Limited Universe Consensus. The goal of the second sub-protocol, LUConsensus , is to achieve agreement among the coordinators. The protocol itself is a simple implementation of deterministic consensus, as described in . The only difference here is that the protocol is executed only on the coordinators, and with some (small) probability, the coordinators have different views of the world. Each process pi begins with three inputs: (1) an initial value vi, (2) a boolean flag isC i indicating whether process pi is a coordinator, and (3) a list coords i of other coordinators. We assume that the	{ "page_id": null, "source": 7338, "title": "from dpo" }
isC indicator and the coordinator lists coords satisfy self-inclusion, probabilistic uniformity, and coordinator-set size, as per the ChooseC protocol. Each process with isC = True returns one output: a value vo. The sub-protocol guarantees the following properties at the end of the execution: • Probabilistic Agreement LU C : With high probabil-ity, every process that outputs a value chooses the same value. • Validity LU C : If process pi outputs value voi , then there is some process pj with initial value vj = voi . • Termination LU C : The protocol terminates in O(log n) rounds. Every non-failed process with in-put isC = True produces an output. Note that unlike the classical requirements of consensus, the LUConsensus protocol only ensures that agree-ment is reached with high probability ; with some small probability, the coordinators may disagree. This sim-plifies the LUConsensus sub-protocol, compensating for the fact that with some small probability, the set of coordinators provided as part of the input may itself be inconsistent. Sub-protocol description. Each process pi main-tains an estimate ei. Initially, ei = vi. The LUCon-sensus sub-protocol consists of the following, repeated for Θ(log n) rounds, specifically for at least 16 c log n + 1 rounds: • Each coordinator pi with isC i = true sends its estimate ei to every process in coords i.969 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. • Each coordinator pi with isC = true updates its estimate with the minimum estimate received in that round. After Θ(log n) rounds, each coordinator pi with isC = true outputs its estimate ei. Analysis. The LUConsensus is, essentially, an im-plementation of the classical FloodSet algorithm (as presented in ) on a limited universe. The key com-ponent of the proof is showing that the probabilistic uni-formity property	{ "page_id": null, "source": 7338, "title": "from dpo" }
is sufficient to ensure that the coordi-nators correctly execute consensus. Lemma 3.5. The LUConsensus protocol satis-fies probabilistic agreement LU C , validity LU C , and termination LU C , assuming the inputs isC and coords satisfy self-inclusion CC , probabilistic uniformity CC ,and coordinator-set size CC .Proof. Validity LU C and termination LU C follow immedi-ately, by inspection. In order to see that agreement LU C holds, recall that probabilistic uniformity CC and coor-dinator set size CC hold with respect to the inputs ( isC and coords ). In particular, with high probability, there exists a subset S of size Θ(log n) such that: (i) every process pi ∈ S is a coordinator; (ii) every non-failed coordinator is a member of S; (iii) for each non-failed coordinator pi ∈ S, coords i ⊆ S; (iv) for each non-failed coordinator pi ∈ S, for each process pj ∈ S\coords i,process pj fails by the end of the ChooseC protocol. From this we conclude, by the pigeon-hole principle, that there is some round r during the Θ(log n) rounds of the LUConsensus protocol in which no process in the subset S fails; fix such a round r. From the set of processes in S that do not fail by the end of round r,choose pi to be a process with the minimum estimate. In round r, process pi sends its estimate to every process in coords i.Let pj be some other coordinator that does not fail by the end of round r. By probabilistic uniformity, we know that pj ∈ coords i, with high probability; otherwise, pj ∈ S\coords i, implying that it fails by the end of the ChooseC protocol, i.e., prior to round r.Thus pj receives a message from pi containing ei;since ei is the minimum estimate among non-failed	{ "page_id": null, "source": 7338, "title": "from dpo" }
coordinators, pj adopts estimate ei. From this we conclude that at the end of round r, every non-failed coordinator has adopted estimate ei. This immediately implies the agreement property, as desired. The communication complexity can be calculated by summing the various message costs: Lemma 3.6. With high probability, the communication complexity of LUConsensus is O(log 3 n), assuming the inputs isC and coords satisfy self-inclusion CC , proba-bilistic uniformity CC , and coordinator-set size CC .Proof. As per the coordinator-set size property, with high probability there are at most O(log n) coordina-tors. In each round, each coordinator sends a constant-sized message to every other coordinator, and this con-tinues for O(log n) rounds, leading to the desired bound. 3.3 Coordinator Data Dissemination. The goal of the third sub-protocol, Disseminate , is to efficiently disseminate data from the set of coordinators to all the other processes. Each process pi begins with three inputs: (1) an initial value vi, (2) a boolean flag isC i indicating whether process pi is a coordinator, and (3) a list coords i of other coordinators, where the initial values vi satisfy probabilistic agreement, and isC i and coords i satisfy self-inclusion, probabilistic uniformity, and coordinator-set size. Each process pi outputs a set of values Vi; each coordinator pi outputs a flag ds i indicating whether its initial value was successfully disseminated. The sub-protocol guarantees the following properties at the end of the execution: • Dissemination D : For every non-failed coordinator pi, the initial value vi is sent to every process, i.e., for every non-failed pj , vi ∈ Vj . • Validity D : If, for some process pi, there is some value v ∈ Vi, then some coordinator pj initiated Disseminate with value vj , i.e., there exists a pj where isC j	{ "page_id": null, "source": 7338, "title": "from dpo" }
= True and vj = v. • Consistency D : If, for some pair of processes pi, p j ,the flag ds i = True and ds j = True , then initial values vi = vj . • Termination D : The protocol terminates in O(log ∗ n) rounds. With high probability, every cor-rect coordinator pi returns ds i = True . Sub-protocol description. Partition the processes in Π into log n log ∗ n groups G1, G 2, . . . , G log n log ∗ n each of size n/ (log n log ∗ n). Each process pi maintains a list of unnotified groups Li and a count ci of the number of notified processes. Initially, Li contains every group, and ci = 0. The protocol proceeds in Θ(log ∗ n) triples of rounds; the constant factor follows from the analysis. Each triple of rounds proceeds as follows: Round 1. Each coordinator pi chooses a group g at random from the list Li, and sends its value vi to every process in group g. Round 2. Each process pj that received exactly one value v in Round 1, and that did not previously 970 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. receive a different value v′ 6 = v in a previous round, adds v to the set Vj and sends a response. (Note that if pj received the same value v in a previous round, then it still sends a response.) Each coordinator, on receiving the responses from processes in group g, counts the number ng of responses received. Round 3. Each coordinator pi sends 〈g, n g , v i〉 to every other coordinator in coords i. When a coordinator pj receives a message containing 〈g′, n ′ > g	{ "page_id": null, "source": 7338, "title": "from dpo" }
, v ′〉, it proceeds as follows: if g′ ∈ Lj and v′ = vj , then coordinator pj removes g′ from Lj and adds n′ > g to cj .These three rounds are repeated Θ(log ∗ n) times. At this point, if, for some coordinator pi, the list Li is not empty, then pi proceedings as follows: • Coordinator pi sends the value vi directly to every process in Π. • Every process that receives such a message sends a response according to the same conditions as before, i.e., only if it has not received a different value in an earlier round. • The coordinator pi sets the count ci to the number of responses received (overwriting any earlier value of ci). At this point, every coordinator is ensured that its initial value has been disseminated, either directly or indirectly. If count ci > n/ 2, then the coordinator pi returns ds i = True ; if count ci ≤ n/ 2, then the coordinator pi returns ds i = False . Every process pj ∈ Π returns Vj . Analysis. We now show that the Disseminate proto-col satisfies the requisite properties. The disseminate D property follows from the simple fact that a process pi only removes a group g from its list if it sends a message to every process in g, or if another coordinator with the same initial value sends a message to every process in g: Lemma 3.7. (Dissemination) For every non-failed coordinator pi, the initial value vi is sent to every pro-cess, i.e., for every non-failed pj , vi ∈ Vj .Proof. We first argue that if a group g is removed from the list Li by a process pi, then every process in g has been sent the value vi. There are two	{ "page_id": null, "source": 7338, "title": "from dpo" }
reasons a group may be removed from Li. First, it might be the case that pi directly sends value vi to every process in g.Second, it might be the case that pi receives a message from some other process pj indicating that pj has sent message vj = vi to every process in g. In both cases, the removal of g clearly implies that every process in g has been sent the value vi. At the end of the protocol, either Li is empty, in which case vi has been sent to every process in Π, or process pi proceeds to send vi directly to every process. We next argue that the Disseminate protocol satisfies the consistency D property: Lemma 3.8. (Consistency) If, for some pair of pro-cesses pi, p j , the flag ds i = True and ds j = True ,then initial values vi = vj .Proof. We first argue that for every coordinator pi, the count ci is a lower bound on the number of processes that received value vi before receiving any other values. If pi broadcasts a message directly to every process (after Θ(log n) triples of rounds), then the count ci is set to exactly the number of responses received; every such response indicates a process that received no value other than vi in a prior round. Consider the case where pi does not broadcast a message directly to every process. Observe that for each group g, a process pi adds count ng to ci only once, i.e., when g is removed from Li; and the count ng reflects the number of responses received by some coordinator pk that sent vk = vi to every process in the group g. Thus again we conclude that there are at least ci processes that	{ "page_id": null, "source": 7338, "title": "from dpo" }
received no value other than vi prior to receiving value vi.Now, we conclude the proof. Fix two processes pi and pj such that ds i = ds j = True when the protocol completes. This implies that ci > n/ 2 and cj > n/ 2. Thus there is some process p` that is included in both counts, i.e., that received a message containing vi prior to (and not concurrently with) receiving any other value, and that also received a message containing vj prior to (and not concurrently with) receiving any other value; this implies that vi = vj , as desired. We conclude that the Disseminate protocol satisfies the requisite properties: Lemma 3.9. The Disseminate protocol satis-fies dissemination D , validity D , consistency D , and termination D , assuming the inputs isC and coords satisfy self-inclusion CC , probabilistic uniformity CC ,and coordinator-set size CC , and assuming the input initial values satisfy probabilistic agreement LU C .Proof. The dissemination and consistency properties follow from Lemma 3.7 and Lemma 3.8, respectively. Validity follows from simple inspection, as a process only returns values received directly from coordinators. 971 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. Similarly, it is immediately clear that the protocol terminates in O(log ∗ n) rounds. Finally, since the initial values agree, with high probability, then every process responds to every dissemination message from every coordinator; since a majority of processes are correct, the successful dissemination implies that every non-failed coordinator pi outputs ds i = True . We now show that the Disseminate protocol has com-munication complexity O(n), with high probability. The key claim is as follows: if the set of coordinators contains Θ(log n) correct processes, then after Θ(log ∗ n)rounds, every group has been sent the	{ "page_id": null, "source": 7338, "title": "from dpo" }
initial value by some coordinator, without resorting to the final round in which coordinators send their value directly to every-one. In this case, the total communication incurred is Θ(log ∗ n) triples of rounds in which Θ(log n) processes send (and receive as responses) Θ( n/ (log n log ∗ n) bits each, along with a small amount of inter-coordinator communication. We say that a group is notified (with respect to S) if it has been selected, and its processes have been sent a message, by some coordinator in S. Otherwise, it is unnotified . We model the process of notifying groups as a classic balls-and-bins game: each of the log n log ∗ n groups is a bin, and in each round, each coordinators throws one “ball” into one “bin,” notifying a particular group. After each round, every “bin” that has received at least one “ball” is removed from the game (via coordination among the coordinators). We refer to this as the process of clearing bins .We first establish that, for a given group of coordi-nators S of size at least log n, within O(log ∗ n) rounds, there are at most 2 log n unnotified groups. This follows from the observation that in each round, each coordi-nator has a probability of at least 1 /2 of selecting a previously unnotified group, resulting in a reduction of the number of unnotified groups by Θ(log n): Lemma 3.10. If subset S contains at least log n correct coordinators, then within O(log ∗ n) rounds there are at most 2 log n groups that are unnotified, with high probability. Proof. Assume for the sake of contradiction that for c log ∗ n triples of rounds, there are at least 2 log n un-notified groups. We focus on the behavior of exactly	{ "page_id": null, "source": 7338, "title": "from dpo" }
log n coordinators (ignoring the notifications by addi-tional coordinators). Observe that in each such triple of rounds, each of the log n coordinators in S notifies a new group with probability at least log n > 2 log n = 12 , independent of the choices made by the other coordinators. For log n coordinators, over c log ∗ n rounds, this implies that in expectation there are at least c log n log ∗ n groups no-tified. Thus by a Chernoff bound 3, we observe that the probability of notifying less than ( c/ 4) log n log ∗ n groups is no greater than e−c log n log ∗ n/ 4 ≤ (1 /n )c/ 4.When c ≥ 4, this is a contradiction (as there are ini-tially log n log ∗ n groups). We now examine the bin-clearing process when there are at least log n coordinators and at most 2 log n remaining groups. This random process has been previously studied in 4: Lemma 3.11. (, Theorem 2) The process of clear-ing b bins with ` balls, for ` ≥ b/ 2, terminates within log ∗(b log `/` ) + O(1) rounds with probability at least 1 − 2e−`1/5 . From this, we derive the straightforward corollary, applying this to our situation: Corollary 3.1. If, for some subset S, there are at most 2 log n unnotified groups, and at least log n correct coordinators, then within O(log ∗ n) rounds, every group has been notified, with high probability. Proof. Applying Lemma 3.11, where b ≤ 2 log n and ` =log n, we observe that after log ∗ (2 log log n) ≤ log ∗ n rounds, with probability at least 1 −(1 /n )(1 /5) ln 2 , every group has been notified.	{ "page_id": null, "source": 7338, "title": "from dpo" }
Thus after some O(c log ∗ n)rounds, every group has been notified with probability polynomially small in n. Putting together Lemma 3.10 and Corollary 3.1, we conclude the following: Lemma 3.12. The communication complexity of Disseminate is O(n), with high probability, assuming the inputs isC and coords satisfy self-inclusion CC , prob-abilistic uniformity CC , and coordinator-set size CC , and assuming the input initial values satisfy probabilistic agreement LU C .Proof. With high probability, there is a subset S that satisfies probabilistic uniformity and coordinator set size, by assumption; and with high probability, the initial values are all the same, by assumption. By > 3Formally, the events are not independent, however due to the property that notification of anew group happens with probability at least 1 /2 independently of other choices, we can stochastically estimate the number of notified groups by the sum of independent variables with expected value 1 /2. > 4In fact, Lemma 3.11 is a slight generalization of the theorem in , as we assume `≥b/ 2, rather than ` > b .Adding only a constant number of rounds in the beginning of the process ensures that the number of bins drops down to at most b/ 2. 972 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. Corollary 3.1, with high probability, within O(log ∗ n)rounds, every group has been notified by a non-failed coordinator in S. Consider the case where these high probability events occur. We now argue that every non-failed coordinator pi removes every group from its list L. Let g be a group notified by a non-failed coordinator pj ∈ S, and let pi be another non-failed coordinator. If pi /∈ coords j ,then pi ∈ S\coords j , and hence we conclude that pi has failed. Thus, since	{ "page_id": null, "source": 7338, "title": "from dpo" }
pi is non-failed, we know that pi ∈ coords j , and hence receives the update from pj that g was notified. Since all coordinators agree on the same value, we know that vj = vi, and hence pi removes g from Li. By the end of the protocol, every coordinator has an empty group list, and hence no coordinator sends its value directly to every process in Π. The communication complexity can be divided into three parts: sending messages to notify groups, sending responses, and sending messages among coordinators. In each round, each coordinator sends n/ log n log ∗ n messages (i.e., one message to each process in a group), and each message is of size O(1), containing only the value to be disseminated. Each such message leads to a single response of size O(1). There are at most O(log ∗ n) rounds, and at most O(log n) coordinators, and thus the total bit complexity of such messages is O(n). Communication among coordinators consists of O(log 2 n) messages in each round, each of size ≤ log (log n log ∗ n) + 1 + log n—i.e., containing the name of the most recently notified group, the value to be disseminated, and a count of processes. Thus, the total communication complexity is O(n + log 3 n). 3.4 Complete Consensus Protocol. We now present the complete protocol. Each process pi begins with initial value vi, and maintains an estimate ei;initially ei = vi. Process pi executes the following steps: Communication-Optimal Consensus Protocol 1. ChooseC () i → 〈 isC i, coords i〉 2. LUConsensus (vi, isC i, coords i)i → v • Set ei = v.3. Disseminate (ei, isC i, coords i)i → 〈 Vi, ds i〉• If isC i = True and ds i = False	{ "page_id": null, "source": 7338, "title": "from dpo" }
, then set isC i = False .4. Disseminate (ei, isC i, coords i)i → 〈 Vi, ds i〉• If isC i = True and ds i = False , then set isC i = False . • If isC i = False and Vi is not empty, then set ei to the unique value in V . (We will show that there is always at most one value in the set V .) 5. Disseminate (ei, isC i, coords i)i → 〈 Vi, ds i〉• If there is a value v ∈ Vi and v = ei, then decide v.6. Each undecided process sends a message containing a “fallback request” to every other process request-ing that they begin the fallback protocol. 7. Every process that has not decided, or that receives a “fallback request” in Step 6 executes a classi-cal consensus protocol (e.g., the FloodSet Pro-tocol ), using value ei as its initial value. Every process that has not yet decided adopts the value returned and decides. We now argue that the resulting protocol is correct. Theorem 3.1. (Correctness) The communication-optimal consensus protocol satisfies agreement, validity, and termination. Proof. We begin by showing that the protocol sat-isfies validity. Specifically, validity follows from the validity LU C property of LUConsensus and the validity D property of the Disseminate protocol: every value ei that is eventually decided is either delivered by the Disseminate protocol or output by the LUCon-sensus protocol; every value distributed by the Dis-seminate protocol was previously output by the LU-Consensus protocol; and every value output by the LUConsensus protocol was previously the initial value of some process. It is also easy to see that the protocol sat-isfies termination, as every sub-protocol terminates. More specifically, termination follows immediately from the termination CC property of ChooseC ,the termination LU C	{ "page_id": null, "source": 7338, "title": "from dpo" }
property of LUConsensus , the termination D property of the Disseminate protocol, and the termination property of the fallback consensus protocol. We now consider the agreement property. We first argue that at the end of Step 3, every non-failed coordinator has the same value. Assume that, at the end of Step 3, there exist two non-failed coordinators pi and pj such that: isC i = True and isC j = True . From this we conclude that both pi and pj completed the Disseminate protocol successfully in Step 3, i.e., ds i = True and ds j = True . By the consistency property of Disseminate , we conclude that ei = ej . Thus, every 973 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. non-failed coordinator has the same candidate value at the end of Step 3. Assume for the sake of contradiction that there are two distinct values v and w decided by the end of the protocol. By the agreement property of the fallback consensus protocol, we know that only one value is decided in Step 7. Thus either v or w is decided in Step 5. Assume, without loss of generality, that value v is decided in Step 5 by some process. From this we conclude that the Disseminate pro-tocol in Step 5 returned value v in the set Vk for some process pk, and hence (by validity D ), some coordinator pj initiated the Disseminate protocol in Step 5 with ej = v and isC j = True . Thus, in Step 4, process pj disseminated value v, i.e., the dissemination property implies that every process received value v in Step 4. As every coordinator has the same candidate value at the end of Step 3, we conclude that v is the	{ "page_id": null, "source": 7338, "title": "from dpo" }
only value received in Step 4, and hence every non-failed process pi adopts v, setting ei = v.This leads us to two conclusions. First, in Step 5, since every non-failed process pi has ei = v, no process can decide w in Step 5. Second, every non-failed process pi still has ei = v at the beginning of Step 7, and hence by validity of the fallback consensus protocol, every non-failed process outputs v in Step 7. Thus no process decides w, which is a contradiction. Finally, we conclude that the protocol achieves good bit complexity: Theorem 3.2. (Efficiency) The communication-optimal consensus protocol has O(n) communication complexity and O(log n) round complexity, with high probability. Proof. With high probability, the set of coordina-tors (and the set of correct coordinators) chosen by ChooseC is of size Θ(log n); that is, in every round af-ter ChooseC completes, there are Θ(log n) non-failed coordinators. In addition, the set of coordinators sat-isfies probabilistic uniformity, as per the properties of the ChooseC sub-protocol. Moreover, with high prob-ability, every process agrees on the same estimate v in Step 2, as per the properties of the LUConsensus sub-protocol. And, with high probability, every correct coordinator returns ds = True in Step 3, as per the properties of the Disseminate protocol. Every process receives and adopts value v in Step 4, and decides v in Step 5, as per the properties of the Disseminate proto-col. From this we conclude that no process proceeds to the fallback phase, skipping Steps 6–7. Thus, the total bit complexity is the cost of ChooseC (Lemma 3.4), plus the cost of LUConsensus (Lemma 3.6), plus the cost of three invocations of Disseminate (Lemma 3.12), which totals O(n). 4 Partially Synchronous Systems While networks are typically synchronous , delivering messages in a	{ "page_id": null, "source": 7338, "title": "from dpo" }
timely fashion, real protocols must cope with occasional asynchrony , i.e., unpredictable message delays. Thus it is considered good computing practice to plan for the worst and hope for the best. In the context of distributed computing, this translates into devising algorithms that, on the one hand tolerate asynchrony, while on the other hand, operate efficiently when the network is synchronous. We refer to systems that are typically synchronous, but occasionally asynchronous, as partially synchronous systems . In this section, we show how to modify the algorithm described in Section 3 so that it can be safely deployed in a partially synchronous network, maintaining its high level of efficiency whenever the network is, in fact, synchronous. 4.1 Model. In this section we formally define a par-tially synchronous system , following the basic model in . The system is parameterized by three variables: n, the number of processes, δ a synchronous bound on clock skew, and d a synchronous bound on message de-lay. We assume that n, δ and d are known a priori .As before, we consider a set Π of crash-prone processes p1, . . . , p n, a majority of which are correct. Each process has its own local clock that proceeds at an arbitrary rate. As before, processes communicate directly with each other; however, we do not assume that communication proceeds in rounds. Instead, a message may be arbitrarily delayed. Every message sent by a correct process to some other correct process is eventually delivered. We say that an execution is synchronous when the following conditions hold: (i) the clock skew of every process is bounded by δ, i.e., the ratio of the rates of two processes’ clocks is at most δ; and (ii) every message is delivered within d time. Otherwise, we say that an	{ "page_id": null, "source": 7338, "title": "from dpo" }
execution is asynchronous . 4.2 Protocol Modifications. We now describe how to modify the communication-optimal consensus proto-col presented in Section 3 in order to operate safely in a partially synchronous system, while remaining efficient in synchronous executions. First, each process simulates synchronous rounds based on message delay d and clock skew δ. Observe that in a synchronous execution, at time τ the clock at every process i is in the range [(1 − δ)τ, (1 + δ)τ ]. 974 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. Let ρ = (1 + δ)/(1 − δ). The first simulated round r1 is defined, for process pi, to end at time d/ (1 −δ) according to the local clock at process pi. Simulated round r is defined for process pi to end at time: d > 1−δ ∑r−1 > j=0 ρj according to the local clock of process pi.Since the clocks of two processes pi and pj may advance at different rates, there is no guarantee that both processes begin and end their rounds at the same time. However, in a synchronous execution, the clock skew is bounded by δ, and hence every message sent by pi to pj at the beginning of round r, according to the local clock of pi, is received by the end of round r according to the local clock of process pj . In an asynchronous execution, however, the simulation of synchronous rounds may, of course, fail completely. Second, each process pi that sends a fallback request message in Step 6 of the protocol acts as follows: if pi received a value in Step 4, then it attaches its current estimate ei to the fallback message. When a process pj receives a fallback message, it immediately aborts the ongoing protocol, jumping immediately to	{ "page_id": null, "source": 7338, "title": "from dpo" }
fallback Step 6. (Of particular note, pj sends no further responses as part of the Disseminate protocol.) Third, a process pi does not begin the fallback con-sensus protocol in Step 7 until it has received fallback request messages from at least a majority of the pro-cesses. When process pi receives a fallback request mes-sage from some process pj with estimate ej , it adopts that estimate, setting ei = ej .Finally, when choosing a fallback consensus proto-col for Step 7, we focus only on protocols that operate correctly in asynchronous networks. For example, we might use the asynchronous consensus protocol in , which guarantees expected sub-quadratic message com-plexity in asynchronous executions. 4.3 Analysis. In this section, we first observe that the modified communication-optimal consensus proto-col still guarantees good performance in synchronous executions: Theorem 4.1. In a synchronous execution, the mod-ified communication-optimal consensus protocol has O(n) communication complexity and O(log n) simulated round complexity, with high probability. Proof. When the execution is synchronous, the simula-tion of synchronous rounds is correct, delivering every message from a non-failed process in the round in which it was sent. Thus, the protocol proceeds exactly as in a synchronous execution and the communication/time complexity are exactly as in Theorem 3.2. It remains to argue that the protocol is correct, even in asynchronous executions: Theorem 4.2. The modified communication-optimal consensus protocol guarantees agreement, validity, and termination. Proof. As before, validity follows immediately by in-spection. Termination is also straightforward: any cor-rect process that does not terminate eventually sends out a fallback request message; eventually every non-failed process receives this message and sends a fallback request message; since a majority of processes are cor-rect, eventually every non-failed process receives enough fallback request messages and begins the asynchronous fallback consensus protocol; eventually, the fallback con-sensus protocol terminates, allowing every	{ "page_id": null, "source": 7338, "title": "from dpo" }
correct pro-cess to decide. Agreement follows from the observation that the safety of the Disseminate protocol does not depend on synchrony. As before, the dissemination D property follows from the fact that a non-failed coordinator pi always sends its initial value vi directly to every pro-cess that has not already been sent the value vi. The consistency D property follows from the fact that a co-ordinator pi returns ds i = True only if a majority of processes receive value vi prior to any other value. The validity D and termination D properties are similarly unaffected by asynchrony (notably, the protocol termi-nates when all the rounds of the protocol have been simulated, according to the local clock). Thus, as before, every non-failed coordinator (that still has isC = True ) has the same estimate by the end of Step 3. This ensures that at most one value is decided in Step 5. The agreement property of the fallback consensus protocol ensures that at most one value is decided in Step 7. It remains to consider the case where some value v is decided in Step 5. This implies that a majority of processes received (and responded, confirming reception of) that estimate in Step 4. Thus, any process that begins the fallback protocol receives that estimate from at least one process during the fallback request phase. The validity of the fallback consensus protocol ensures that v is the only possible decision in Step 7. 5 Gossip In this section, we provide a brief overview of how to adapt the techniques presented thus far to solve the problem of gossip. Assume each process pi begins with a rumor ri. The goal is for every process to learn the rumor of every other correct process. The same techniques described in 975 Copyright	{ "page_id": null, "source": 7338, "title": "from dpo" }
© by SIAM. Unauthorized reproduction of this article is prohibited. Section 3 yield a synchronous (or partially synchronous) protocol that can solve this problem of gossip. The key observation is that the Disseminate routine can be used just as well to collect data as to distribute it. Specifically, we modify the Disseminate routine as follows. We refer to the modified protocol as Collect . • First, when executed at process pi, it takes three parameters: (i) ri, a rumor to collect, (ii) isC i, a flag indicating whether pi is a coordinator, and (iii) coords i, the set of coordinators. It returns to each coordinator pi a set Ri of rumors and a flag ds i; it does not return anything to non-coordinators. • Second, every process attaches its rumor ri to the response sent to the coordinators during Round 2 in each triple of rounds. Each coordinator attaches the set of newly learned rumors to every message sent to the other coordinators during Round 3 in each triple of rumors. (Note that if the coordinators are attempting to aggregate data as it is collected, they may send some aggregate or compressed ver-sion of the newly discovered rumors.) The Collect protocol has essentially the same prop-erties (of validity, consistency, and termination) as the Disseminate protocol, with the exception of the dissemination D property which is now replaced by the collection C property: For every non-failed coordinator pi, for every non-failed process pj , the rumor rj is re-turned to pi, i.e., rj ∈ Ri.The gossip protocol, then, proceeds as follows: Communication-Efficient Gossip 1. ChooseC () → 〈 isC i, coords i〉 2. Collect (ri, isC i, coords i) → 〈 Ri, ds i〉 3. Disseminate (Ri, isC i, coords i) → 〈 Vi, ds i〉 4. Disseminate (Done , isC	{ "page_id": null, "source": 7338, "title": "from dpo" }
i, coords i) → 〈 Vi, ds i〉 5. If process pi has not received the flag Done , then it sends a fallback request to every other process. Every process, on receiving such a request, sends its rumor in response. The resulting protocol ensures that every rumor origi-nating at a correct process is distributed to every non-failed process: if there are no non-failed coordinators that complete Step 4, then no process receives the Done message and every process sends its rumor to all other process during the fallback Step 5; if there is even one non-failed coordinator, then by the collection property it retrieves all the rumors in Step 2, and by the dissem-ination property it distributes all the rumors in Step 3. It is also easy to see that the resulting protocol terminates in O(log ∗ n) rounds, as each individual step completes in at most O(log ∗ n) rounds. Finally, with high probability, the gossip protocol uses no more than O(n) messages. This follows from the probabilistic uniformity and coordinator-set size proper-ties of the ChooseC protocol, along with the message-complexity analysis of the Collect /Disseminate pro-tocols. While the protocol sends at most O(n) message, with high probability, the communication complexity depends on the size of the rumors and their capacity to be efficiently aggregated. (This is, of course, inherent to all gossip protocols.) Even so, there are a wide variety of examples in which the data being collected can be efficiently aggregated (or summarized). For example, a common problem in distributed computing is verifying whether there is one or more than one non-failed leader in a system; such a problem can be solved using this gossip protocol with only O(n) bits of communication. 6 Conclusion In this paper, we have developed a new consensus al-gorithm that achieves	{ "page_id": null, "source": 7338, "title": "from dpo" }
optimal communication complex-ity and almost optimal time complexity. We have also shown how to modify the algorithm so that it can tol-erate asynchronous executions, while maintaining good performance if the network is synchronous. The tech-niques we have used are quite general, and can be used to solve a variety of other problems. As an example, we have shown how to use this technique of universe reduction to efficiently gossip rumors. One of the important open questions regards the property of locality , i.e., where no process sends more than O(log O(1) n) bits. (In the communication-optimal consensus protocol in this paper, each of the coordina-tors may send Θ( n/ log n) messages.) We conjecture that the same techniques in this paper can be used to achieve locality; however straightforward modifications lead to larger communication and time complexity. In fact, there may well be an inherent trade-off between locality and communication/time complexity. The nat-ural question, then, is what is the optimal communica-tion complexity for a local algorithm? The other major open question is resolving the op-timal communication complexity for deterministic con-sensus algorithms with linear time complexity. (Recall that achieves optimal O(n) message complexity, but requires super-linear round complexity.) We conjecture that it is impossible to achieve both O(n) communica-976 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. tion complexity and O(n) time complexity with a de-terministic algorithm. Acknowledgments We would like to thank Valerie King for several helpful conversations, and especially her insights regarding the technique of universe reduction . We would also like to thank Dan Alistarh for many discussions regarding how to reduce the message complexity of distributed algorithms. References S. Amdur, S. Weber, and V. Hadzilacos. On the message complexity of binary agreement under crash failures. Distributed Computing , 5(4):175–186, 1992. J.	{ "page_id": null, "source": 7338, "title": "from dpo" }
Aspnes. Randomized protocols for asynchronous consensus. Distributed Computing , 16(2-3):165–175, 2003. H. Attiya and K. Censor. Lower bounds for random-ized consensus under a weak adversary. In Proceedings of the Twenty-Seventh Symposium on Principles of Distributed Computing (PODC) , pages 315–324. ACM, 2008. H. Attiya and K. Censor. Tight bounds for asyn-chronous randomized consensus. J.of the ACM ,55(5):1–26, 2008. M. Ben-Or, E. Pavlov, and V. Vaikuntanathan. Byzan-tine agreement in the full-information model in o(log n) rounds. In Proceedings of the Thirty-Eighth Sympo-sium on Theory of Computing (STOC) , pages 179–186. ACM, 2006. B. Chlebus and D. Kowalski. Gossiping to reach consensus. In Proceedings of 14th Symposium on Parallel Algorithms and Architectures (SPAA) , pages 220–229, 2002. B. Chlebus and D. Kowalski. Robust gossiping with an application to consensus. Journal of Computer and System Science , 72(8):1262–1281, 2006. B. Chlebus and D. Kowalski. Locally scalable random-ized consensus for synchronous crash failures. In Pro-ceedings of 21st Symposium on Parallel Algorithms and Architectures (SPAA) , 2009. B. S. Chlebus and D. R. Kowalski. Randomization helps to perform independent tasks reliably. Random Struct. Algorithms , 24(1):11–41, 2004. B. S. Chlebus, D. R. Kowalski, and M. Strojnowski. Fast scalable deterministic consensus for crash failures. In Proceedings of the 28th Symposium on Principles of Distributed Computing (PODC) , 2009. B. Chor, M. Merritt, and D. B. Shmoys. Simple constant-time consensus protocols in realistic failure models. J. of the ACM , 36(3):591–614, 1989. D. Dolev and H. Strong. Requirements for agreement in a distributed system. Technical Report RJ 3418, IBM Research, San Jose, CA, Mar. 1982. C. Dwork, J. Halpern, and O. Waarts. Performing work efficiently in the presence of faults. SIAM Journal on Computing , 27(5):1457–1491, 1998. C. Dwork, N. Lynch, and L. Stockmeyer. Consensus	{ "page_id": null, "source": 7338, "title": "from dpo" }
in the presence of partial synchrony. Journal of the ACM ,35(2):288–323, 1988. Z. Galil, A. Mayer, and M. Yung. Resolving message complexity of byzantine agreement and beyond. In Proceedings of the 36th Symposium on Foundations of Computer Science (FOCS) , pages 724–733, 1995. C. Georgiou, S. Gilbert, R. Guerraoui, and D. Kowal-ski. On the complexity of asynchronous gossip. In Proceeding of the 27th Symposium on Principles of Dis-tributed Computing (PODC) , 2008. S. Gilbert, R. Guerraoui, and D. Kowalski. On the message complexity of indulgent consensus. In Proceedings of the the 21st International Symposium on Distributed Computing (DISC) , 2007. B. M. Kapron, D. Kempe, V. King, J. Saia, and V. San-walani. Fast asynchronous byzantine agreement and leader election with full information. In Proceedings of the Nineteenth Annual Symposium on Discrete Algo-rithms (SODA) , pages 1038–1047, 2008. R. M. Karp, C. Schindelhauer, S. Shenker, and B. Vck-ing. Randomized rumor spreading. In Proceedings of the 41st Symposium on Foundations of Computer Sci-ence (FOCS) , 2000. V. King and J. Saia. Fast, scalable byzantine agree-ment in the full information model with a nonadap-tive adversary. In Proceedings of the 23rd International Symposium on Distributed Computing (DISC) , 2009. V. King, J. Saia, V. Sanwalani, and E. Vee. Scalable leader election. In Proceedings of the Seventeenth Annual Symposium on Discrete Algorithms (SODA) ,pages 990–999, 2006. L. Lamport, R. Shostak, and M. Pease. The byzantine generals problem. ToPLaS , 4(3):382–401, 1982. N. Lynch. Distributed Algorithms . Morgan Kaufman, 1996. D. Malkhi, M. K. Reiter, A. Wool, and R. N. Wright. Probabilistic quorum systems. Information and Com-putation , 170(2):184–206, 2001. M. Pease, R. Shostak, and L. Lamport. Reaching agreement in the presence of faults. Journal of the ACM , 27(2):228–234, 1980. 977 Copyright © by	{ "page_id": null, "source": 7338, "title": "from dpo" }
SIAM. Unauthorized reproduction of this article is prohibited.	{ "page_id": null, "source": 7338, "title": "from dpo" }
Title: Consensus using omega in asynchronous systems with unknown membership and degenerative Byzantine failures URL Source: Markdown Content: Skip to main content Skip to article Journals & Books View PDF Download full issue Outline Abstract Keywords 1. Introduction 2. The asynchronous system S 3. The omega failure detector class (Ω) 4. Reliable FIFO order broadcast (RFLOB) 5. Consensus in S with Ω and RFLOB 6. On the implementability of Ω in a system with degenerative Byzantine failures 7. Conclusions Declaration of Competing Interest References Show full outline Cited by (1) Figures (3) Journal of Computer and System Sciences Volume 107, February 2020, Pages 54-71 Consensus using omega in asynchronous systems with unknown membership and degenerative Byzantine failures☆ Author links open overlay panel Ernesto Jiménez a , José Luis López-Presa b , Javier Martín-Rueda b Show more Add to Mendeley Share Cite Get rights and content Under an Elsevier user license Open archive Abstract We study consensus in asynchronous systems where membership is unknown, and where up to f degenerative Byzantine failures can happen. In our failure model a faulty process can have a Byzantine behavior (i.e., it deviates from its specification), and, furthermore, every faulty process will degenerate such that eventually it will have permanent physical or transmission failures. We present a simple algorithm that solves Consensus using the Omega failure detector and a new broadcast primitive called RFLOB in an asynchronous system with degenerative Byzantine failures, which is optimal with respect to failures because it works when 𝑓 < 𝑛 / 3 . RFLOB guarantees reliable, FIFO and local order broadcast in systems with Byzantine processes and unknown membership. Finally, we present an algorithm that implements an Omega failure detector with unknown membership and minimum connectivity (i.e., communication reliability, and synchrony properties) in a system with degenerative	{ "page_id": null, "source": 7342, "title": "from dpo" }
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 that, from the set of values proposed by the processes in a system, only one of these values can be decided. Consensus has been studied under different failure models. The most commonly used is the crash failure model . In this failure model, processes cannot deviate from their specification, and a process can only fail by crashing permanently. It is well known that Consensus cannot be solved in an asynchronous system, even if it is restricted to crash failures and only one process can crash . To overcome this impossibility result, asynchronous systems can be augmented with failure detectors . A failure detector is a distributed device that returns information related to faulty processes. More precisely, a failure detector provides suspicions about processes which may have failed. However, failure detectors can make mistakes, e.g. by erroneously suspecting a non-faulty process (also called a correct process), or by not suspecting a failed one. However, to be useful, it is required that failure detectors fulfill completeness and accuracy properties. The completeness property requires that non-faulty processes must eventually suspect all faulty processes, and the accuracy property restricts the erroneous suspicions that can be returned by the failure detector. Chandra and Toueg in their seminal work proposed eight different classes of failure detectors, and showed that any of them can be used to solve Consensus in asynchronous systems with the crash failure model. All these classes satisfy the weak completeness property. Weak completeness requires that there is a time after which some correct process permanently suspects all crashed processes ( ◇ ◇ 𝑆 is one of	{ "page_id": null, "source": 7342, "title": "from dpo" }
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 weakest failure detector that can be used to solve Consensus in asynchronous systems with the crash failure model since the information returned by Ω about faulty processes is the minimum necessary to solve Consensus. Traditionally, in asynchronous systems where consensus and failure detectors are studied, it is assumed that the membership is known, i.e. every process initially knows the identity of all the processes in the system. When the membership is known, Ω and ◇ ◇ 𝑆 are equivalent, i.e. a failure detector of Class Ω is also a failure detector of Class ◇ ◇ 𝑆 and vice versa. It is shown in that the assumption of the knowledge of the membership is not banal. In fact, it is proved there that, with unknown membership, no failure detector class with weak completeness can be implemented. Hence, none of the original 8 classes proposed by Chandra and Toueg in can be implemented. Interestingly, in it is also showed that Ω can indeed be implemented without membership knowledge. This implies that Ω and ◇ ◇ 𝑆 failure detector classes are not equivalent when membership is unknown. Roughly speaking, the reason why Ω is implementable, while classical failure detector classes are not, is that, in Ω every correct process only needs to know the identity of one correct process, while in ◇ ◇ 𝑆 every correct process needs to know the identity of every faulty process. Thus, although initially unknown, correct processes will eventually know each other because,	{ "page_id": null, "source": 7342, "title": "from dpo" }
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 is the Byzantine failure model : faulty processes (also called Byzantine processes) can deviate from their specification and execute whatever operation they want, or even crash permanently. Hence, Byzantine processes may behave in a totally arbitrary way. Thus, this model considers any type of behavior of faulty processes. Hence, the crash failure model is a subset of the Byzantine failure model because the latter includes all failures in the first. In other words, the Byzantine failure model is more general than the crash one. Thus, all impossibility results that hold for the crash failure model also hold for the Byzantine failure model. In particular, the impossibility of achieving consensus with one faulty process also holds for Byzantine processes. Failure detectors are a way to circumvent this impossibility. In and the authors observed that the failure detector paradigm cannot be decoupled from the algorithm that uses it if the failure model is extended to Byzantine processes. They showed an inherent circular dependency because the only way for a failure detector FD to be able to return all the suspicions is that the algorithm 𝐴 which uses the failure detector cooperates informing FD of failures. Hence, the failure detector FD needs to know how 𝐴 is implemented. They introduce the ◇ ◇ 𝑀 𝐴 failure detector class with eventual mute completeness and eventual weak accuracy properties. Eventual weak accuracy guarantees that, eventually, some correct process is not suspected anymore by any other correct process. Eventual mute completeness states that every correct	{ "page_id": null, "source": 7342, "title": "from dpo" }
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 with muteness strong completeness and eventual strong accuracy properties. Eventual strong accuracy states that, eventually, no correct process is suspected anymore by any correct process. Muteness strong completeness guarantees that, eventually, all mute processes are suspected by all correct processes. In the authors introduce consensus in asynchronous systems enriched with the ◇ ◇ 𝑆 ( bz ) failure detector class for Byzantine processes. The ◇ ◇ 𝑆 ( 𝑏 𝑧 ) failure detector class has two properties: strong completeness and eventual weak accuracy (already described in the context of ◇ ◇ 𝑀 𝐴 ). Strong completeness specifies that every correct process eventually suspects all quiet processes. A process p is quiet if some process in the system eventually stops receiving messages from p. In an algorithm 𝐴 is introduced to solve Consensus in asynchronous systems with the Byzantine failure model and the ◇ ◇ 𝑊 ( Byz ) failure detector class. This failure detector class has eventual weak accuracy (already described) and eventual weak Byzantine ( 𝑘 + 1 ) -completeness properties. Eventual weak Byzantine ( 𝑘 + 1 ) -completeness property specifies that at least 𝑘 + 1 correct processes eventually suspect every process that has deviated from algorithm 𝐴 . Not surprisingly, due to the inherent circular dependency detected in and , every consensus algorithm 𝐴 of the previous papers requires synchrony constraints in cooperation with the failure detector FD, which does not allow 𝐴 to be executed	{ "page_id": null, "source": 7342, "title": "from dpo" }
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 mute (quiet or deviated) process. However, these processes might crash before sending any message, preventing correct processes in the system from knowing their existence. Almost all papers on consensus in systems with Byzantine failures use the rotating coordinator paradigm , , , , , . Using this method, the consensus algorithm works in rounds. At each round, one process in the system acts as the coordinator, which must be known by every process in the system. The order in which the coordinators are chosen as well as the membership must be known by every process in the system to be able to advance to the next round. 1.1. Our contributions In this paper we present a consensus algorithm for asynchronous systems where each process initially only knows its own identity and the size of the system, but ignores the identity of the other processes in the system. There are several advantages in solving consensus in systems with these features. From a practical point of view, consensus algorithms that work with unknown membership execute the same code in runs with different sets of processes in the system, without the need to statically change the set of addresses of the processes that participate in each run. Another advantage is to solve consensus in systems where the huge number of processes and its dynamism make it impossible to know the membership a priori (e.g. wireless mobile ad-hoc networks,	{ "page_id": null, "source": 7342, "title": "from dpo" }
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 to be overcome by systems without knowledge of the membership is when a process crashes before sending any message, because it would be permanently unknown to any other process. The failure model of our paper follows that of , with an extension to omission failures. In every faulty process is a Byzantine process such that there is a time after which it crashes permanently. They call them mortal Byzantine failures. We say in our model that we have degenerative Byzantine failures because each faulty process eventually degenerates and makes a physical or a transmission failure permanently. A physical failure is that in which the process crashes permanently (as a mortal Byzantine failure of ), for example due to a system fault from which it is impossible to recover. A transmission failure arises when a process omits a communication operation, either sending or receiving protocol messages (involuntary, for example when the network is congested, or voluntary in a Byzantine behavior of the process). The main advantage of our degenerative Byzantine failure model and with respect to that of is that, similarly to the crash failure model of , Consensus can be solved in a pure asynchronous system augmented with a failure detector such that both of them are totally decoupled. In other words, the failure detector can be seen as a “black-box” that the asynchronous consensus algorithm can use based only in its properties, and independently of its implementation. This independence between abstractions allows simplifying the design, development, correctness and maintenance of	{ "page_id": null, "source": 7342, "title": "from dpo" }
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 Ω without worrying about how they have been implemented and how they have to be interconnected to work properly. As the authors of note, their failure model with mortal Byzantine failures can be seen as a system in which, when Byzantine failures occur, there is another component outside the system that eventually detects these failures and stops them. They also present several practical examples especially focused on space systems where the misbehavior is detected by external units (ground operator and/or hardware units) which disable permanently the faulty units. One of these is the European automated transfer vehicle (ATV) with a set of computing elements and checking mechanisms whose task is to halt each damaged element when a failure is detected. Another example is focused on systems where a human operator halts one element of the system when a wrong behavior is detected. The degenerative Byzantine failure model we present in this paper extends the model of mortal Byzantine failures in with processes that eventually make omission failures permanently. This type of failures complements the failure model in by adding transmission failures to physical failures. In our model not all faulty processes eventually crash; there could be faulty processes alive that can be undetectable for an external unit. For example, there could be a process that sends messages permanently but does not receive any. We call it a deaf process. If a process can receive messages but cannot send any, we call it a mute process.	{ "page_id": null, "source": 7342, "title": "from dpo" }
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 asynchronous system there is no way to infer that a process is mute, because it could just be slow. Furthermore, they might be assumed to have crashed since they stopped sending messages. Similarly, a deaf process may be perceived externally as a correct process because it sends messages periodically. With our model, we include these new types of failures preserving all the advantages present in . In , a consensus algorithm needs to know the membership of the system. Additionally, it needs all Byzantine processes to crash before making a decision. In our case, the consensus algorithm presented in this paper decides even when some faulty processes (deaf, mute or autistic) are still alive. Our algorithm is simple and optimal with respect to the number of failures because it works when 𝑓 < 𝑛 / 3 , being f the maximum number of faulty processes and n the number of processes in the system , . This algorithm uses the Ω failure detector adapted from to our failure model with degenerative Byzantine failures, and a broadcast primitive, called reliable FIFO and local order broadcast (RFLOB) , to communicate messages among processes. This RFLOB primitive guarantees that correct processes deliver the same sequence of messages if they were broadcast by the same (correct or not) process and the messages broadcast by each process are delivered by all correct processes following the same causal order (i.e., FIFO and local order ). The aim of the introduction of this	{ "page_id": null, "source": 7342, "title": "from dpo" }
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 no implementation of a broadcast primitive with our reliability properties: FIFO, local order, and unknown membership in a system with Byzantine processes. Hence, for the sake of completeness, we also present and prove in this paper an algorithm that implements RFLOB in a system with unknown membership and where up to 𝑓 < 𝑛 / 3 processes are Byzantine. To our knowledge, all failure detector classes in systems with Byzantine failures present in the literature cannot be implemented when the membership is unknown ( ◇ ◇ 𝑃 mute , ◇ ◇ 𝑀 𝐴 , ◇ ◇ 𝑆 ( bz ) and ◇ ◇ 𝑊 ( Byz ) ). As we have mentioned above, this is so because every correct process needs to know every faulty process. However, in systems with unknown membership, these processes can fail before sending any message, preventing correct processes from detecting their presence in the system. In with mortal Byzantine failures, ◇ ◇ 𝑃 is used in a consensus algorithm although it cannot be implemented when the membership is unknown. This is so because it is one of the original 8 failure detectors of and its completeness property also forces it to know every faulty process . In this paper we present (and prove the correctness of) an algorithm that implements a failure detector of Class Ω in a system with unknown membership, minimum connectivity (i.e., the minimum communication reliability and synchrony properties) and degenerative Byzantine failures. To do so, we also prove which are the	{ "page_id": null, "source": 7342, "title": "from dpo" }
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 follows. Our model, with unknown membership and degenerative Byzantine failures, is given in Section 2. In Section 3 we refine the definition of the Ω failure detector class to cope with all failure types present in our system. In Section 4 we introduce the reliable FIFO local order broadcast (RFLOB) primitive for Byzantine systems, which we use to simplify solving Consensus, without strengthening the system model. We also provide an algorithm that implements RFLOB and prove its correctness. In Section 5 we provide an algorithm to solve the Consensus problem in our system and prove its correctness. In Section 6 we find weak conditions to implement Ω in a partially synchronous system with degenerative Byzantine failures. In particular, we find minimal conditions on the number of eventually-timely and lossy-asynchronous links. We also provide an algorithm to implement Ω under these conditions and prove its correctness. Finally, in Section 7 we provide concluding remarks. 2. The asynchronous system S In this section we describe the main features of the asynchronous system S. That includes the elements that form the system and the relationships among them. 2.1. Processes, communication, links and time Let S be a system formed by a finite set Π = { 𝑝 ℎ , 𝑝 𝑘 , … , 𝑝 𝑠 } of n processes (i.e., \| Π \| = 𝑛 ). The identities of the processes do not need to be consecutive. We assume that the membership is unknown but the size n is known. Hence, initially each process 𝑝	{ "page_id": null, "source": 7342, "title": "from dpo" }
𝑖 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. Thus, every process 𝑝 𝑖 ∈ 𝑆 can send messages to every process 𝑝 𝑘 ∈ 𝑆 using a different and unidirectional link. A process 𝑝 𝑖 invokes the operation broadcast 𝑖 ( 𝑚 ) to send a copy of message m to all processes in the system S using each one of these links. If a process crashes while executing broadcast 𝑖 ( 𝑚 ) , a copy of m will be received by an arbitrary and unknown number of processes. Links are reliable : if a correct process 𝑝 𝑖 sends a message m, eventually each correct process 𝑝 𝑘 receives m once. Losses, changes, duplication or creation of spurious messages are not allowed in reliable links. However, messages may be delayed and delivered in a different order than they were sent. broadcast 𝑖 ( 𝑚 ) and received 𝑖 ( 𝑚 ) are the operations used by a process 𝑝 𝑖 to transmit a message m through these reliable links. The system S is asynchronous, that is, with regard to processes, we consider that processes of S execute by taking steps, and the time required to execute each step is finite but unbounded; regarding links, unless otherwise stated, the time a message needs to get from the sender process to the receiver process is finite but unbounded. 2.2. Failure model Let f be the maximum number of processes in Π that can fail. In the system S up to 𝑓 < 𝑛 /	{ "page_id": null, "source": 7342, "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 processes is denoted by Crashed. • Omission A process 𝑝 𝑖 fails by omission if 𝑝 𝑖 deviates from its algorithm, but only by avoiding to execute communication operations. The set of omitting processes is denoted by Omitting. From all possible omission failures, we solely consider in S the following three subtypes. – Deaf A process 𝑝 𝑖 is denoted deaf if 𝑝 𝑖 eventually stops executing all receiving operations. The set of deaf processes is denoted by Deaf. – Mute A process 𝑝 𝑖 is denoted mute if 𝑝 𝑖 eventually stops executing all sending operations. The set of mute processes is denoted by Mute. – Autistic A process 𝑝 𝑖 is denoted autistic if 𝑝 𝑖 eventually stops executing all sending and receiving operations. The set of autistic processes is denoted by Autistic. • Mortal Byzantine A process 𝑝 𝑖 is denoted mortal Byzantine if it deviates from its algorithm by executing arbitrary operations whenever 𝑝 𝑖 wants, but eventually 𝑝 𝑖 crashes permanently. The set of mortal Byzantine processes is denoted by MortalByz. A process 𝑝 𝑖 ∈ Π is correct if it never makes a failure. Otherwise, 𝑝 𝑖 is faulty. Thus, we denote the set of correct processes by Correct and the set of faulty processes by Faulty. Observe that every Autistic process eventually stops executing sending and receiving operations. Hence, Autistic = Deaf ∩ Mute . Besides, every crashed process eventually stops executing sending and receiving operations,	{ "page_id": null, "source": 7342, "title": "from dpo" }
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 . Note that in our system S we only consider what we call degenerative Byzantine failures, that is, when a process 𝑝 𝑖 starts failing, it degrades and it will eventually fail permanently (by either crashing or omitting communication operations). 2.3. Relation between failures, identities and communication Now that we have introduced the failure model we can go back to explaining in more depth the behavior of some communication features of system S. If a correct process 𝑝 𝑖 invokes 𝑏 𝑟 𝑜 𝑎 𝑑 𝑐 𝑎 𝑠 𝑡 𝑖 ( 𝑚 ) , a copy of message m certainly will be sent to all processes in the system S using the corresponding unidirectional link. If 𝑝 𝑖 is a crashed or omitting process, there is no guarantee that a copy of m will be sent to every process in S. Finally, note that a mortal Byzantine process 𝑝 𝑖 executing 𝑏 𝑟 𝑜 𝑎 𝑑 𝑐 𝑎 𝑠 𝑡 𝑖 ( 𝑚 ) will not even guarantee that exact copies of m will be sent to all processes. For example, let 𝑝 𝑖 , 𝑝 𝑘 , 𝑝 𝑠 , 𝑝 𝑟 ∈ Π , let 𝑝 𝑖 ∈ MortalByz , if 𝑝 𝑖 issues 𝑏 𝑟 𝑜 𝑎 𝑑 𝑐 𝑎 𝑠 𝑡 𝑖 ( 𝑚 ) , it can send m to process 𝑝 𝑘 , 𝑚 ′ ≠ 𝑚 to process 𝑝 𝑠 , and nothing to process 𝑝 𝑟 . We	{ "page_id": null, "source": 7342, "title": "from dpo" }
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 message invalid and will discard it upon reception, so the algorithms proposed only need to consider valid messages. In our system S we assume that messages can be uniquely identified. Thus, if a message m is received by a correct process more than once, subsequent copies of m may be identified and discarded upon reception, so the algorithms proposed do not need to deal with multiple copies of the same message. Since we assume that links are reliable in system S, the network will not generate duplicates of messages. However, mortal Byzantine processes might send multiple copies of the same message to some process or even corrupt messages (messages that do not follow the protocol specification). For the sake of simplicity, we assume that, if the receiver is a correct process, it will discard every duplicate or corrupt message upon reception. Finally, observe that, if 𝑝 𝑖 is a mortal Byzantine process, it might not discard the invalid, duplicate or corrupt messages and can process them in whatever way it wants. The behavior of a mortal Byzantine process is unpredictable. 3. The omega failure detector class (Ω) It is very well known in the literature the result of that states that Consensus cannot be solved in asynchronous systems under the crash failure model where processes are benign and at least one process may crash. In this failure model, we say that processes are benign (as apposite to Byzantine) because they cannot deviate from	{ "page_id": null, "source": 7342, "title": "from dpo" }
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 returns information related to faulty processes. Ω stands out among the other failure detector classes because it is the weakest failure detector class that allows solving Consensus when a majority of processes never crash . Ω is the weakest class because the information returned by this failure detector is necessary and sufficient to solve Consensus . The systems defined in , , use the benign crash failure model of . In this benign crash failure model processes only fail by crashing (i.e., physical failure). The specification of the Ω failure detector class in these systems states that an Ω failure detector eventually outputs the same non-crashed process 𝑝 𝑙 (as leader) to all non-faulty processes. In our system S, faulty processes include crashed, deaf, mute, autistic and mortal Byzantine processes. None of them should be chosen as an eventual leader by the failure detector. Mortal Byzantine and crashed processes can be detected by traditional Ω failure detectors. However, in our system s, we need to avoid choosing as leader a deaf, mute or autistic process. Hence, our failure detector needs to cope with transmission failures as well as physical failures. Therefore, we need to adapt the definition of to include the transmission failures of system S. Roughly speaking, the Ω failure detector class in our system S eventually outputs as leader the same correct process 𝑝 𝑙 to all correct processes. More formally, Definition 1 Ω A failure detector D, with a function leader 𝑖 ( ) that returns a process identity to process 𝑝	{ "page_id": null, "source": 7342, "title": "from dpo" }
𝑖 , belongs to Class Ω if it satisfies the following property: let leader 𝑖 ( ) 𝜏 be the value returned to process 𝑝 𝑖 by function leader 𝑖 ( ) at time τ, then there is a time 𝜏 ′ and some process 𝑝 𝑙 ∈ Correct such that for all 𝜏 ≥ 𝜏 ′ and for all 𝑝 𝑖 ∈ Correct , 𝐷 . 𝑙 𝑒 𝑎 𝑑 𝑒 𝑟 𝑖 ( ) 𝜏 = 𝑝 𝑙 . 4. Reliable FIFO order broadcast (RFLOB) We introduce, in this section, a broadcast primitive called reliable FIFO local order broadcast (RFLOB), used for inter-process communication in system S. This RFLOB primitive, as we will show, does not strengthen the model of system S and it is used in this paper to simplify the consensus algorithm proposed in Section 5. We define the RFLOB primitive for a Byzantine system. Hence, since our degenerative Byzantine failure model is a particular case of Byzantine failures, we can use it in our system S. 4.1. Definition of the RFLOB primitive The RFLOB primitive guarantees that correct processes deliver the same sequence of messages if they were broadcast by the same (correct or not) process, and that messages broadcast by each process 𝑝 𝑘 are delivered by all correct processes in the causal order they were sent by 𝑝 𝑘 . More formally: Definition 2 RFLOB The reliable FIFO local order broadcast (RFLOB) primitive, when invoked by a process 𝑝 𝑖 , has two operations: RFLOB _ broadcast 𝑖 ( ) and RFLOB _ delivered 𝑖 ( ) , which preserve the following five properties: • Validity: A correct process 𝑝 𝑖 executes RFLOB _ delivered 𝑖 ( 𝑚 ) at most once. If RFLOB _ delivered 𝑖 ( 𝑚 ) was due to	{ "page_id": null, "source": 7342, "title": "from dpo" }
a correct process 𝑝 𝑘 , then RFLOB _ broadcast 𝑘 ( 𝑚 ) must have been executed previously by 𝑝 𝑘 . • Termination: If a correct process 𝑝 𝑖 executes RFLOB _ broadcast 𝑖 ( 𝑚 ) , then each correct process 𝑝 𝑘 will execute RFLOB _ delivered 𝑘 ( 𝑚 ) . • Agreement: If a correct process 𝑝 𝑖 executes RFLOB _ delivered 𝑖 ( 𝑚 ) first and, later, RFLOB _ delivered 𝑖 ( 𝑚 ′ ) due to the same process 𝑝 𝑘 , then every correct process 𝑝 𝑗 must execute RFLOB _ delivered 𝑗 ( 𝑚 ) first, and RFLOB _ delivered 𝑗 ( 𝑚 ′ ) later. • FIFO Order: If a correct process 𝑝 𝑖 executes RFLOB _ delivered 𝑖 ( 𝑚 ) first and, later, RFLOB _ delivered 𝑖 ( 𝑚 ′ ) both due to the same correct process 𝑝 𝑘 , then 𝑝 𝑘 must have executed RFLOB _ broadcast 𝑘 ( 𝑚 ) first and RFLOB _ broadcast 𝑘 ( 𝑚 ′ ) later. • Local Order: If a correct process 𝑝 𝑖 executes RFLOB _ delivered 𝑖 ( 𝑚 ) first and RFLOB _ broadcast 𝑖 ( 𝑚 ′ ) later, then every correct process 𝑝 𝑗 executes RFLOB _ delivered 𝑗 ( 𝑚 ) first and RFLOB _ delivered 𝑗 ( 𝑚 ′ ) later. Observe that Definition 2 forces all correct processes to deliver the same sequence of messages sent by the same process 𝑝 𝑘 , regardless of whether 𝑝 𝑘 is correct or not (Agreement), but only enforces FIFO order to messages sent by correct processes. Besides, it enforces causal order to every message sent by the same process (Local Order). Observe also that a message cannot be lost if	{ "page_id": null, "source": 7342, "title": "from dpo" }
it was sent by a correct process (Termination), but the RFLOB primitive does not guarantee that a message sent by a faulty process is delivered. The RFLOB primitive in a system with Byzantine failures has been previously defined in the literature , but, to our knowledge, it has not been previously implemented in a system with degenerative Byzantine failures and unknown membership. Following, we present (and prove the correctness of) an implementation of the RFLOB primitive as a useful tool to solve consensus in S. 4.2. The asynchronous Byzantine system B Let B be a system such as S but with the only difference that faulty processes are Byzantine . A process 𝑝 𝑖 is Byzantine if it deviates from its algorithm by executing arbitrary operations whenever it wants. The set of Byzantine processes is denoted by Byz. Note that, unlike the mortal Byzantine processes of S, a Byzantine process in B might never crash. 4.3. Implementation of RFLOB in B Algorithm 𝐴 RFLOB , presented in Fig. 1, works in the following way. Each message m sent using the RFLOB _ broadcast 𝑖 ( 𝑚 ) function is acknowledged by all processes which receive it. When enough processes have acknowledged that message, all of them execute RFLOB _ delivered 𝑖 ( 𝑚 ) . Download: Download high-res image (173KB) Download: Download full-size image Fig. 1. RFLOB primitive in system B (code for process pi). In order to satisfy FIFO and Local Order, Algorithm 𝐴 RFLOB uses the known vector clock technique , (which is and extension of logical clocks ). Thus, each process 𝑝 𝑖 keeps three variables: members 𝑖 (which stores the processes known by process 𝑝 𝑖 ), seq 𝑖 (which stores the number of messages sent by process 𝑝 𝑖 ) and next 𝑖	{ "page_id": null, "source": 7342, "title": "from dpo" }
(which stores the vector clock of process 𝑝 𝑖 ). Since the membership is not known a priori, each time a new process is known, it is included in members 𝑖 and its expected sequence number is added to the vector clock next 𝑖 and set to 1. Note that next 𝑖 is a hash vector indexed by process identifiers. Since membership is unknown, different processes may have different sets of keys. Abusing of notation, in the algorithm, we use next 𝑘 [ 𝑗 ] ∉ next 𝑖 to test, in an easy way, if key j is not a key in next 𝑖 . Algorithm 𝐴 RFLOB is an event-driven algorithm. Events are triggered by the invocation of a primitive or the arrival of messages. When a process 𝑝 𝑖 invokes RFLOB _ broadcast 𝑖 ( 𝑚 ) , it increases its sequence number seq 𝑖 and executes broadcast 𝑖 ( MSG , 𝑚 , seq 𝑖 , next 𝑖 , 𝑖 ) . When messages arrive, they are processed in two steps: first they are processed by task T1 and then by task T2. Thus, the reception of a message may trigger multiple events in a predefined sequence. Each when clause is executed atomically, i.e., two when clauses may not be executed concurrently. Task T1 (Lines 9–13) is executed for every message received to update the known membership and add the new processes (those processes for which there is an entry in the vector clock next 𝑘 that comes in the message but for which there is no entry in the local vector clock next 𝑖 ) to the local vector clock. Each clause in task T2 is asynchronously executed whenever its condition is satisfied. When process 𝑝 𝑖 receives a ( MSG , − , 𝑠 𝑘	{ "page_id": null, "source": 7342, "title": "from dpo" }
, − , 𝑘 ) message from process 𝑝 𝑘 for the first time, it executes broadcast 𝑖 ( ACK , 𝑚 , 𝑠 𝑘 , next 𝑘 , 𝑘 ) , where m and next 𝑘 are the message and vector clock, respectively, received from process 𝑝 𝑘 (Lines 14–16). When process 𝑝 𝑖 has received a ( ACK , 𝑚 , 𝑠 𝑘 , next 𝑘 , 𝑘 ) message from 𝑛 − 𝑓 different processes, it broadcasts a ( AGREE , 𝑚 , 𝑠 𝑘 , next 𝑘 , 𝑘 ) message (Lines 17–18). When process 𝑝 𝑖 has received 𝑓 + 1 of these AGREE messages from different processes, at least one of them comes from a correct process, so it rebroadcasts them to help reaching a number of 𝑛 − 𝑓 such messages from different processes (Lines 19–20). Finally, when 𝑛 − 𝑓 ( AGREE , 𝑚 , 𝑠 𝑘 , next 𝑘 , 𝑘 ) messages from different processes are received and all messages which must be delivered before m (to satisfy both FIFO order and local order) have already been delivered by process 𝑝 𝑖 (i.e., 𝑠 𝑘 = next 𝑖 [ 𝑘 ] and for all 𝑟 ∈ members 𝑖 , next 𝑘 [ 𝑟 ] ∉ next 𝑘 ∨ next 𝑖 [ 𝑟 ] ≥ next 𝑘 [ 𝑟 ] ), process 𝑝 𝑖 executes RFLOB _ delivered 𝑖 ( 𝑚 ) and updates its vector clock accordingly (Lines 21–23). Note that the condition of Line 21 can always be evaluated since every message received has been previously processed by task T1, so if there is an entry for process 𝑝 𝑗 in next 𝑘 , then there is an entry for process 𝑝 𝑗 in next 𝑖 . 4.4. Correctness	{ "page_id": null, "source": 7342, "title": "from dpo" }
of algorithm 𝐴 RFLOB Lemma 1 Algorithm 𝐴 RFLOB satisfies the Validity property of the RFLOB primitive when 𝑓 < 𝑛 / 3 . Proof Note first that RFLOB _ delivered 𝑖 ( 𝑚 ) is only executed at Line 22, and it is executed only once for each process 𝑝 𝑘 and sequence number next 𝑖 [ 𝑘 ] , since next 𝑖 [ 𝑘 ] is incremented at Line 23. Recall that communication channels in our system are reliable. Hence, messages cannot be altered during transmission. Thus, if RFLOB _ delivered 𝑖 ( 𝑚 ) is executed by process 𝑝 𝑖 (at Line 22), then 𝑝 𝑖 must have received 𝑛 − 𝑓 ( AGREE , 𝑚 , 𝑠 𝑘 , next 𝑘 , 𝑘 ) messages from different processes. Since 𝑓 < 𝑛 / 3 , more than 𝑛 / 3 came from correct processes. Correct processes may only send these messages at Lines 20 or 18. At Line 20, it must hold that 𝑓 + 1 previous ( AGREE , 𝑚 , 𝑠 𝑘 , next 𝑘 , 𝑘 ) messages have already been received by the process which executes this line. Thus, at least one correct process must have previously sent an ( AGREE , 𝑚 , 𝑠 𝑘 , next 𝑘 , 𝑘 ) message at Line 20 or Line 18. Line 18 can only be executed by a correct process if it has already received 𝑛 − 𝑓 ( ACK , 𝑚 , next 𝑘 , 𝑘 ) messages (Line 17), more than 𝑛 / 3 from correct processes. Since ( ACK , 𝑚 , next 𝑘 , 𝑘 ) messages are only sent by correct processes at Line 16, a ( MSG , 𝑚 , 𝑠 𝑘 , next 𝑘 , 𝑘	{ "page_id": null, "source": 7342, "title": "from dpo" }
) message must have been previously received by more than 𝑛 / 3 correct processes. Correct processes may only send this message at Line 8 as a consequence of executing RFLOB _ broadcast 𝑘 ( 𝑚 ) . Hence, If RFLOB _ delivered 𝑖 ( 𝑚 ) was due to a correct process 𝑝 𝑘 , then RFLOB _ broadcast 𝑘 ( 𝑚 ) must have been executed previously by 𝑝 𝑘 . Lemma 2 Algorithm 𝐴 RFLOB satisfies the Termination property of the RFLOB primitive when 𝑓 < 𝑛 / 3 . Proof If a correct process 𝑝 𝑖 executes RFLOB _ delivered 𝑖 ( 𝑚 ) (at Line 22), then 𝑝 𝑖 must have received at least 𝑛 − 𝑓 ( AGREE , 𝑚 , 𝑠 𝑘 , next 𝑘 , 𝑘 ) messages from different processes (more than 𝑛 / 3 of them from correct processes). If more than 𝑛 / 3 correct processes sent the ( AGREE , 𝑚 , 𝑠 𝑘 , next 𝑘 , 𝑘 ) message (recall that 𝑓 < 𝑛 / 3 ), then the condition of Line 19 must hold for all correct processes, so all of them will send the ( AGREE , 𝑚 , 𝑠 𝑘 , next 𝑘 , 𝑘 ) message at Line 20. Thus, every correct process will receive at least 𝑛 − 𝑓 such messages (all of them coming from correct processes). Hence, the condition of Line 21 will hold for every correct process and all of them will execute RFLOB _ delivered 𝑖 ( 𝑚 ) . Lemma 3 Algorithm 𝐴 RFLOB satisfies the Agreement property of the RFLOB primitive when 𝑓 < 𝑛 / 3 . Proof Note that a correct process expects messages from other processes in a deterministic sequence. When process	{ "page_id": null, "source": 7342, "title": "from dpo" }
𝑝 𝑖 receives a message from process 𝑝 𝑘 for the first time, it sets its expected sequence number next 𝑖 [ 𝑘 ] to 1 (see Lines 9–13). Then, each time it delivers a message from 𝑝 𝑘 (at Line 22), it increments its expected sequence number (Line 23). Thus, messages from a process 𝑝 𝑘 are delivered in increasing order of their sequence number. Hence, if a correct process 𝑝 𝑖 executes RFLOB _ delivered 𝑖 ( 𝑚 ) before it executes RFLOB _ delivered 𝑖 ( 𝑚 ′ ) , both due to the same process 𝑝 𝑘 , then the sequence number of m must be smaller than that of 𝑚 ′ . Since all correct processes deliver messages from each correct sending process in increasing order of their sequence number, any other correct process 𝑝 𝑗 must execute RFLOB _ delivered 𝑗 ( 𝑚 ) before RFLOB _ delivered 𝑗 ( 𝑚 ′ ) . Lemma 4 Algorithm 𝐴 RFLOB satisfies the FIFO Order property of the RFLOB primitive when 𝑓 < 𝑛 / 3 . Proof Assume that a correct process 𝑝 𝑖 executes (at Line 22) RFLOB _ delivered 𝑖 ( 𝑚 ) first and RFLOB _ delivered 𝑖 ( 𝑚 ′ ) later, both due to the same correct process 𝑝 𝑘 . Then, the sequence number associated with m must be smaller than that of 𝑚 ′ (recall that messages from the same process 𝑝 𝑘 are delivered in increasing order of the sequence number). The sequence number is assigned when the message is broadcast, i.e. the sender sets the sequence number (Lines 6–8) and, if it is a correct process, these sequence numbers are assigned in increasing order. Hence, 𝑝 𝑘 must have executed RFLOB _ broadcast 𝑖 ( 𝑚	{ "page_id": null, "source": 7342, "title": "from dpo" }
) before RFLOB _ broadcast 𝑖 ( 𝑚 ′ ) . Lemma 5 Algorithm 𝐴 RFLOB satisfies the Local Order property of the RFLOB primitive when 𝑓 𝑠 𝑘 when 𝑝 𝑖 executed broadcast 𝑖 ( MSG , 𝑚 ′ , seq 𝑖 , next 𝑖 , 𝑖 ) and either next 𝑘 did not contain an entry for 𝑝 𝑖 , or next 𝑘 [ 𝑖 ] ≤ next 𝑖 [ 𝑖 ] . Consider now the behavior 𝑝 𝑗 . When 𝑝 𝑗 executes RFLOB _ delivered 𝑗 ( 𝑚 ′ ) , it must have received 𝑛 − 𝑓 ( AGREE , 𝑚 ′ , 𝑠 𝑖 , next 𝑖 , 𝑖 ) messages from different processes and, for each process r for which there is an entry in next 𝑖 , next 𝑖 [ 𝑟 ] ≤ next 𝑗 [ 𝑟 ] (as required by Line	{ "page_id": null, "source": 7342, "title": "from dpo" }
21). However, since process 𝑝 𝑗 has not executed RFLOB _ delivered 𝑗 ( 𝑚 ) yet, next 𝑗 [ 𝑘 ] must be less or equal than 𝑠 𝑘 . Hence, next 𝑗 [ 𝑘 ] < next 𝑖 [ 𝑘 ] and we reach a contradiction, so 𝑝 𝑗 must execute RFLOB _ delivered 𝑗 ( 𝑚 ) before executing RFLOB _ delivered 𝑗 ( 𝑚 ′ ) . Theorem 1 Algorithm 𝐴 RFLOB correctly implements the RFLOB primitive when 𝑓 < 𝑛 / 3 . Proof Direct from Lemma 1, Lemma 2, Lemma 3, Lemma 4, Lemma 5. 5. Consensus in S with Ω and RFLOB As we have previously mentioned, Consensus cannot be solved in asynchronous systems when processes can crash . To circumvent this impossibility result, we enrich the asynchronous system S with a failure detector D of Class Ω. By definition, D can be whatever algorithm that preserves the properties of Definition 1. We denote by 𝑆 [ Ω ] the asynchronous system S empowered with any failure detector D of the Ω failure detector class. As we have also mentioned earlier, for the sake of simplicity, in the algorithm proposed to solve consensus in 𝑆 [ Ω ] , inter-process communication will be realized using the RFLOB primitive. 5.1. Definition of Consensus There are several definitions of Consensus in systems where processes can have a Byzantine behavior (i.e., when there are processes in the system that can behave arbitrarily). From all of them, we consider in this paper one of the most common . In this type of consensus, each correct process initially proposes a value and, eventually, all correct processes decide the same value. More formally, Definition 3 Consensus Each correct process proposes a value, and the decision taken by each correct	{ "page_id": null, "source": 7342, "title": "from dpo" }
process must preserve the following three properties: • Validity The value v must be decided by each correct process when all correct processes propose the same value v. • Termination Every correct process eventually decides a value. • Agreement All correct processes decide the same value. The value proposed by a correct process can be whatever. Then, the set of proposed values can have an arbitrary size. This version of Consensus is also called multi-valued . Observe that a mortal Byzantine process cannot be forced to propose a value because it can avoid to make the proposal on purpose, due to the fact that it can behave arbitrarily. 5.2. Implementing Consensus in 𝑆 [ Ω ] with RFLOB In Fig. 2, we propose Algorithm 𝐴 𝐶 to solve Consensus in 𝑆 [ Ω ] (the asynchronous system S enriched with the failure detector Ω). Note that the processes in S know the size n of the system but they do not know the membership. The failure model of S includes processes that, when they start failing, they degrade and eventually will make failures forever (by crashing or omitting communication operations permanently), and the maximum number of faulty processes in S is less than one third, i.e. \| Faulty \| = 𝑓 < 𝑛 / 3 . Download: Download high-res image (255KB) Download: Download full-size image Fig. 2. Algorithm 𝐴 𝐶 for solving Consensus in S[Ω], i.e., in an asynchronous system enriched with a failure detector of Class Ω, with unknown membership, degenerative Byzantine failures, and where f < n/3 (code of pi). 5.2.1. Description of the Consensus Algorithm 𝐴 𝐶 Algorithm 𝐴 𝐶 , shown in Fig. 2, is implemented by function propose( 𝑣 𝑖 ) which is executed by each process 𝑝 𝑖 . This function uses the following	{ "page_id": null, "source": 7342, "title": "from dpo" }
three local variables: 𝑟 𝑖 to store the current round of Task T1, est 𝑖 to store the value to be proposed by process 𝑝 𝑖 at round 𝑟 𝑖 and decided 𝑖 to know if this process 𝑝 𝑖 has already diffused its wish to take a decision. Function 𝐷 . leader 𝑖 ( ) is used by process 𝑝 𝑖 to invoke the failure detector D of Class Ω to get its leader process in round 𝑟 𝑖 . The algorithm runs two different tasks: T1 and T2. Task T1 is run iteratively in asynchronous rounds until process 𝑝 𝑖 is able to take a decision, while T2 is an event-driven task activated by the reception of enough ( DEC , 𝑣 ) messages to make a decision (Line 27). Once process 𝑝 𝑖 makes a decision v in task T2 (Line 29), it never changes this decided value v. Rounds start at 0 and est 𝑖 is set to 𝑝 𝑖 's proposal 𝑣 𝑖 (Line 1). In each round, process 𝑝 𝑖 sends its proposal in 𝑒 𝑠 𝑡 𝑖 to all the processes in the system (Line 6) and waits until proposals from 𝑛 − 𝑓 different processes are delivered to this process (Line 7). The current estimation est 𝑖 is set to the most common value received at Line 7. In case of a tie, a value is chosen by all correct processes in a deterministic way among all the values with the greatest cardinality. Then it is diffused at Line 10 with the trace which proves that est 𝑖 was indeed the most common value found. Then it waits, at Line 11, for the BEST message from the leader process. Messages with invalid traces are discarded to avoid being cheated by Byzantine processes.	{ "page_id": null, "source": 7342, "title": "from dpo" }
Note also that, eventually, a correct process will be chosen as the leader and all messages RFLOB_broadcast by correct processes are eventually RFLOB_delivered by every correct process, so a correct process will eventually stop waiting at Line 11. During the COMMIT phase, processes RFLOB_broadcast the estimations they got from their leader processes (Line 12) and wait until 𝑛 − 𝑓 COMMIT messages from different processes have been RFLOB_delivered (at Line 13). In case 𝑝 𝑖 has already diffused its wish to take a decision (Line 19), it will not change it (i.e., 𝑒 𝑠 𝑡 𝑖 will never be changed again). So, process 𝑝 𝑖 proceeds directly to the next round. In case 𝑝 𝑖 has not diffused its wish to take a decision yet (i.e., 𝑝 𝑖 has not executed Line 19 yet), it tests if there is a value which has been committed by 𝑛 − 𝑓 processes. In such a case, a majority of the correct processes must have chosen that value as best, so 𝑝 𝑖 diffuses its wish to make a decision on that value and broadcasts it (Lines 16–19). In case there is a value v that has been chosen as best by a majority of the 𝑛 − 𝑓 processes, that value v is adopted for next round (Lines 21–22). Finally, if 𝑓 + 1 different processes inform process 𝑝 𝑖 of their wish to take a decision v (Line 27), then 𝑝 𝑖 stops task T1 (Line 28) and decides v (Line 29). Since there are at most f mortal Byzantine processes, it is guaranteed that at least one correct process has broadcast its wish of taking this decision at Line 19. 5.2.2. Correctness of 𝐴 𝐶 First we prove some basic remarks that will help proving that Algorithm 𝐴 𝐶 is	{ "page_id": null, "source": 7342, "title": "from dpo" }
valid to solve Consensus. Remark 1 At each round r, all correct processes receive the same sets of ( PROP , 𝑟 , − , − ) and ( COMMIT , 𝑟 , − ) messages, although each of them might consider a different subset at Lines 7 and 13 respectively. Proof At each round r, each correct process sends one ( PROP , 𝑟 , − , − ) / ( COMMIT , 𝑟 , − ) message, and, from the Termination property of RFLOB (see Definition 2), all these messages are received by all correct processes. From the Agreement property of RFLOB, messages sent by the same (correct or not) process 𝑝 𝑘 are received in the same order by each correct process 𝑝 𝑖 . Note that only mortal Byzantine processes may send more than one ( PROP , 𝑟 , − , − ) / ( COMMIT , 𝑟 , − ) message even with different values. If this happens, only the first one received will be processed by each correct process 𝑝 𝑖 at Lines 7 and 13. Hence, 𝑝 𝑖 will never pick up a ( PROP , 𝑟 , 𝑣 ′ , 𝑘 ) / ( COMMIT , 𝑟 , 𝑒 ′ ) message if a previous ( PROP , 𝑟 , 𝑣 , 𝑘 ) / ( COMMIT , 𝑟 , 𝑒 ) message has been received from the same process 𝑝 𝑘 . Therefore, at each round r, all correct processes receive the same sets of ( PROP , 𝑟 , − , 𝑝 𝑘 ) and ( COMMIT , 𝑟 , − ) messages. Note that two correct processes might consider different sets of messages at Lines 7 or 13 since a process might receive up to n messages per	{ "page_id": null, "source": 7342, "title": "from dpo" }
round and phase, but only 𝑛 − 𝑓 messages are considered by the correct processes at Lines 7 and 13 respectively. Corollary 1 Among any two correct processes, the sets of messages they consider at Lines 7 and 13 have at least 𝑛 − 2 𝑓 common messages. Proof From Remark 1, all correct processes receive the same set of messages at the same round. Since they may receive up to n messages and they only consider 𝑛 − 𝑓 of them, the worst case arises when at most f messages not considered by a process are considered by another process at the expense of other f messages. Hence, the two subsets must have at least 𝑛 − 2 𝑓 common messages. Corollary 2 The sets of messages considered by two correct processes at Lines 7 and 13 at the same round may only differ in up to 2f messages. Proof Direct from Remark 1 and Corollary 1. Remark 2 The consistency of a ( BEST , 𝑟 , est , trace ) message can be verified by every correct process. Proof From the definition of the RFLOB primitive, by the time a correct process delivers a ( BEST , 𝑟 , est , trace ) message, it must have delivered the PROP messages whose content is present in trace, prior to the reception of the BEST message. If a correct process has not delivered those PROP messages (or the values are not the same), then it can discard the BEST message for having a fake trace. Remark 3 If, at round r, all correct processes have the same estimation est, they do not change that estimation. Proof If all ( 𝑛 − 𝑓 ) correct processes have the same estimation est at round r, then all of them propose	{ "page_id": null, "source": 7342, "title": "from dpo" }
that estimation in Line 6. Since there are at most f estimations which differ from est (those of the faulty processes), all of them will choose est as their best value (at Line 8) and diffuse it at Line 10. From Remark 2, BEST messages from Byzantine processes may be validated by every correct process, and may be discarded for inconsistency. Hence, only BEST messages whose estimation is est are accepted by correct processes and all of them will broadcast a ( COMMIT , 𝑟 , est ) at Line 12, so all of them will deliver at least 𝑛 − 2 𝑓 such messages. Thus, the assignment at Line 22 will keep the previous value of est 𝑖 . Remark 4 Let 𝑣 ≠ 𝑣 ′ . If a correct process 𝑝 𝑖 executes RFLOB _ broadcast 𝑖 ( DEC , 𝑣 ) in Line 19 at round r, then no other correct process 𝑝 𝑗 may execute RFLOB _ broadcast 𝑗 ( DEC , 𝑣 ′ ) in Line 19 at the same round r. Proof By the way of contradiction, assume that 𝑣 ≠ 𝑣 ′ and, at round r, process 𝑝 𝑖 executes RFLOB _ broadcast 𝑖 ( DEC , 𝑣 ) in Line 19 while process 𝑝 𝑗 executes RFLOB _ broadcast 𝑗 ( DEC , 𝑣 ′ ) in Line 19. If 𝑝 𝑖 executes RFLOB _ broadcast 𝑖 ( DEC , 𝑣 ) , then it must have considered 𝑛 − 𝑓 ( COMMIT , 𝑟 , 𝑣 ) messages at Line 13. On the contrary, if 𝑝 𝑗 executes RFLOB _ broadcast 𝑗 ( DEC , 𝑣 ′ ) , then it must have considered 𝑛 − 𝑓 ( COMMIT , 𝑟 , 𝑣 ′ ) messages at Line 13. From Corollary	{ "page_id": null, "source": 7342, "title": "from dpo" }
2, the sets of messages considered by processes 𝑝 𝑖 and 𝑝 𝑗 at Line 13 may only differ in up to 2f messages. However, since 𝑛 − 𝑓 > 2 𝑓 , this contradicts the initial hypothesis, and, hence, we reach a contradiction. Remark 5 If, at round r, a process 𝑝 𝑖 executes RFLOB _ broadcast 𝑖 ( DEC , 𝑣 ) at Line 19, then every correct process detects at least 𝑛 − 2 𝑓 ( COMMIT , 𝑟 , 𝑣 ) messages with the same value v and sets its estimation to v. Proof If a process 𝑝 𝑖 executes RFLOB _ broadcast 𝑖 ( DEC , 𝑣 ) at Line 19 at round r, then it must have detected at least 𝑛 − 𝑓 ( COMMIT , 𝑟 , 𝑣 ) messages with the same value v at Line 13 and, from Corollary 1, every other correct process must have at least 𝑛 − 2 𝑓 common messages. Hence, any other correct process 𝑝 𝑗 must detect at least 𝑛 − 2 𝑓 ( COMMIT , 𝑟 , 𝑣 ) messages, and will set its estimation to v at Line 22. Remark 6 Eventually, all faulty processes stop sending messages. Proof In the case of mortal Byzantine processes, they eventually crash, so they stop sending messages. In the case of mute processes, they eventually are unable to send messages. Finally, in the case of a deaf process, it will eventually be unable to complete the wait sentences of Lines 7, 11 or 13. Thus, it will also stop sending messages because it will get blocked waiting forever to receive messages at Lines 7, 11 or 13. Lemma 6 Validity: The value v must be decided by each correct process when all correct processes propose the	{ "page_id": null, "source": 7342, "title": "from dpo" }
same value v. Proof If all correct processes propose the same value v, then, from Remark 3, they will not change it. If all the faulty processes store other values (either the same or different) than v, then it is possible that the condition of Line 16 would not hold until all the faulty processes either crash or become mute but, from Remark 6, eventually, all faulty processes stop sending messages. When, no faulty process is able to send messages, the condition of Line 16 will hold for all correct process. When that happens, all of them send the corresponding ( DEC , 𝑣 ) message, and all of them receive at least 𝑓 + 1 such messages at Line 27. Hence, they will decide v (Line 29). Lemma 7 Agreement: All correct processes decide the same value. Proof By the way of contradiction, let 𝑣 ≠ 𝑣 ′ and assume that two correct processes 𝑝 𝑖 and 𝑝 𝑗 execute RFLOB _ broadcast 𝑖 ( DEC , 𝑣 ) and RFLOB _ broadcast 𝑗 ( DEC , 𝑣 ′ ) respectively at Line 19. From Remark 4, that cannot happen at the same round. Then, assume, without loss of generality, that 𝑝 𝑖 executes RFLOB _ broadcast 𝑖 ( DEC , 𝑣 ) at round r and 𝑝 𝑗 executes RFLOB _ broadcast 𝑗 ( DEC , 𝑣 ′ ) at round 𝑟 ′ , 𝑟 ′ > 𝑟 . However, from Remark 5, if a process 𝑝 𝑖 executes RFLOB _ broadcast 𝑖 ( DEC , 𝑣 ) at Line 19, then every correct process sets its estimation to v. Then, all correct processes will propose v in the following round and, from Lemma 6, all correct processes will eventually decide v, what contradicts the initial assumption. Thus,	{ "page_id": null, "source": 7342, "title": "from dpo" }
it is impossible that two correct processes decide different values. Lemma 8 Termination: Every correct process eventually has to decide a value. Proof Note first that every wait sentence in the algorithm of Fig. 2 ends in a finite time since there are 𝑛 − 𝑓 correct processes and, from the definition of Ω, 𝐷 . leader 𝑖 ( ) eventually returns the same correct process to every correct process 𝑝 𝑖 . Hence, at some round r, all correct processes get the same estimation v in Line 11. Then, all of them broadcast COMMIT messages with estimation v in Line 12. Thus, even if Byzantine processes broadcast COMMIT messages with different estimations in Line 12, every correct process will get at least 𝑛 − 2 𝑓 COMMIT messages with estimation v in Line 13. If a correct process gets 𝑛 − 𝑓 such messages, it will assume that estimation v for the following round at Line 17. Otherwise, it will get at least 𝑛 − 2 𝑓 such messages and it will assume that estimation at Line 22. Then, two cases arise: first, if at least 𝑓 + 1 processes execute Line 19, then all correct processes will eventually satisfy the condition of Line 27 and will decide v at Line 29; second, since all correct processes have the same estimation for the following round, then, from Lemma 6, all correct processes will eventually decide v. Theorem 2 The algorithm 𝐴 𝐶 of Fig. 2 solves Consensus in 𝑆 [ 𝛺 ] . Proof From Lemma 6, Lemma 7 and Lemma 8, validity, agreement and termination properties are satisfied. Therefore, from Definition 3, Algorithm 𝐴 𝐶 solves consensus. 6. On the implementability of Ω in a system with degenerative Byzantine failures The aim of this section is to find	{ "page_id": null, "source": 7342, "title": "from dpo" }
weak conditions to implement Ω. No failure detector can be implemented in asynchronous systems under the (benign or not) crash failure model . Thus, we need to include synchronization assumptions in the system S in order to make the implementation of a failure detector (of Class Ω) possible. We first consider a traditional synchronous system 𝑆 𝑠 where the membership is known and there are no mortal Byzantine processes. Then, we study in Section 6.1 the minimum number of different types of links in 𝑆 𝑠 necessary for a failure detector of Class Ω to be implementable. Due to its wide use in the literature , , , , , we consider the system 𝑆 𝑠 focusing on two types of links: eventually-timely and lossy-asynchronous. Later, we present in Section 6.2 an implementation of a failure detector of Class Ω fulfilling the minimal condition achieved in Section 6.1, in a system 𝑆 𝑝 with degenerative Byzantine failures as in S, where up to n processes can be faulty, with partial synchrony, and where the membership is unknown. 6.1. Minimal conditions on the links In this section we prove that an Ω failure detector cannot be implemented in 𝑆 𝑠 if: a) there is not a path of eventually-timely links between some correct process 𝑝 𝑙 and the other correct processes, and b) there is not a path of eventually-timely links between some other correct process and this process 𝑝 𝑙 . This impossibility holds even if there are not any mortal Byzantine processes and the membership is known. 6.1.1. The synchronous system 𝑆 𝑠 Let 𝑆 𝑠 be a system such as S but with the following differences. To add generality for the impossibility result, 𝑆 𝑠 is synchronous , that is, the maximum time needed by each process 𝑝	{ "page_id": null, "source": 7342, "title": "from dpo" }
𝑖 in 𝑆 𝑠 to execute a step is bounded and known by every process, and the time needed to receive a sent message is bounded and also known. We also assume that the clocks of all processes are synchronized. We assume that, in system 𝑆 𝑠 , there may be any number of faulty processes (i.e., 𝑓 ≤ 𝑛 ), and there are not any mortal Byzantine processes. Regarding membership in 𝑆 𝑠 , each process 𝑝 𝑖 initially knows the identity of all the processes in Π and, hence, 𝑝 𝑖 also knows the size n of the system. 𝑆 𝑠 has two types of links: eventually-timely and lossy-asynchronous . In eventually-timely links, there is an unknown bound Δ on message delays and an unknown (system-wide) global stabilization time T such that, if a message is sent through any of these links at a time 𝑡 ≥ 𝑇 , then this message is received by time 𝑡 + Δ . In lossy-asynchronous links, messages can be lost or arbitrarily delayed. Every message sent through a lossy-asynchronous link may be lost, but every message that is not lost is delivered in a finite but unknown time. Let 𝐺 ( 𝑋 ) be the directed graph obtained from 𝑆 𝑠 with the vertex set formed by the processes in X and the set of eventually-timely links that connect processes of X as the arc set. For example, 𝐺 ( Correct ) is the directed graph from 𝑆 𝑠 with the vertex set formed by Correct and the set of eventually-timely links that connect processes of Correct as the arc set. Then, 𝑆 𝑠 must preserve the following property for a failure detector of Class Ω to be implementable in such system. Property 1 There is a process 𝑝 𝑙 ∈	{ "page_id": null, "source": 7342, "title": "from dpo" }

Subsets and Splits

No community queries yet

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