text
stringlengths 2
132k
| source
dict |
|---|---|
of so-called linear degen-erations of Fl( V ): Let U be the variety of tuples ( f1, . . . , f n−1) ∈ End( V )n−1 of linear operators such that rk( fj−1 ◦ . . . ◦ fi) ≥ n + i − j for all i n ∏ > i=1 Gr i(V ) × U such that fi(Ui) ⊂ Ui+1 for all i = 1 , . . . , n − 1. Then πU : FU → U is a flat family with generic fibre isomorphic to Fl( V ), and the most degenerate fibre isomorphic to Fl mf (V ). We can stratify FU according to a kind of attractor flow into the irreducible components of its most degenerate fibre by defining, for every non-crossing arc diagram A as above, a stratum S(A) consisting of all ( U∗, f ∗) such that rk( fj−1 ◦ . . . ◦ fi : Ui → Uj ) = r(A)ij for all i ∗ (FU ×U FU ) as a quotient of a quiver Hecke/KLR algebra, and describe its standard representations indexed by Motzkin paths. References > G. Cerulli Irelli, E. Feigin, M. Reineke, Quiver Grassmannians and degenerate flag varieties ,Algebra Number Theory 6(2012), no. 1, 165–194. G. Cerulli Irelli, X. Fang, E. Feigin, G. Fourier, M. Reineke, Linear degenerations of flag varieties
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
, Math. Z. 287 (2017), no. 1-2, 615–654. X. Fang, M. Reineke, Supports for linear degenerations of flag varieties , Preprint 2018, arXiv:1805.09797. Types A and D quiver representation varieties Jenna Rajchgot (joint work with Ryan Kinser, Allen Knutson) Given a quiver Q with vertex set Q0, arrow set Q1, and dimension vector d : Q0 → Z≥0, there is a representation space rep Q(d) := ∏ > a∈Q1 Mat( d(ta ), d(ha )), where ta and ha denote the tail and head vertices of the arrow a, and Mat( m, n )denotes the space of m × n matrices with entries in a field K. The product of 2890 Oberwolfach Report 46/2019 general linear groups GL( d) := ∏ > z∈Q0 GL d(z)(K) acts on rep Q(d) on the right by conjugation, that is, ( Va)a∈Q1 · (gz )z∈Q0 := ( g−1 > ta Vagha )a∈Q1 , for ( Va)a∈Q1 ∈ rep Q(d), and ( gz )z∈Q0 ∈ GL( d). The closure of a GL( d) orbit in rep Q(d) is called a quiver locus .Motivations for the study of quiver loci come from various disciplines includ-ing algebraic geometry, commutative algebra, representation theory, and algebraic combinatorics. For example, through the study of quiver loci, one encounters well-known ideals from commutative algebra, including classical determinantal ideals and defining ideals of varieties of complexes. The primary motivation for the work discussed herein is from algebraic geometry, through study of degener-acy loci : given a non-singular algebraic variety X and a map of vector bundles φ : V → W on X, there is a degeneracy locus Ω r := {x ∈ X | rank φx ≤ r}, where φx : Vx → Wx is the induced map on fibers. The locus Ω r is a closed subvariety of X, defined
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
locally by the vanishing of minors of a matrix. When φ is sufficiently general, an expression for its fundamental class in the cohomology ring of X is given by the Giambelli-Thom-Porteous formula. A. Buch and W. Fulton general-ized this to sequences of vector bundle maps V1 → V2 → · · · → Vn in . Related formulas were subsequently produced in works such as [6, 2, 8, 5, 13, 18, 15, 3, 7]. The problem of producing formulas for degeneracy loci is closely related to that of finding formulas for multidegrees of associated quiver loci (see ). Indeed, in , A. Knutson, E. Miller, and M. Shimozono produced multiple formulas for the multidegrees and K-polynomials of quiver loci of equioriented type A quivers (i.e. all arrows point in the same direction). One important ingredient in this work was the Zelevinsky map , which identifies an equioriented type A quiver locus with an open subvariety of a Schubert variety [19, 14], thereby allowing for importation of results from Schubert calculus to the equioriented type A quiver setting. In joint work with R. Kinser and A. Knutson , we generalized three of Knutson, Miller, and Shimozono’s formulas from to all type A orientations. Our work also generalized or recovered formulas from [16, 4, 7]. Our main result was a proof of A. Buch and R. Rim´ anyi’s conjectured K-theoretic component formula from . In analogy with the equioriented setting, an explicit connection to Schubert varieties (from ) was important to our work. This extended abstract focuses on algebro-geometric results on type A quiver loci important to the proofs of the formulas in , as well as analogs of some of these algebro-geometric results for type D loci. The latter part is based on recent joint work with Kinser . 1.
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
Type A In this section we discuss some geometric results in type A, including the bipartite Zelevinsky map from , and a degeneration from which was central to the proof of the K-theoretic type A quiver component formula. 1.1. Bipartite Zelevinsky map. Let Q be a bipartite (i.e. alternating) type A quiver and d a dimension vector for Q. There is an associated general linear group Mini-Workshop: Degeneration Techniques in Representation Theory 2891 GL d(K), parabolic subgroup P ⊆ GL d(K), opposite Schubert cell Y ⊆ P \GL d,and closed immersion ζ : rep Q(d) → Y which restricts to an isomorphism from each quiver locus in rep Q(d) to a Schubert variety intersected with Y . We refer to ζ as the bipartite Zelevinsky map . For example, the type A5 representation Kd5 D −→ Kd4 C ←− Kd3 B −→ Kd2 A ←− Kd1 maps, via ζ, to the block matrix on the left below: 0 A 1 0 0 C B 0 1 0 D 0 0 0 11 0 0 0 00 1 0 0 0 ∈ ∗ ∗ 1 0 0 ∗ ∗ 0 1 0 ∗ ∗ 0 0 11 0 0 0 00 1 0 0 0 ∼= Y. Note that 1s denote identity matrices of appropriate sizes, and the matrix on the right denotes the space of all matrices of the given form (i.e. with arbitrary elements of K in the locations with stars). The ranks of the matrices A, B, C, D, [AB ] , [C B] , [CD ] , [ 0 AC B ] , [C BD 0 ] , 0 AC BD 0 characterize the points in the GL( d) orbit containing ( D, C, B, A ). This list of
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
ranks is equivalent to a list of ranks of certain North-West justified submatrices of ζ(D, C, B, A ). Using this, one can show that the closure of the orbit through (D, C, B, A ) is isomorphic, via ζ, to a Schubert variety intersected with Y .The bipartite Zelevinsky map is useful beyond the bipartite setting because of the following: given a type A quiver locus Ω ⊆ rep Q(d) (for Q of arbitrary orientation), there is as associated bipartite type A quiver locus ˜Ω and product of general linear groups G∗ such that Ω × G∗ is isomorphic to an open subvariety of ˜Ω . It follows from this result, the bipartite Zelevinsky map, and [9, Lemma A.4] that each type A quiver locus is isomorphic, up to a smooth factor, to an open subvariety of a Schubert variety. This gives a uniform way of obtaining results such as type A quiver loci are normal and Cohen-Macaulay with rational singularities (also proved earlier via other methods by G. Bobi´ nski and G. Zwara ); quiver locus containment is governed by Bruhat order on the symmetric group; there is a Frobenius splitting (in positive characteristic) of each representation space of a type A quiver that compatibly splits all quiver loci; certain generalized determinantal ideals are prime, and scheme-theoretically define type A quiver loci (C. Riedtmann and G. Zwara also obtained this result via other methods). 1.2. Degenerations. Certain degenerations of bipartite type A quiver loci are important in the proofs of the component formulas found in . To describe these degenerations (also given in ), we start with a general set-up: let G be an algebraic group over K, H ≤ G a closed subgroup, X a G-variety, and Y ⊆ X an H-stable closed subvariety. Let μ
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
: K× → G be a group homomorphism and consider the right action of K× on G by g · t = μ(t−1)gμ (t) and the right action 2892 Oberwolfach Report 46/2019 of K× on X by x · t = x · μ(t). With this set-up, we get two families ˜H and ˜Y over A1 − { 0} where the fiber H · t in the first family is a subgroup which acts on the fiber Y · t in the second family. In our case, X is a bipartite type A quiver representation space rep Q(d), Y ⊆ X is a quiver locus, G = GL( d) × GL( d), and H = GL( d)∆, a copy of GL( d)embedded diagonally in G. The action of G on X is a conjugation action where if (( gz , h z )) z∈Q0 ∈ G then gz (respectively hz ) acts on the map over the arrow to the left of z (respectively to the right of z). The induced action of H on X is then the usual action of GL( d) on rep Q(d). Letting ρz (t) denote the d(z) × d(z) diagonal matrix with t, t 2, . . . , t d(z) down the diagonal, the homomorphism μ is defined by t 7 → ( ( ρz (t−1), ρ z (t)) ) z∈Q0 . The families ˜H and ˜Y extend to flat families over A1 and the special fiber of the first family acts on the special fiber of the second family. From this, one deduces that a bipartite type A quiver locus degenerates to a union of products of matrix Schubert varieties, up to radical. One can further prove that this degeneration is reduced. See for details. Similar degenerations appeared previously in the
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
equioriented setting in . 2. Type D In recent joint work with Kinser , we obtain results in type D which are analo-gous to the type A results from . Indeed, we unify aspects of the equivariant ge-ometry of three classes of varieties: type D quiver representation varieties, double Grassmannians Gr (a, n ) × Gr (b, n ), and symmetric varieties GL (a + b)/(GL (a) × GL (b)). In particular, we translate results about singularities of orbit closures, combinatorics of orbit closure containment, and torus equivariant K-theory be-tween these three families. This is accomplished by producing explicit embed-dings of homogeneous fiber bundles over type D quiver representation spaces into symmetric varieties. Immediate consequences of these embeddings, together with results on symmetric varieties, include type D quiver loci are normal and Cohen-Macaulay with rational singularities (recovering work from obtained by other methods); the poset of orbit closures in a type D representation space (and also the poset of diagonal B-orbit closures in a double Grassmannian) is isomorphic to a subposet of a poset of clans , which are involutions in the symmetric group with signed fixed points. A next step in the investigation of type D quiver loci is to make use of the explicit embeddings in to help produce formulas for multidegrees and K-polynomials, in analogy with what was done in type A. References > G. Bobi´ nski and G. Zwara. Schubert varieties and representations of Dynkin quivers. Colloq. Math. , 94(2):285–309, 2002. A. S. Buch. Grothendieck classes of quiver varieties. Duke Math. J. , 115(1):75–103, 2002. A. S. Buch. Alternating signs of quiver coefficients. J. Amer. Math. Soc. , 18(1):217–237 (electronic), 2005. A. S. Buch. Alternating signs of quiver coefficients. J. Amer. Math. Soc. , 18(1):217–237 (electronic), 2005. Mini-Workshop: Degeneration Techniques
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
in Representation Theory 2893 A. S. Buch, L. M. Feh´ er, and R. Rim´ anyi. Positivity of quiver coefficients through Thom polynomials. Adv. Math. , 197(1):306–320, 2005. A. S. Buch and W. Fulton. Chern class formulas for quiver varieties. Invent. Math. ,135(3):665–687, 1999. A. S. Buch and R. Rim´ anyi. A formula for non-equioriented quiver orbits of type A. J. Algebraic Geom. , 16(3):531–546, 2007. L. Feh´ er and R. Rim´ anyi. Classes of degeneracy loci for quivers: the Thom polynomial point of view. Duke Math. J. , 114(2):193–213, 2002. D. Kazhdan and G. Lusztig. Representations of Coxeter groups and Hecke algebras. Invent. Math. , 53(2):165–184, 1979. R. Kinser, A. Knutson, and J. Rajchgot. Three combinatorial formulas for type A quiver polynomials and K-polynomials. Duke Math. J. , 168(4):505–551, 2019. R. Kinser and J. Rajchgot. Type A quiver loci and Schubert varieties. J. Commut. Algebra ,7(2):265–301, 2015. R. Kinser and J. Rajchgot. Type D quiver representation varieties, double Grassmannians, and symmetric varieties, 2019. A. Knutson, E. Miller, and M. Shimozono. Four positive formulae for type A quiver poly-nomials. Invent. Math. , 166(2):229–325, 2006. V. Lakshmibai and P. Magyar. Degeneracy schemes, quiver schemes, and Schubert varieties. Internat. Math. Res. Notices , (12):627–640, 1998. E. Miller. Alternating formulas for K-theoretic quiver polynomials. Duke Math. J. , 128(1):1– 17, 2005. E. Miller. Alternating formulas for K-theoretic quiver polynomials. Duke Math. J. , 128(1):1– 17, 2005. C. Riedtmann and G. Zwara. Orbit closures and rank schemes. Comment. Math. Helv. ,88(1):55–84, 2013. A. Yong. On combinatorics of quiver component formulas. J. Algebraic Combin. , 21(3):351– 371, 2005. A. V. Zelevinsky. Two remarks on graded nilpotent classes. Uspekhi Mat. Nauk ,40(1(241)):199–200, 1985. Convex geometric push-pull operators and FFLV polytopes Valentina Kiritchenko
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
Let X be a smooth algebraic variety, and E → X a vector bundle of rank two on X. Define the projective line fibration Y = P(E) as the variety of all lines in E. The natural projection π : Y → X induces pull-back π∗ : A∗(X) → A∗(Y ) and push-forward π∗ : A∗(Y ) → A∗− 1(X) (aka transfer or Gysin map ) in the (generalized) cohomology rings of X and Y . The push-pull operator π∗π∗ : A∗(Y ) → A∗− 1(Y ) is a homomorphism of A∗(X)-modules, and can be described explicitly via Quillen–Vishik formula for any algebraic oriented cohomology theory A∗ (such as Chow ring, K-theory or algebraic cobordism). Push-pull operators are used extensively in representation theory (Demazure operators) and in Schubert calculus (divided difference operators). We discuss convex geometric counterparts of push-pull operators and their applications in the theory of Newton–Okounkov convex bodies. We focus on the case where Y = G/B is the complete flag variety for a connected reductive group G. Let Pi ⊂ G be the minimal parabolic subgroup associated with a simple root αi, and X = G/P i the corresponding partial flag variety. Clearly, 2894 Oberwolfach Report 46/2019 πi : Y → X is a projective line fibration. For instance, if G = GL n(C) then points in G/B can be identified with complete flags ( V 1 ⊂ V 2 ⊂ . . . ⊂ V n−1 ⊂ Cn)of subspaces, and the map πi forgets the subspace V i. The corresponding push-pull operator ∂i : CH ∗(Y ) → CH ∗− 1(Y ) for Chow rings is often called divided difference operator , while the push-pull operator Di : K∗(Y ) → K∗− 1(Y ) for the K-theory is usually called Demazure operator .A classical result of
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
Schubert calculus [BGG, D] is an inductive description of Schubert cycles [ Xw ] ∈ CH ∗(Y ) for all elements w ∈ W in the Weyl group of G.Namely, if w = si1 si2 · · · siℓ is a reduced decomposition of w into the product of simple reflections, then [Xw ] = ∂iℓ . . . ∂ i2 ∂i1 [Xid ]. (1) A classical result in representation theory [A] is an inductive description of the Demazure character χw (λ) for every Schubert variety Xw and a dominant weight λ of G: χw (λ) = D1D2 . . . D ℓ(eλ). (2) While formulas (1) and (2) look similar, there is no direct relation between them since in (1) operators are applied in the order opposite to that of (2). In [Ki16], we defined convex geometric analogs of Demazure operators. They can be used to construct inductively polytopes Pλ such that the sum of expo-nentials over lattice points in Pλ yields the Demazure character χw (λ). Recently, Naoki Fujita showed that the Nakashima–Zelevinsky polyhedral realizations of crystal bases for a special reduced decomposition of the longest element w0 ∈ W can be constructed inductively using convex geometric Demazure operators in types An, Bn, Cn, Dn, and G2 [Fu18]. In this setting, the convex geometric Demazure operators are applied in the same order as in (2). Below we define different convex geometric analogs of push-pull operators that are more natural from the perspective of (1). When computing Newton–Okounkov polytopes of Schubert or Bott–Samelson varieties one often needs an effective tool for comparing the degrees of varieties with the volumes of resulting polytopes. For a reduced decomposition w = si1 si2 · · · siℓ , convex geometric push-pull operators produce inductively polytopes such that their volume polynomials coincide with
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
the degrees of Bott–Samelson varieties corresponding to collections of simple roots (αi1 ), ( αi1 , α i2 ),. . . , ( αi1 , α i2 , . . . , α iℓ ). Let P ⊂ Rn be a convex polytope, and I ⊂ Rn a segment. Let Q ⊂ Rn be a polytope analogous to P (i.e., having the same normal fan). Define the push-pull polytope ∆( P, Q, I ) ⊂ Rn+1 = R × Rn as the convex hull of the following set: (1 × P ) ∪ (0 × (Q + I)) . When I = {0}, this construction produces the Newton polytope of a projective line fibration Y = P1(E) over the toric variety X corresponding to the polytope P . We assume that E = O ⊕ L is split so Y is also a toric variety. In this case, there is a simple relation between the polytope Q and the first Chern class of L.In particular, construction of Grossberg–Karshon cubes [GK] (done originally in Mini-Workshop: Degeneration Techniques in Representation Theory 2895 the spirit of (2)) for Bott–Samelson varieties can also be reproduced in the spirit of (1) using convex-geometric push-pull operators with I = {0}.While Grossberg–Karshon cubes can be realized as Newton–Okounkov poly-topes of Bott–Samelson varieties for some line bundles [Fu15, HY16, HY17], they do not degenerate to Newton–Okounkov polytopes of flag varieties (instead they turn into twisted cubes, which are not true polytopes). Using segment I of positive length allows us to produce polytopes that do not break in the limit when passing to flag varieties. The following example produces the Newton–Okounkov polytope of a Bott–Samelson variety in type A2 with the desired degeneration. Example 1. cf. [An13, Section 6.4] Let n = 2 , and P ⊂ R2 a
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
trapezoid with the vertices (0 , 0) , (2 , 0) , (0 , 1) , (1 , 1) . Take I = [(0 , 0) , (0 , 1)] , and Q = P . Then the push-pull polytope ∆( P, Q, I ) ⊂ R3 is the Minkowski sum of the FFLV polytope in type A2 corresponding to the weight ρ and the segment J = [(0 , 0, 0) , (1 , 0, 0)] (see [FFL] for the definition of FFLV polytopes in type A and their representation-theoretic meaning). By shrinking J we get the degeneration to the FFLV polytope. We plan to use convex geometric push-pull operators as a tool for proving the following conjecture on Newton–Okounkov polytopes of Bott–Samelson varieties in type A and generalized FFLV polytopes. We use notation of [Ki18]. Conjecture 1. Let Λi = ( λii, . . . , λ in). If j > i , put λji = λjj . The Newton– Okounkov polytope ∆v0 (Xw0 , L (Λ 1, . . . , Λn−1)) is given by inequalities: ulm ≥ 0 and ∑ > (l,m )∈D ulm ≤ > j ∑ > s=1 (λsk − λsi+j ) for all Dyck paths going from λk to uij in table (FFLV) where 1 n−1 u21 . . . u2 > n−2 . . . . . . un−21 un−22 un−11 (F F LV ) References > [A] H. H. Andersen, Schubert varieties and Demazure’s character formula, Invent. Math., > 79 , no. 3 (1985), 611–618 [An13] D. Anderson ,Okounkov bodies and toric degenerations , Math. Ann., 356 (2013), no. 3, 1183–1202 [BGG] I.
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
N. Bernstein, I. M. Gelfand, S. I. Gelfand ,Schubert cells, and the cohomology of the spaces G/P , Russian Math. Surveys 28 (1973), no. 3, 1–26. [D] M. Demazure ,D´ esingularisation des vari´ et´ es de Schubert g´ en´ eralis´ ees , Collection of articles dedicated to Henri Cartan on the occasion of his 70th birthday, I. Ann. Sci. ´Ecole Norm. Sup. 4 7(1974), 53–88. 2896 Oberwolfach Report 46/2019 > [FFL] E. Feigin, Gh. Fourier, P. Littelmann ,PBW filtration and bases for irreducible mod-ules in type An, Transform. Groups 165 (2011), no. 1, 71–89 [Fu15] N. Fujita ,Newton-Okounkov bodies for Bott–Samelson varieties and string polytopes for generalized Demazure modules , J. of Algebra 515 (2018), 408–447 [Fu18] N. Fujita ,Polyhedral realizations of crystal bases and convex-geometric Demazure op-erators , preprint arXiv:1810.12480 [math.AG] [GK] M. Grossberg and Y. Karshon ,Bott towers, complete integrability, and the extended character of representations , Duke Math. J., 76 (1994), no. 1, 23–58 [HY16] M. Harada, J. Yang ,Newton-Okounkov bodies of Bott-Samelson varieties and Grossberg-Karshon twisted cubes , Michigan Math. J., 65 (2016), no. 2, 413–440 [HY17] M. Harada, J. Yang ,Singular string polytopes and functorial resolutions from Newton-Okounkov bodies , Illinois J. Math. 62 (2018), no. 1-4, 271–292. [Ki16] V. Kiritchenko ,Divided difference operators on convex polytopes , Adv. Studies in Pure Math., 71 (2016), 161–184e [Ki18] V. Kiritchenko ,Newton–Okounkov polytopes of Bott–Samelson varieties as Minkowski sums , arXiv:1801.00334 [math.AG] Hessenberg Varieties and the Stanley–Stembridge Conjecture Martha Precup (joint work with Megumi Harada) Recent results have forged exciting new connections between algebraic combi-natorics and the geometry and topology of certain subvarieties of the flag vari-ety called Hessenberg varieties. In particular, the Shareshian–Wachs conjecture , proven in 2015 by Brosnan and Chow , established a new connection be-tween Hessenberg varieties and the Stanley–Stembridge conjecture in combina-torics.
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
This talk gives a brief introduction to that story, and discusses a recent theorem of the author and Harada which uses the topology of Hessenberg varieties to give an inductive approach to the Stanley–Stembridge conjecture in a special case. Let n be a positive integer. A Hessenberg function is an increasing sequence h = ( h(1) , h (2) , . . . , h (n)) such that h(i) ≥ i for all i ∈ [n]. Let h be a Hessenberg function and X be an n × n matrix in gl (n, C). The Hessenberg variety B(X, h )associated to h and X is the subvariety of the flag variety Fℓags (Cn) defined by B(X, h ) := {V• ∈ F ℓags (Cn) | X(Vi) ⊂ Vh(i) for all i ∈ [n]}. Let S ∈ gl n(C) be a regular semisimple matrix. The Hessenberg variety B(S, h )is called a regular semisimple Hessenberg variety . Tymoczko proved that there is a graded symmetric group representation on the cohomology H∗(B(S, h )) for each Hessenberg function h, called the dot action representation . We will see below that the dot action provides the essential link between Hessenberg varieties and the Stanley–Stembridge conjecture. Another way to interpret the data of a Hessenberg function is as a graph. We define the incomparability graph Γh = ( V, E h) associated to a Hessenberg function h as follows. The vertex set V is [ n] = {1, 2, . . . , n } and the edge set Eh is defined Mini-Workshop: Degeneration Techniques in Representation Theory 2897 as: {i, j } ∈ Eh if 1 ≤ j < i ≤ n and i ≤ h(j). For example, the incomparability graph for h = (3 , 4, 5, 5, 5) is given below.
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
1 2 3 4 5Let Γ be a (simple) graph with vertex set [ n]. A proper coloring of Γ is a function κ : [ n] → N such that κ(v) 6 = κ(w) whenever {v, w } is an edge. We define a monomial xκ in variables x = x1, x 2, . . . by xκ := ∏ > v∈[n] xκ(v). Stanley’s chromatic symmetric function is XΓ(x) := ∑ > κ xκ where the sum is taken over all proper colorings of Γ. This symmetric function was defined by Stanley in and has subsequently received considerable attention from combinatorists. We can now state the Stanley–Stembridge conjecture. Conjecture 2. Let h be a Hessenberg function. Then XΓh (x) is e-positive, that is, it is a nonnegative integer combination of the elementary symmetric functions. The original statement of the Stanley–Stembridge conjecture asserts that the chromatic symmetric function of the incomparability graph of a (3+1)-free poset is e-positive . We will not define the incomparability graph of a poset here. Rather, we note that work of Guay-Paquet and Shareshian–Wachs shows that the original conjecture is implied by Conjecture 2 above. One might suspect that XΓh is the image under the Frobenius character map of some naturally occurring Sn-representation. We have already seen an example of such a representation, namely the dot action representation. The following conjecture of Shareshian and Wachs first established the connection between the dot action and XΓh (x). It is now a theorem thanks to the work of Brosnan and Chow [1, Theorem 129]. Theorem 1. For each Hessenberg function h, XΓh (x) = ω(ch( H∗(B(S, h )))) ,where ch denotes the Frobenius character map and ω is the usual involution on symmetric functions. Theorem 1 can be used to recover information about
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
the dot action represen-tation. For example, the Schur-basis expansion of XΓh (x) is known; there is a combinatorial formula for the coefficients due to Gasharov obtained by enumerat-ing Ph-tableaux . Gasharov’s formula determines the decomposition of the dot action representation into irreducible Sn-representations. It is well known that the set of representations {M λ := Ind Sn > Sλ (1) | λ ⊢ n} form a Z-basis for the representation ring Rep (Sn) of Sn. Thus there exist unique integers cλ such that (1) H∗(B(S, h )) = ∑ > λ⊢n cλM λ as elements in Rep (Sn). Since ω(ch( M λ)) = eλ, Theorem 1 implies that in order to prove the Stanley–Stembridge conjecture it suffices to show cλ ≥ 0 for all λ.2898 Oberwolfach Report 46/2019 In , the author and Harada use Theorem 1 to prove a new inductive formula for certain coefficients appearing in (1). Recall that a subset of vertices I ⊆ [n] in the graph Γ h is called independent if they are pairwise nonadjacent. We obtain a ‘smaller’ graph Γ hI := Γ h \ I from each such subset I by deleting the vertices in I and all adjacent edges. The graph Γ hI uniquely determines a new Hessenberg function hI = ( hI (1) , . . . , h I (n − | I|)). Theorem 2 (Harada–Precup) . Let h be a Hessenberg function and λ ⊢ n be a partition of n with exactly ℓ parts, where ℓ is the independence number of Γh. Let μ = ( μ1, . . . , μ ℓ) ⊢ (n − ℓ) such that λ = ( μ1 + 1 , . . . , μ ℓ + 1) . Then, cλ = ∑ > I∈I ℓ(Γ h) cIμ where Iℓ(Γ h)
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
is the set of all independent sets of vertices of size ℓ in Γh and for each I ∈ I ℓ(Γ h), the coefficients cIμ are the coefficients as in (1) associated to the semisimple Hessenberg variety B(S, h I ) in the flag variety of GL n−ℓ(C). As a corollary, we obtain a special case of the Stanley–Stembridge conjecture by induction . Corollary 1. Let h be a Hessenberg function such that the independence number of Γh is at most 2. Then the integers cλ appearing in (1) are non-negative. The technical details of the induction argument leading to Theorem 2 use– among other things– Brosnan and Chow’s proof of the Shareshian–Wachs Conjec-ture. In particular, Theorem 76 of states that the dot action representation is completely determined by the Betti numbers of regular Hessenberg varieties ,that is, varieties of the form B(Xλ, h ) where Xλ denotes a regular matrix of Jor-dan type λ. Combining [1, Theorem 76] with results of author on the geometry and combinatorics of Hessenberg varieties provides the necessary tools to prove Theorem 2. References > P. Brosnan and T. Chow. Unit interval orders and the dot action on the cohomology of regular semisimple Hessenberg varieties, Adv. Math. 328:955–1001, 2018. V. Gasharov. Incomparability graphs of (3 + 1)-free posets are s-positive. In Proceedings of the 6th Conference on Formal Power Series and Algebraic Combinatorics (New Brunswick, NJ, 1994) , volume 157, pages 193–197, 1996. M. Guay-Paquet. A modular relation for the chromatic symmetric functions of (3+1)-free posets. preprint: 2013. J. Shareshian and M. L. Wachs. Chromatic quasisymmetric functions. Adv. Math. , 295:497– 551, 2016. M. Harada and M. Precup. The cohomology of abelian Hessenberg varieties and the Stanley– Stembridge conjecture. accepted to Alg. Comb. , preprint:
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
2017. M. Harada and M. Precup. Upper-triangular linear relations on multiplicities and the Stanley–Stembridge conjecture. preprint: 2018. M. Precup. The Betti numbers of regular Hessenberg varieties are palindromic. Trans. Groups. 23(2):491–499, 2018. Mini-Workshop: Degeneration Techniques in Representation Theory 2899 > R. P. Stanley. A symmetric function generalization of the chromatic polynomial of a graph. > Adv. Math. , 111(1):166–194, 1995. R. P. Stanley and J. R. Stembridge. On immanants of Jacobi-Trudi matrices and permuta-tions with restricted position. J. Combin. Theory Ser. A , 62(2):261–279, 1993. J. S. Tymoczko. Permutation actions on equivariant cohomology of flag varieties. In Toric topology , volume 460 of Contemp. Math. , pages 365–384. Amer. Math. Soc., Providence, RI, 2008. Positive initial ideals and the FFLV polytope Lara Bossinger The following abstract summarizes a short talk presenting an open problem about Feigin-Fourier-Littelmann-Vinberg polytopes (short: FFLV ) and Newton-Okounkov bodies from cluster algebras. Consider the full flag variety Fℓn of type A, i.e. points are in correspondence with full flags of subspaces {0} ⊂ V1 ⊂ · · · ⊂ Vn−1 ⊂ Cn with dim( Vi) = i.We further assume n ≥ 5 and use the notation [ n] := {1, . . . , n }. We embed it into the product of Grassmannains Gr 1(Cn) × · · · × Gr n−1(Cn) and further every Grassmannain in a projective space with respect to its Pl¨ ucker embedding. Hence, Fℓn֒ → P(n > 1 )−1 × · · · × P( nn−1)−1. The (multi-)homogeneous coordinate ring of Fℓn with respect to this embedding is An := C[pJ |J ⊂ [n]] /I n, where In is a (multi-)homogeneous ideal generated by the Pl¨ ucker relations. On An we have a family of valuations coming from the cluster structure of Fℓn.
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
To be precise, by the algebra An is a cluster algebra meaning that it can be generated recursively by seeds (certain maximally algebraically independent subsets of algebra generators for An) and an algebraic operation called mutation (a procedure to construct new seeds from a given one). For every seed s we have a full-rank homogeneous valuation, denoted by νs : An \ { 0} → Zd+( n−1) , where d = dim( Fℓn). These valuations have the special property that their associated initial ideals (in the sense of Kaveh-Manon as presented in Christopher Manon’s lecture series on Khovanskii basis in this Mini-Workshop) are positive , i.e. for every seed s the ideal in νs (In) does not contain any non-zero element of R+[pJ |J ⊂ [n]]. Following Kiritchenko or Fang-Fourier-Littelmann the FFLV-polytope (that as been discussed in detail during this Mini-Workshop) can be realized as a Newton-Okounkov body associated with a full-rank homogeneous valuation νFFLV : An \ { 0} → Zd+( n−1) . We have FFLV( ρ) = ∆( An, ν FFLV ). Since a few years the following question has been studied but not yet answered: Question: Does the FFLV-polytope occur as a Newton-Okounkov polytope ∆( An, ν s) for some seed s?While studying this question the following observation might give some new insights. Proposition: The initial ideal in νFFLV (In) associated with the FFLV-valuation is not positive. 2900 Oberwolfach Report 46/2019 This suggests that the answer to the above question might be no. However, it should be noted that positivity of ideals is not preserved under isomorphisms. Already isomorphisms induced by the action of the symmetric group on Pl¨ ucker coordinates does not preserve positivity on the level of ideals. References > A. Berenstein, S. Fomin, A. Zelevinsky, Cluster algebras. III. Upper
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
bounds and double Bruhat cells. Duke Math. J. 126 (2005), no. 1, 1–52. X. Fang, G. Fourier, P. Littelmann, Essential bases and toric degenerations arising from birational sequences. Adv. Math. 312 (2017), 107–149. E. Feigin, G. Fourier, P. Littelmann, Favourable modules: filtrations, polytopes, Newton-Okounkov bodies and flat degenerations. Transform. Groups 22 (2017), no. 2, 321–352. K. Kaveh, C. Manon, Khovanskii bases, higher rank valuations, and tropical geometry. > SIAM J. Appl. Algebra Geom. 3 (2019), no. 2, 292–336. V. Kiritchenko, Newton-Okounkov polytopes of flag varieties. Transform. Groups 22 (2017), no. 2, 387–402. Global Demazure modules and semi-infinite Veronese curves Ilya Dumanski Let g = n− ⊕ h ⊕ n+ be a simple Lie algebra and let g[t] be its current algebra. Fix a dominant weight λ = ∑ri=1 miωi. The global Weyl module Wλ of weight λ over g[t] is defined as a cyclic module with cyclic vector v with defining relations n+[t].v = 0, ht 0.v = λ(h)v and ( fαt0)(λ,α ).v = 0 for any positive root α.We also define the local Weyl module Wλ as a cyclic g[t]-module with a cyclic vector v and defining relations n+[t].v = 0, th[t].v = 0, ht 0.v = λ(h)v and (fαt0)(λ,α ).v = 0 for any positive root α.For arbitrary g[t]-module W and c ∈ C we define the g[t]-module W (c), which is isomprphic to W as a vector space, and xt m act as x(t + c)m on it. The following important theorem was proved in , , : Theorem 1. (1) Wλ admits an h[t]-action, induced by ht m.uv = uht mv (for u ∈ U (g[t]) ). Define Aλ = U (h[t]) /Ann U(h[t]) v. (2) As algebra Aλ is isomorphic to C[z1, . . . , z m1+... +mr ]Sm1 ×...
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
×Smr . (3) For x = ( x1,1, . . . x r,m r ) ∈ Am+ ... +mr with pairwise distinct coordinates we have Wλ ⊗Aλ Cx ≃ > r ⊗ > i=1 > mi ⊗ > i=1 Wωi (xi,j ). (4) Wλ ⊗Aλ C0 ≃ Wλ (5) dim Wλ = ∏ri=1 (dim Wωi )mi . This theorem implies that the specialisation of Wλ as Aλ-module have equal di-mension every point. Hense, Wλ is projective Aλ-module, and taking into account the Quillen-Suslin theorem we state that it is free Aλ-module. Mini-Workshop: Degeneration Techniques in Representation Theory 2901 Geometric realisation of Wλ was given in , . It was proved that the homoge-neous coordinate ring of Drinfeld-Pl¨ ucker embedding of semi-infinite flag variety to ∏ri=1 P(Vωi [t]) is isomorphic to ⊕ > λ W∗ > λ .Kato also proved that the natural map Wλ+μ → Wλ ⊗ Wμ is injective. Note also that for type A one has Wλ = Vλ ⊗ C[t], where Vλ is an irreducible g-module of highest weight λ.Taking it into account we conclude that in type A we have Wλ ≃ U (g[t]) .v ⊂ > r ⊗ > i=1 Vωi [t]⊗mi , where v is a tensor product of the highest vectors of Vωi [t]. Fix some l ∈ Z>0. Our idea is to consider the sl r+1 [t]-module Dl,λ ≃ U (g[t]) .v ⊂ > r ⊗ > i=1 Vlω i [t]⊗mi , where v is a tensor product of the highest vectors of Vlω i [t]. We are trying to prove the analogue of Theorem 1 for arbitrary l. So far we can prove the following steps: Theorem 2. (1) Dl,λ admits an h[t]-action, induced by ht m.uv = uht mv (for u ∈ U (g[t]) ). Define Al,λ = U
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
(h[t]) /Ann U(h[t]) v. (2) As algebra Al,λ is isomorphic to C[z1, . . . , z m1+... +mr ]Sm1 ×... ×Smr . (3) For x = ( xi, 1, . . . x r,m r ) ∈ Am+ ... +mr with pairwise distinct coordinates we have Dl,λ ⊗Al,λ Cx ≃ > r ⊗ > i=1 > mi ⊗ > i=1 Dl,ω i (xi,j ), Where Dl,λ is the sl r+1 -stable Demazure module of level l and highest weight lλ in the integrable ̂ sl r+1 -module L(lΛ0). It suffices to study Dl,λ ⊗Al,λ C0 to finish the theorem. Geometric realisation of Dl,λ is the following. Consider the embedding of semi-infinite flag variety into ∏ri=1 P(Vlω i [t]), which can be thought as a composition of Drinfeld-Pl¨ ucker embedding and r-tuple of semi-infinite Veronese maps of degree l, νi : P(Vωi [t]) → P(( SlVωi )[ t]) = P(Vlω i [t]). The homoheneous coordinate ring of this variety is isomorphic to ⊕ > λ D∗ > l,λ .We study the case of sl 2 more precisely. In this case the described embedding is just an arc scheme of finite-dimensional Veronese curve of degree l, P(Vω [t]) → P(Vlω [t]). Knowing representation-theoretic facts about Dl,λ for sl 2 we deduce the reduced structure of this scheme. Let ( x0 : · · · : xl) be standard homogeneous coordinates on Pl. To obtain the corresponding arc scheme one uses the infinite set of coordi-nates x(k) > a , k ≥ 0 packed into the formal series xa(t) = ∑ > k≥0 x(k) > a tk.2902 Oberwolfach Report 46/2019 Theorem 3. The reduced scheme structure of arc sheme of Veronese curve of degree l is given by the quadratic ideal generated by all the coefficients of certain linear combinations of expressions
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
of the form dixa(t) > dx i xb(t). Note that relations with derivatives first appeared in in the homogeneous co-ordinate ring of usual Drinfeld-Pl¨ ucker embedding of the semi-infinite flag variety in type A. References > A.Braverman, M.Finkelberg. Weyl modules and q-Whittaker functions , Math. Ann., vol. 359 (1), 2014, pp 45–59. V. Chari and S. Loktev. Weyl, Demazure and fusion modules for the current algebra of > sl r+1 . Adv. Math., 207(2):928–960, 2006. E. Feigin and I. Makedonskyi. Semi-infinite Pl¨ ucker relations and Weyl modules , Interna-tional Mathematics Research Notices, rny121, 2018. G. Fourier and P. Littelmann. Weyl modules, Demazure modules, KR-modules, crystals, fusion products and limit constructions . Adv. Math., 211(2):566–593, 2007. S.Kato. Demazure character formula for semi-infinite flag varieties , Math. Ann. (2018). K. Naoi. Weyl modules, Demazure modules and finite crystals for non-simply laced type .Adv. Math., 229(2):875–934, 2012. Newton-Okounkov bodies of Schubert varieties and tropicalized cluster mutations Naoki Fujita (joint work with Hironori Oya) A Newton-Okounkov body ∆( X, L, v ) is a convex body constructed from a polar-ized variety ( X, L) with a valuation v on the function field C(X), which gives a systematic method of constructing toric degenerations of X by . In the case of flag varieties and Schubert varieties, their Newton-Okounkov bodies realize the following representation-theoretic polytopes: (1) Berenstein-Littelmann-Zelevinsky’s string polytopes , (2) Nakashima-Zelevinsky polytopes , (3) Feigin-Fourier-Littelmann-Vinberg polytopes [3, 9]. One motivating problem is to relate these polytopes by using the framework of cluster algebras. The theory of cluster algebras also gives a general framework to obtain toric degenerations of projective varieties, following Gross-Hacking-Keel-Kontsevich . They introduced the notion of positive polytopes, and showed that it gives toric degenerations of compactified A-cluster varieties. Our aim in this talk is to
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
study relations between these two constructions of toric degenerations. To be more precise, let A = ⋃ > t At = ⋃ > t Spec( C[x1(t)±1, . . . , x m(t)±1]) be a cluster variety, where t runs over a set of seeds which are all mutation equiv-alent, and x1(t), . . . , x m(t) are the corresponding cluster variables. Assuming that Mini-Workshop: Degeneration Techniques in Representation Theory 2903 X is birational to the cluster variety A, we have the following identification for each t: C(X) ≃ C(x1(t), . . . , x m(t)) . Fix a total order ≤t on Zm refining the dominance order introduced by Qin ; this ≤t induces a total order on the set of Laurent monomials in x1(t), . . . , x m(t). We define a valuation vt : C(X) \ { 0} → Zm to be the associated lowest term valuation. By definition, this valuation vt gener-alizes g-vectors of cluster monomials and of the theta function basis, which implies that Gross-Hacking-Keel-Kontsevich’s positive polytopes are identical to Newton-Okounkov bodies associated with vt. Let us compute the Newton-Okounkov body ∆( X, L, v t) when X is a Schubert variety. Let G be a simply-connected semisimple algebraic group over C, B a Borel subgroup of G, W the Weyl group, and P+ the set of dominant integral weights. We denote by X(w) ⊂ G/B the Schubert variety corresponding to w ∈ W , and by Lλ the globally generated line bundle on X(w) associated with λ ∈ P+. We consider the cluster structure on the unipotent cell which is naturally birational to X(w). Let ∆ i(λ) (resp., ˜∆i(λ)) denote the string polytope (resp., the Nakashima-Zelevinsky polytope) associated with a reduced word i for w ∈ W and λ ∈ P+. Theorem 1.
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
Let i be a reduced word for w ∈ W . Then, there exists a seed t (resp., ˜t) such that ∆( X(w), Lλ, v t) ( resp., ∆( X(w), Lλ, v ˜t)) is unimodularly equivalent to ∆i(λ) ( resp., ˜∆i(λ)) for all λ ∈ P+. Analogous relations between string polytopes and cluster varieties were pre-viously given by Magee and Bossinger-Fourier in type A, and by Genz-Koshevoy-Schumann in simply-laced case. Let A∨ denote the Fock-Goncharov dual of A. By tropicalizing the cluster mutation μk for A∨, we obtain the tropicalized cluster mutation μTk . Using Kang-Kashiwara-Kim-Oh’s monoidal categorification of the cluster algebra, we de-duce the following in simply-laced case. Theorem 2. If G is of simply-laced, then the following hold for all w ∈ W and λ ∈ P+. (1) For each t, the Newton-Okounkov body ∆( X(w), Lλ, v t) is a rational con-vex polytope, which induces a toric degeneration of X(w). (2) If t′ is obtained from t by the mutation μk, then the following equality holds :∆( X(w), Lλ, v t′ ) = μTk (∆( X(w), Lλ, v t)) . By combining the theorems above, we see that string polytopes and Nakashima-Zelevinsky polytopes are all related by tropicalized cluster mutations. 2904 Oberwolfach Report 46/2019 References > D. Anderson, Okounkov bodies and toric degenerations , Math. Ann. 356 (2013), 1183–1202. L. Bossinger and G. Fourier, String cone and superpotential combinatorics for flag and Schubert varieties in type A , J. Combin. Theory Ser. A 167 (2019), 213–256. E. Feigin, G. Fourier, and P. Littelmann, Favourable modules: filtrations, polytopes, Newton-Okounkov bodies and flat degenerations , Transform. Groups 22 (2017), 321–352. N. Fujita and S. Naito, Newton-Okounkov convex bodies of Schubert varieties and polyhedral realizations of crystal bases , Math. Z. 285
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
(2017), 325–352. V. Genz, G. Koshevoy, and B. Schumann, Polyhedral parametrizations of canonical bases > &cluster duality , arXiv preprint arXiv:1711.07176, 2017. M. Gross, P. Hacking, S. Keel, and M. Kontsevich, Canonical bases for cluster algebras , J. Amer. Math. Soc. 31 (2018), 497–608. S.-J. Kang, M. Kashiwara, M. Kim, S.-j. Oh, Monoidal categorification of cluster algebras ,J. Amer. Math. Soc. 31 (2018), 349–426. K. Kaveh, Crystal bases and Newton-Okounkov bodies , Duke Math. J. 164 (2015), 2461– 2506. V. Kiritchenko, Newton-Okounkov polytopes of flag varieties , Transform. Groups 22 (2017), 387–402. T. Magee, Fock-Goncharov conjecture and polyhedral cones for U⊂SL nand base affine space SL n/U , arXiv preprint arXiv:1502.03769, 2015. F. Qin, Triangular bases in quantum cluster algebras and monoidal categorification conjec-tures , Duke Math. J. 166 (2017), 2337–2442. Non-abelian PBW degenerations Igor Makhlin Originally, PBW degenerations of highest weight representations of semisimple Lie algebras were defined as associated graded spaces for filtrations given by standard PBW degree. These spaces are acted upon by the associated graded algebra of U(n−) (which in this case is just a polynomial algebra). Here we are evidently dealing with a filtration by the ordered group Z. Other filtrations by ordered groups were considered in, for instance, and , however, in all previous cases the ordered group in consideration was abelian. The first idea we wish to express is that one may, in fact, consider filtrations by arbitrary totally ordered semigroups, not necessarily abelian, and still obtain associated graded representations acted upon by the associated graded algebra. All one needs to do is to choose a map from the set of negative roots to a totally ordered semigroup. Now it must be said that in this generality the theory is, apparently, not very rich, since
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
it is unclear how to define one of the main ingredients: the degenerate flag variety. In the cases considered previously the associated graded algebra was always itself a universal enveloping algebra and one could define the variety as an orbit closure for the corresponding Lie group. In general, the associated graded algebra is not a universal enveloping algebra. Nevertheless, in certain situations the degenerate variety can still be defined and this does produce degenerations which could not be obtained from abelian filtra-tions. We focus on a particular well-known example in type A: the toric variety associated with the Gelfand-Tsetlin polytope. Mini-Workshop: Degeneration Techniques in Representation Theory 2905 We describe an alternative approach to the definition which does not rely on a Lie group action. This is done by noting that if we have a monoidal structure on degenerate representations and maps gr Lλ+μ → gr Lλ ⊗ gr Lλ (where gr Lλ is the degeneration of the irreducible representation with highest weight λ), then the sum ⊕ > λ (gr Lλ)∗ turns into a commutative ring. If this ring is finitely generated, then we may define the degenerate flag variety as its “multigraded Proj”. (This is equivalent to the original definition in the known cases.) Now we are left to provide a specific ordered semigroup and a filtration thereon which meet the above requirements and produce the Gelfand-Tsetlin toric degen-eration as a result. To do so one may, in fact, take the free monoid in generators corresponding to the negative roots together with a rather natural graded lexico-graphic order on this monoid. A detailed description of this construction can be found in the addendum of . References > E. Feigin, G. Fourier, P. Littelmann, Favourable modules: filtrations, polytopes, Newton-Okounkov bodies and flat degenerations , Transformation Groups 22 (2017), no.
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
2, 321–352. X. Fang, E. Feigin, G. Fourier, I. Makhlin, Weighted PBW degenerations and tropical flag varieties , Communications in Contemporary Mathematics 22 (2019), 1850016. I. Makhlin, Gelfand–Tsetlin degenerations of representations and flag varieties , > Flag varieties, Valuations and Standard Monomial Theory Peter Littelmann (joint work with Rocco Chiriv` ı, Xin Fang) The theory of standard monomials on flag varieties is closely related to semi-toric degenerations. The starting point of this project is the conviction that the theory of valuations and Newton-Okounkov bodies provides a new and more algebraic-geometric approach towards the construction of a standard monomial theory, com-pared to the construction in . Another aim is to get an algebraic-geometric version of the LS-algebras introduced in . This is a report on work in progress. 1. The setting Let X ⊂ P(V ) be an embedded projective variety with homogeneous coordinate ring R = ⊕ > i≥0 Ri = K[X]. We assume throughout the following that K is an algebraically closed field. In addition we assume that we have • a finite partially ordered set A. The partial order is graded, and A has a unique minimal element pmin and a unique maximal element pmax ; • { Yp}p∈A is a family of projective subvarieties of X, such that Ypmin = pt ,and p covers q if and only if Yq ⊂ Yp of codimension one; • { fp}p∈A is a family of homogeneous functions (on V ) such that – fp|Yp 6 ≡ 0, and Yp = {x ∈ X | fq(x) = 0 ∀q 6 ≤ p} (set theoretically) 2906 Oberwolfach Report 46/2019 – let Hp be the hypersurface {[v] ∈ P(V ) | fp(v) = 0 }, then: Hp ∩ Yp = ⋃ > qcovered by p Yq (set theoretically) . For
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
simplicity we assume that the Yp are projectively normal. In the proofs this condition can often be replaced by other properties like smooth in codimension 1, or the existence of open affine patches. Example 1. Let X = G/B ⊂ P(V (λ)) be the (generalized) flag variety, where G is a semisimple algebraic group and λ is a regular dominant weight. The partially ordered set is the Weyl group W , endowed with the Bruhat order. The family of subvarieties is given by the Schubert varieties X(τ ), τ ∈ W , and the functions fp are given by extremal weight vectors {pτ }τ ∈W ⊂ V (λ)∗ = R1.Let GA be the Hasse graph of A. We put weights on the edges as follows: we write p →b q if p covers q and fp|Yp vanishes with multiplicity b on Yq . In case X = G/B ⊆ P(V (λ)), the weights are fixed by the Pieri-Chevalley formula. 2. Valuations and a quasi-valuation Let C be a maximal chain in A. The associated sequence of subvarieties (of codi-mension one) X = Ypr ⊃ · · · ⊃ Yp0 = pt , pi ∈ C, induces a Zr+1 -valued valuation. Using ideas of Rees , we add to this valuation asymptotic considerations and attach to C a new full rank valuation VC : R → Qr+1 . Note that r + 1 = dim ˆX is the dimension of the affine cone ˆX over X. Even in the case X = G/B , it is in general not known whether the associated semigroup SC = VC(R) ⊂ Qr+1 is finitely generated. The modification introduced in the construction allows us to replace the valuations by a non-negative quasi-valuation: we fix on Qr+1 the lexicographic order, and for a given function h
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
we choose a maximal chain such that VC(h) = min {V C′ (h) | C′ maximal chain }. We replace then Qr+1 by Q|A| with basis {ep}p∈A and set: V : R → Q|A|≥0 , h 7 → ∑ > pi∈C (VC(h)) iepi 3. Results Theorem 1. i) The quasi-valuation V induces a filtration on R such that the associated graded algebra gr V R is finitely generated. The graded components are at most one-dimensional. ii) The irreducible components of the associated projective variety X0 are in bijection with maximal chains in the partially ordered set A. There exists a flat stepwise degeneration of X into the semitoric variety X0.iii) The irreducible component of X0 associated to a maximal chain C is the toric variety associated to the finitely generated semigroup: ΓC := {V (h) | h ∈ R homogeneous , VC(h) is minimal } ⊂ Qr+1 > ≥0 Mini-Workshop: Degeneration Techniques in Representation Theory 2907 4. Flag variety In case X = G/B ⊆ P(V (λ)), the semigroup can be made explicit. Let b1, . . . , b r be the weights on the edges in the maximal chain C. Then Theorem 2. ΓC = v = ar ... a0 ∈ Qr+1 > ≥0 ∣∣∣∣∣∣∣∣∣∣ br ar ∈ Z br−1(ar + ar−1) ∈ Z . . . b1(ar + ar−1 + . . . + a1) ∈ Z a0 + a1 + . . . + ar ∈ N The construction via valuations yields in a natural way an algebraic-geometric interpretation of the path model . Let C = ( τr , . . . , τ 0): Proposition 1. i) The map which associates to (ar, . . . , a 0) ∈ ΓC the pair (τr , . . . , τ
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
0; ar , a r−1 + ar , . . . , a 0 + . . . + ar ) induces a bijection between the elements of ΓC and the LS-paths of shape nλ , n ∈ N, having support in C.ii) The Newton-Okounkov body ∆V (R) ⊂ Q|A| associated to V is the (gener-alized) polytope with integral structure described in . Conjecture 3. We conjecture that the description of the semigroup Γ C (which only uses data which can be read off the weighted Hasse graph) is valid in general if the functions {fp}p∈A satisfy the following additional condition: let p cover q and let b be the weight on the edge joining the two. Then there exists a rational function η ∈ K( ˆYp) such that ηb = fp > fq in K( ˆYp). References > R. Chiriv` ı, LS algebras and application to Schubert varieties , Transform. Groups 5(2000), no. 3, 245–264. R. Dehy, Combinatorial Results On Demazure Modules , J. Algebra 205 (1998), 505–524. X. Fang and P. Littelmann, From standard monomial theory to semi-toric degenerations via Newton-Okounkov bodies , Trans. Moscow Math. Soc. 78 (2017), 275–297. P. Littelmann, Contracting modules and standard monomial theory for symmetrizable Kac-Moody algebras , J. Amer. Math. Soc. 11 (1998), no. 3, 551–567. P. Littelmann, A Littlewood-Richardson rule for symmetrizable Kac-Moody algebras , Invent. Math. 116 (1994), no. 1-3, 329–346. D. Rees, Lectures on the asymptotic theory of ideals , London Mathematical Society Lecture Note Series, 113, Cambridge University Press, Cambridge, 1988. Reporter: Ilya Dumanski 2908 Oberwolfach Report 46/2019 ## Participants Dr. Lara Bossinger Instituto de Matem´ aticas Universidad Nacional Aut´ onoma de M´ exico Centro Historico Antonio de L´ eon # 2, altos Oaxaca de Ju´ arez, CP. 68000 MEXICO Ilya
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
Dumanski Department of Mathematics National Research University Higher School of Economics Usacheva str. 6 Moscow 119 048 RUSSIAN FEDERATION Dr. Xin Fang Mathematisches Institut Universit¨ at zu K¨ oln Weyertal 86 - 90 50931 K¨ oln GERMANY Prof. Dr. Evgeny Feigin Department of Mathematics National Research University Higher School of Economics Usacheva str. 6 Moscow 119 048 RUSSIAN FEDERATION Dr. Johannes Flake Lehrstuhl B f¨ ur Mathematik RWTH Aachen Pontdriesch 10-16 52062 Aachen GERMANY Prof. Dr. Ghislain Fourier Lehrstuhl f¨ ur Algebra und Darstellungstheorie RWTH Aachen Pontdriesch 10-16 52062 Aachen GERMANY Prof. Dr. Naoki Fujita Graduate School of Mathematical Sciences The University of Tokyo 3-8-1 Komaba, Meguro-ku Tokyo 153-8914 JAPAN Prof. Dr. Syu Kato Department of Mathematics Graduate School of Science Kyoto University Kitashirakawa, Oiwake-cho, Sakyo-ku Kyoto 606-8502 JAPAN Dr. Valentina Kiritchenko Faculty of Mathematics Higher School of Economics Usacheva str. 6 Moscow 119 048 RUSSIAN FEDERATION Dr. Martina Lanini Dipartimento di Matematica Universit` a degli Studi di Roma II ”Tor Vergata” Via della Ricerca Scientifica 00133 Roma ITALY Mini-Workshop: Degeneration Techniques in Representation Theory 2909 Prof. Dr. Peter Littelmann Mathematisches Institut Universit¨ at zu K¨ oln Weyertal 86 - 90 50931 K¨ oln GERMANY Dr. Igor Y. Makhlin Center for Advanced Studies Skolkovo Institute of Science and Technology Bol’shoy Bul’var, 30 Moscow, Oblast 143 026 RUSSIAN FEDERATION Prof. Dr. Christopher Manon Department of Mathematics University of Kentucky 715 Patterson Office Tower Lexington, KY 40506-0027 UNITED STATES Prof. Dr. Martha Precup Department of Mathematics Washington University in St. Louis Campus Box 1146 One Brookings Drive St. Louis, MO 63130-4899 UNITED STATES Prof. Dr. Jenna Rajchgot Department of Mathematics University of Saskatchewan Saskatoon SK S7N 5E6 CANADA Prof. Dr. Markus Reineke Fakult¨ at f¨ ur Mathematik Ruhr-Universit¨ at Bochum Universit¨ atsstrasse 150 44801 Bochum GERMANY Prof. Dr. Julianna Tymoczko Department of
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
Mathematics Smith College Northampton, MA 01063-0001 UNITED STATES
|
{
"page_id": null,
"source": 7361,
"title": "from dpo"
}
|
Title: URL Source: Markdown Content: # Byzantine-fault tolerant algorithms in DistAlgo # Bachelor Thesis ## Roland Widmer from Bern, Switzerland Faculty of Science, University of Bern July 21th, 2020 Prof. Christian Cachin Orestis Alpos, Luca Zanolini Cryptology and Data Security Group Institute of Computer Science University of Bern, Switzerland Abstract DistAlgo is a high-level programming language for implementing distributed algorithms. Due to the high degree of abstraction, DistAlgo code is close to pseudocode. This makes it ideal for educational purposes, while it is still a running and efficient implementation. In this thesis, a DistAlgo compiler is used that produces regular Python programs. After an introduction to the programming language and the compiler, some Byzantine-fault tolerant algorithms are introduced and implemented in DistAlgo. The differences between pseu-docode and DistAlgo implementation are analyzed and discussed. iAcknowledgements First and foremost, I would like to thank my supervisors, Orestis Alpos and Luca Zanolini, for the great support. With their creative ideas they contributed a lot, especially when it came to questions about algorithms and DistAlgo. I would also like to thank Prof. Christian Cachin with his profound expertise in this topic. Furthermore, I wish to thank Alexandra Elia and Martin Widmer for proofreading the thesis. ii Contents 1 Introduction 22 Background 3 2.1 Abstractions in Distributed Programming . . . . . . . . . . . . . . . . . . . . . . . . . 32.2 Introduction to DistAlgo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 3 Preliminaries 9 3.1 Byzantine Consistent Broadcast . . . . . . . . . . . . . . .
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
. . . . . . . . . . . . . . . 93.1.1 Authenticated Echo Broadcast . . . . . . . . . . . . . . . . . . . . . . . . . . . 93.1.2 Signed Echo Broadcast . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 3.2 Byzantine Reliable Broadcast . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 3.2.1 Authenticated Double-Echo Broadcast . . . . . . . . . . . . . . . . . . . . . . . 13 3.3 Byzantine Consistent Channel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 3.3.1 Byzantine Consistent Channel . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 4 Design and Implementation 17 4.1 Byzantine Consistent Broadcast . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 4.1.1 Authenticated Echo Broadcast . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 4.1.2 Signed Echo Broadcast . . . . . . . . .
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
. . . . . . . . . . . . . . . . . . . . . . 19 4.2 Byzantine Reliable Broadcast . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 4.3 Byzantine Consistent Channel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 5 Conclusion 25 5.1 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 5.2 Future work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 A Extra material 27 A.1 Running DistAlgo programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 A.2 DistAlgo example program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 A.3 Authenticated Echo Broadcast . . . . . . . . . . . . . . . . . . . . . . . . . . . .
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
. . . 29 11Introduction Distributed algorithms are algorithms intended to achieve a certain degree of cooperation on a set of processes . They may be written in high-level pseudocode using certain assumptions, but practical implementations are usually much more extensive. DistAlgo is a high-level programming language to implement distributed algorithms in an abstract and well-structured way. Despite its high degree of abstraction, a working Python program is compiled and executed. The executability and clarity of DistAlgo implementations have many advantages, for example, researchers could find improvements in distributed algorithms using a DistAlgo implementation . DistAlgo needs to make many implicit assumptions due to its high degree of abstraction. These assumptions may be constraints for programming algorithms as well. Considering some Byzantine-fault tolerant algorithms, we will determine how they can be implemented in DistAlgo. An additional goal is to obtain DistAlgo code that is as similar as possible to the pseudocode. This thesis starts with an explanation of the abstractions used in the pseudocode implementation of the algorithms in Chapter 2. An introduction to DistAlgo follows, which also includes the abstractions used in DistAlgo. Chapter 3 introduces and describes the algorithms using pseudocode. In Chapter 4, we look at the implementations in DistAlgo. The implementations have some caveats, which are discussed in Chapter 5. All implementations may be downloaded and executed, the instructions can be found in the appendix. 22Background ## 2.1 Abstractions in Distributed Programming Abstractions are used in Distributed Programming to focus on the essential and to hide unnecessary details. This thesis uses abstractions from the book ”Introduction to Reliable and Secure Distributed Programming” . The algorithms introduced in the next chapter are also from this book and build on those abstractions. System model. The physical system may be represented with two main concepts, processes and links .Entities,
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
that are able to perform computations in a distributed system are called processes. A process may for example represent a computer or a thread on a processor. In distributed computing, processes should be able to communicate with each other. The logical and physical network connecting processes is abstracted as a link. Links allow processes to exchange messages. Composition model. To describe distributed algorithms in pseudocode, a composition model is help-ful. A process hosts a set of software components, called modules . A module is identified by a name and characterized by a set of properties. It provides an interface with events that it accepts and produces. Using modules, a layered architecture using a software stack may be constructed. At each process, a module represents a layer in the stack. Modules within the same stack communicate through the ex-change of events. Since there may exist multiple instances of a module running on the same process at the same time, instances are identified with a corresponding identifier. In this thesis an algorithm in pseudocode implements a specific module. Algorithms consist of a set of event handlers . Some are implementations of the received and produced events described in the module definition. There may be additional event handlers, which are triggered if some condition becomes TRUE . Those events are called internal events and the condition uses usually local variables. Another type of event is the initialization event . This event is generated automatically by the runtime system when an instance is created. Process abstractions. A process executes a distributed algorithm using the modules which implement the algorithm within that process. If a process does not behave according to the algorithm, a failure occurs. Different types of faults lead to the failure of a process. Process abstractions are used to define if a
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
process is faulty or correct. The simplest failure of a process is a crash, where a process stops to execute steps. With this crash-stop process abstraction, a process is considered faulty if it crashes at some time during the execution, otherwise it is called correct .3This process abstraction is simple, but it covers only a subset of process failures. Other types of fail-ures may occur, for example, if a process does not send a message it is supposed to send, which is called omission fault. The most general process abstraction is the arbitrary-fault process abstraction. There are no assumptions on the behavior of faulty processes, which means they can deviate in an arbitrary manner from the algorithm. This includes intentional and malicious attacks, but also failures caused by a bug in the implementation. Those failures are also called Byzantine and are the most expensive to tolerate. The distinction between faulty and correct processes is static. In other words, a process which is correct in the beginning and then crashes later is considered faulty. Link abstractions. Abstractions are also used for links in order to assume certain properties. In this thesis, all algorithms will use the Authenticated perfect link abstraction, which ensures the following three properties: 1. Reliable delivery: If a correct process sends a message m to a correct process q , then q eventually delivers m.2. No duplication: No message is delivered by a correct process more than once. 3. Authenticity: If some correct process q delivers a message m with sender p and process p is correct, then m was previously sent to q by p.This abstraction may also be represented as a module using our composition model, where two events are provided as an interface, one to send and one to receive messages. Broadcast. To disseminate information
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
among a set of processes, broadcast communication abstrac-tions are used. They differ according to the reliability of the dissemination. With the arbitrary-fault process abstraction, a process can deviate arbitrarily from its assigned algorithm. A process may also try to prevent the goals of the algorithm from being reached. An algorithm has to tolerate such behavior. Quorums. A helpful tool to design fault-tolerant algorithms is quorums . A quorum is a set of processes with special properties. Using the arbitrary-fault process abstraction, Byzantine quorums may be used. A Byzantine quorum tolerating f faulty processes in a system with N processes is a set of more than N+f > 2 processes. A useful property of Byzantine quorums is that two quorums overlap in at least one correct process. In every Byzantine quorum, there may be at most f faulty processes. It follows that a quorum has more correct processes than N−f > 2 , because N + f 2 − f = N − f 2 . Considering two disjoint quorums, then there are more than N − f correct processes, since N − f 2 + N − f 2 = N − f. This is a contradiction, hence there is at least one correct process occurring in both quorums. The algorithms introduced in the following chapter require a Byzantine quorum of correct processes. This is achieved by restricting the number of faulty processes f in the system, namely f is required to be smaller than N > 3 . This inequality is derived from the following formula, which states that the cardinality of the set of correct processes N − f is larger than the cardinality of a Byzantine quorum: N − f > N + f 2 ⇐⇒ N > 3f ⇐⇒ f < N 3 . 42.2 Introduction
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
to DistAlgo The advantage of a pseudocode implementation is the high degree of abstraction, which is used to facili-tate the understanding of algorithms. However, such implementations may not be executed on a system. DistAlgo is a very high-level language for clear descriptions of distributed algorithms. It combines the advantages of pseudocode and programming languages. The introduction follows roughly the ”DistAlgo language description” . Compiler. In this thesis, a DistAlgo compiler with Python as a target language is used. The DistAlgo code is processed by the compiler and the output is an ordinary Python program, which can be run on a system with Python installed. In the following chapters, the DistAlgo syntax for the Python compiler is used, as currently only this Python compiler exists. DistAlgo abstractions. The system model of a DistAlgo program is similar to the model described beforehand. Since a DistAlgo program is executable on a system, it has to be more specific. Processes in DistAlgo are represented as an instance of a process class. They use the Internet protocol as link , the usage of TCP or UDP can be configured. Messages. Processes are identified by a process identifier pid . To send and receive messages only the identifier is used, the implementation with the Internet protocol is hidden in the DistAlgo code. Messages are implemented as tuples, in this example, a 2-tuple is sent to the process with identifier pid . > send(('Hi.', 'Greetings.'), to =pid) Receive handlers may be added, similar to the event handlers of the abstract model. In this example, the function is called if a 2-tuple as in the example above is received. The variable p specified in the from argument may store a process identifier. The receive handler is only triggered if the sender of the received message matches. If the
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
variable p is not defined, the sender of the received message is accessible in the following code block using this variable. The argument from is used since from is a reserved word in Python. > def receive(('Hi.', 'Greetings.'), from_ =pid): > #function body All messages sent and received by a process are kept in variables sent and received . Synchronisation. The await statement waits for the value of a Boolean-valued expression to become > TRUE . This example waits until such a message is received, then the normal flow of control continues. > await (received(('Hi.', 'Greetings'))) To wait for multiple Boolean-valued expressions to become TRUE , a multi-part await statement may be used. The order of the statements is irrelevant, the code block of the statement which becomes TRUE first is executed. > if await (received(('Hi.',)): ... > elif received(('Bye.',)): ... > elif received(('How are you?',)): ... 5The expression may also be more complex, for example using queries described in the next paragraph. If the process is waiting in an await statement, all messages are handled by default. In all other places, a yield point has to be added, otherwise incoming messages are not handled. This example includes a busy waiting loop. Without the yield point handleMessages , incoming messages are not handled. The handleMessages statement is a special DistAlgo structure that is transformed into a function call by the compiler. This function handles the received messages. > while True :--receiveMessages > #loop body Queries. A high-level query is over arbitrary sets or sequences, however often the message history received is used. Three concepts may be used, namely comprehension , aggregation , and quantification .Combinations and nesting of these are possible as well. In this introduction the formal definitions are omitted, instead, some explicit examples are introduced, which are similar
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
to the queries used in the implementations of the algorithms. A comprehension is implemented using the setof statement. The following example returns the set of all processes from which the process received a Hi message. > setof(proc, received(('Hi',), from_= proc)) Aggregations use an aggregation operator, which may be len , sum , min , or max . The first line returns the cardinality of the set of all processes from which the process received a Hi message. This set consists of DistAlgo process identifiers. There is an order implemented on this set, therefore min and max operators may also be used. The second line returns the highest process identifier from the same set as before. > len(setof(proc, received(('Hi',), from_= proc))) max(setof(proc, received(('Hi',), from_= proc))) A quantification is implemented using the each or the some statement and a Boolean value is returned. Assuming the variable clients is the set containing all processes which have sent a Hi message to the process, then TRUE is returned. Otherwise, if a process exists in this set which has not sent a Hi message to the process, then FALSE is returned. The second line returns TRUE if a process exists which has sent a Hi message to the process. Sometimes, it is helpful to know for which process the condition in the has argument is true. This process is accessible later by using the variable proc . > each(proc in clients, has=received(('Hi',), from_ =proc)) some(proc in clients, has=received(('Hi',), from_ =proc)) Structure of a DistAlgo program. DistAlgo programs are written in .da files. Each file consists of one or more process definitions and a main function. A process p is defined by extending the class process . > class Bob (process): ... > class Alice (process): ... > def main(): ... The process body contains a
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
set of methods and handlers. A special setup method may be used to initialize data before the process is started. All arguments of the method automatically become instance variables of the process. If additional instance variables are required, it is possible to define them in the setup method. Another special method is the run method. It is defined for carrying out the main flow of execution. A process is alive as long as this run method is running, otherwise the process is terminated 6and thus may no longer send or handle messages. In addition to these special methods, the process body may consist of additional helper methods or receive handlers. It is important to remember that receive handlers are only triggered if the flow of control reaches a yield point or an await statement, as described in paragraph Synchronisation. The following example shows a process body. The setup method takes a process identifier as a parameter, which is later accessible using the variable alice . Another instance variable, the Boolean flag greeted , is also defined. The run method contains an await statement, therefore the subsequent receive handler may be triggered until the run method has terminated. > class Bob (process): > def setup(alice:da.common.ProcessId): self.greeted =False def run(): send(('Hi Alice',), to=alice) > if await (self.greeted == True ): send(('Bye',), to=alice) > def receive(msg=('Hi Bob',), from_=p): output("Hi Bob received from", p) self.greeted =True Below the process bodies is the entry point of a DistAlgo program, the main method. It is used to create, set up, and start processes. The new statement creates processes and returns the corresponding process identifiers. With the argument num , the number of processes to create may be specified. The setup statement is used to pass arguments to the processes. The statement executes the setup method of
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
the corresponding processes. Then, as a third step, the processes may be started with the start statement. This executes the run method of the corresponding processes. The following example creates three Bob processes and one Alice process. We can see the benefits of this three-part process creation. The Bob processes need the process identifier of the Alice process. Assuming that the Alice process also needs the process identifiers of the Bob processes, this would not be directly possible with a one-part process creation, because the setup statement is the only way to pass data to processes besides normal messages. > def main(): alice =new(Alice, num=1) bobs = new(Bob, num=3) setup(alice, (n_bobs,)) setup(bobs, (alice,)) start(alice) start(bobs) Compiling and Running. To execute DistAlgo source code in a .da file a computer is required that has the DistAlgo compiler installed. The command python3 -m da .da is used to compile the source code. Subsequently, the program is executed automatically . Nodes. DistAlgo processes are executed on nodes. By default, all processes are executed on the same unnamed node. But it is also possible to execute the processes on multiple nodes. To distinguish be-tween them, a name is assigned to each of them. They might also run on different machines that are connected through the Internet. To run a DistAlgo program on multiple nodes, some modifications to the main method are necessary. It has to be specified on which node which processes are executed. For this purpose the at argument of the new statement is used. In the following example the three Bob pro-cesses should be executed on a node with the name BobNode . The Alice process should be executed on AliceNode . For this purpose, an at argument is added to the respective new statement. 7def main(): alice = new(Alice, num=1, at='AliceNode')
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
bobs = new(Bob, num=3, at='BobNode') setup(alice, (n_bobs,)) setup(bobs, (alice,)) start(alice) start(bobs) To execute the program on the two nodes, two terminals are required. A node is named using the -n option. More information about running a DistAlgo program on multiple nodes can be found in the DistAlgo repository . > python3 -m da -n AliceNode helloworld.da python3 -m da -n BobNode -D helloworld.da A first difference to the pseudocode abstraction becomes already visible. DistAlgo processes are inde-pendent of each other and always have their own TCP interface. Even if they are running on the same node, the only way to communicate is regular message exchange, in contrast to the composition model no local events exist. Therefore, a layered architecture with modules as layers as described in the com-position model is not possible. This difference influences the DistAlgo implementations as they may not be translated directly. The following chapters introduce some strategies to address this issue. 83Preliminaries We continue with the introduction to some Byzantine-fault tolerant algorithms. The specifications are taken from and use the abstract model introduced in Chapter 2. ## 3.1 Byzantine Consistent Broadcast The Byzantine consistent broadcast (Module 1) abstraction may be represented as a module using the composition model. Every instance of the module has a pre-defined sender process s, which broadcasts a message m. If another message has to be sent or if another process has to send a message, an additional instance is required. The interface of the module consists of two events. One of them, the broadcast event, may only be triggered once by the sender process s. The deliver event is triggered by a correct process, if a message was received, that was broadcast by a process. As faulty processes can deviate arbi-trarily from the algorithm assigned to them, some properties are
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
specified. An algorithm that implements this module must satisfy these properties. The validity property guarantees that if a process p broadcasts a message m, then every correct pro-cess eventually delivers m. The second property, no duplication , allows correct processes to deliver at most one message. This constraint is appropriate since only one message may be sent per instance. In-tegrity ensures, that if a correct process delivers a message m with sender p and process p is correct, then m was previously broadcast by p. The fourth property is called consistency and it states that if some correct process delivers a message m and another correct process delivers a message m’ , then is m = m’ .In the following section, two algorithms are introduced which fulfill these properties. 3.1.1 Authenticated Echo Broadcast Requirements. The amount of Byzantine processes f in the system should be smaller than N > 3 . Authen-ticated perfect links are used as a link abstraction. Algorithm overview. The Authenticated echo broadcast (Algorithm 1) consists roughly of two rounds. After initialization, the sender process sends the message to every processes in the system. In a second round, the message from the sender process is resent by all processes to every processes again as an > ECHO message. Once a process has received more than N+f > 2ECHO messages with the same message, the message is delivered. 9Module 1 Interface and properties of Byzantine consistent broadcast. Module: Name: ByzantineConsistentBroadcast, instance bcb , with sender s. Events: Request: 〈bcb , Broadcast | m〉: Broadcasts a message m to all processes. Executed only by process s. Indication: 〈bcb , Deliver | p, m〉: Delivers a message m broadcast by process p. Properties: BCB1: Validity: If a correct process p broadcasts a message m, then every correct process eventually delivers
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
m. BCB2: No duplication: Every correct process delivers at most one message. BCB3: Integrity: If some correct process delivers a message m with sender p and process p is correct, then m was previously broadcast by p. BCB4: Consistency: If some correct process delivers a message m and another correct process delivers a message m’ , then m = m’ . Algorithm 1 Authenticated Echo Broadcast. Implements: ByzantineConsistentBroadcast, instance bcb , with sender s. Uses: AuthPerfectPointToPointLinks, instance al . upon event 〈bcb , Init 〉 do sentecho := FALSE delivered := FALSE echos := [ ⊥]n upon event 〈bcb , Broadcast | m〉 do* forall q ∈ Π do trigger 〈al , Send | q, [SEND , m ]〉 upon event 〈al , Deliver | p, [SEND , m ]〉 such that p = s and sentecho = FALSE do sentecho := TRUE forall q ∈ Π do trigger 〈al , Send | q, [ECHO , m ]〉 upon event 〈al , Deliver | p, [ECHO , m ]〉 do if echos [p] = ⊥ then echos [p] := m upon exists m 6 = ⊥ such that #( {p ∈ Π | echos [p] = m}) > N+f > 2 and delivered = FALSE do delivered = TRUE trigger 〈bcb , Deliver | s, m〉 * only sender process s 10 Correctness. It follows from the f 3 assumption that there are more than N +f > 2 correct processes in the system. If the sending process is correct and sends a SEND message, then more than N +f > 2 processes will receive it and send an ECHO message. Hence, more than N +f > 2 processes will receive an ECHO message with the same message m. The messages are not lost or have not
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
been sent by another process, as there are also requirements for the links. The correct processes will receive enough ECHO messages to deliver the message m. This proves the validity property. No duplication follows directly from the algorithm. If the flag delivered is TRUE , no further message may be delivered. If a correct process delivers a message m with sender s, then the process has received ECHO messages containing m from more than N +f > 2 processes. Among these processes, at least one process p is correct, since these processes form a Byzantine quorum. Thus p has received a SEND message from s. If s is correct, then s has broadcast m, which shows integrity . Consistency follows from a property of Byzantine quorums. Two Byzantine quorums overlap in at least one correct process. If a correct process delivers a message m, then it received ECHO messages with m from more than N +f > 2 processes. This set of processes is a Byzantine quorum. If another correct process p’ delivers a message m’ , then there is another Byzantine quorum of ECHO messages containing m’ . The two quorums overlap in a correct process, which sent all ECHO messages with the same message, hence m = m’ . 3.1.2 Signed Echo Broadcast The Authenticated echo broadcast sends a quadratic number of messages over the links. To reduce this amount, a cryptographic digital signature scheme may be used. This section introduces another algorithm which fulfills the properties of Byzantine consistent broadcast but only sends a linear number of messages over the links. Requirements. As in the algorithm before, the Authenticated perfect link abstraction is used and the amount of Byzantine processes in the system is limited to f 3 .In addition, a digital signature scheme
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
is required that provides two functions sign and verifysig . A process may get a signature of a message using the sign function with its process identifier. On the other hand, a process may verify a signature of an incoming message by calling the verifysig function, which returns a Boolean value. Algorithm overview. In a first round of Signed echo broadcast (Algorithm 2), the message is sent from the sender process to all processes. Instead of sending the ECHO messages in the second round to all processes as in the algorithm before, the ECHO messages are only sent back to the sender, however, a signature is added. If the sender has received a message m in more than N +f > 2ECHO messages, it sends a > FINAL message to all processes. This message also contains the signatures of all ECHO messages. Any process that receives the FINAL message may then use the signatures to verify that the sender process has received enough ECHO messages to deliver the message. Correctness. The FINAL message with the signatures of the ECHO messages contains indirectly the same information as the ECHO messages sent to all processes in the Authenticated echo broadcast . If a correct process delivers a message m, it has received a FINAL message with N +f > 2 valid signatures. The digital signature scheme guarantees that the sender process has received an ECHO message containing m from at least N +f > 2 processes. With this observation, the proof of the Authenticated echo broadcast may be used to show the four properties. ## 3.2 Byzantine Reliable Broadcast To guarantee that a correct process delivers a message if and only if every other correct process delivers a message, a fifth property may be added to the properties of Byzantine consistent broadcast
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
. It is called totality . With this fifth property, we define Byzantine reliable broadcast (Module 2). As before, only 11 Algorithm 2 Signed Echo Broadcast. Implements: ByzantineConsistentBroadcast, instance bcb , with sender s. Uses: AuthPerfectPointToPointLinks, instance al . upon event 〈bcb , Init 〉 do sentecho := FALSE sentfinal := FALSE delivered := FALSE echos := [ ⊥]n Σ := [ ⊥]n upon event 〈bcb , Broadcast | m〉 do* forall q ∈ Π do trigger 〈al , Send | q, [SEND , m ]〉 upon event 〈al , Deliver | p, [SEND , m ]〉 such that p = s and sentecho = FALSE do sentecho := TRUE σ := sign (self , bcb || self || ECHO || m) forall q ∈ Π do trigger 〈al , Send | q, [ECHO , m, σ ]〉 upon event 〈al , Deliver | p, [ECHO , m, σ ]〉 do* if echos [p] = ⊥ and verifysig (p, bcb || ECHO || m, σ ) then echos [p] := m Σ[ p] := σ upon exists m 6 = ⊥ such that #( p ∈ Π | echos [p] = m) > N+f > 2 and sentfinal = FALSE do* sentfinal := TRUE forall q ∈ Π do trigger 〈al , Send | q, [FINAL , m, Σ] 〉 upon event 〈al , Deliver | p, [FINAL , m, Σ] 〉 do if #( {p ∈ Π | Σ[ p] 6 = ⊥ and verifiysig (p, bcb || p|| ECHO || m, Σ[ p]) }) > N+f > 2 and delivered = FALSE do delivered := TRUE trigger 〈bcb , Deliver | s, m〉 * only sender process s 12 one message may be broadcast and the sender process is pre-determined. Combining the consistency and totality property, a simpler
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
property arises. It states that if a message m is delivered by some correct process, then m is eventually delivered by every correct process. Module 2 Interface and properties of Byzantine reliable broadcast. > Module: Name: ByzantineReliableBroadcast, instance brb , with sender s. > Events: Request: 〈brb ,Broadcast |m〉: Broadcasts a message mto all processes. Executed only by process s. > Indication: 〈brb ,Deliver |p,m〉: Delivers a message mbroadcast by process p. > Properties: BRB1: Validity: If a correct process pbroadcasts a message m, then every correct process eventually delivers m. > BRB2: No duplication: Every correct process delivers at most one message. > BRB3: Integrity: If some correct process delivers a message mwith sender pand process pis correct, then mwas previously broadcast by p. > BRB4: Consistency: If some correct process delivers a message mand another correct process delivers a message m’ , then m=m’ . > BRB5: Totality: If some message is delivered by any correct process, every correct process eventually delivers a message. 3.2.1 Authenticated Double-Echo Broadcast The Authenticated double-echo broadcast (Algorithm 3) is an extension of the Authenticated echo broad-cast , to additionally satisfy totality . This is achieved by adding a third round of message exchange. Requirements. The requirements are the same as for the Authenticated echo broadcast . As links, the Authenticated perfect link abstraction is used. The number of faulty processes f should be smaller than N > 3 . Algorithm overview. First, the sender process sends the message to all processes. Then, the processes send an ECHO message to all processes. Once a process has received a Byzantine quorum of ECHO messages, it sends a READY message to all processes to indicate that it is ready to deliver. In addition, the algorithm includes an amplification step for the READY messages. If a
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
process has received READY messages from more than f processes, it sends a READY message to all processes itself. This mechanism is required to satisfy the totality property. Correctness. To show the validity , no duplication , and integrity properties, the arguments of the proof of Authenticated echo broadcast may be used. If some correct processes send a READY message, then they all send the same message m. This follows from the consistency property of the Authenticated echo broadcast . Consistency of the Authenticated double-echo broadcast follows from this observation. If some correct process delivers a message m, then the process received READY messages from more than 2f processes. Thus more than f correct processes sent a READY message to the process. As they are correct, they send a READY message by the amplification step or after receiving enough ECHO messages. In both cases, they eventually deliver the message m. This shows the totality property. 13 Algorithm 3 Authenticated Double-Echo Broadcast. Implements: ByzantineReliableBroadcast, instance brb , with sender s. Uses: AuthPerfectPointToPointLinks, instance al . upon event 〈brb , Init 〉 do sentecho := FALSE sentready := FALSE delivered := FALSE echos := [ ⊥]n readys := [ ⊥]n upon event 〈brb , Broadcast | m〉 do* forall q ∈ Π do trigger 〈al , Send | q, [SEND , m ]〉 upon event 〈al , Deliver | p, [SEND , m ]〉 such that p = s and sentecho = FALSE do sentecho := TRUE forall q ∈ Π do trigger 〈al , Send | q, [ECHO , m ]〉 upon event 〈al , Deliver | p, [READY , m ]〉 do if readys [p] = ⊥ then readys [p] := m upon event 〈al , Deliver | p, [ECHO , m ]〉 do if echos [p] = ⊥ then
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
echos [p] := m upon exists m 6 = ⊥ such that #( {p ∈ Π | echos [p] = m}) > N+f > 2 and sentready = FALSE do sentready := TRUE forall q ∈ Π do trigger 〈al , Send | q, [READY , m ]〉 upon exists m 6 = ⊥ such that #( {p ∈ Π | readys [p] = m}) > f and sentready = FALSE do sentready := TRUE forall q ∈ Π do trigger 〈al , Send | q, [READY , m ]〉 upon exists m 6 = ⊥ such that #( {p ∈ Π | readys [p] = m}) > 2f and delivered = FALSE do delivered := TRUE trigger 〈brb , Deliver | s, m〉 * only sender process s 14 3.3 Byzantine Consistent Channel The two broadcast abstractions we considered so far may send at most one message. The Byzantine consistent channel abstraction (Module 3) introduced in this section allows us to send multiple messages without specifying the sender beforehand. Again, the abstraction is represented as a module in our composition model. The interface consists of two events, a broadcast and deliver event. Additionally, a label ` is used to distinguish the different roles a message may play. The implementation of the labels is determined by the algorithm under the condition that labels are unique on a process for all messages from a given sender. For example, a per-sender sequence number may be used. The four properties are similar to the Byzantine consistent broadcast abstraction, except that the labels are also included. Module 3 Interface and properties of Byzantine consistent channel. > Module: Name: ByzantineConsistentBroadcastChannel, instance bcch , with sender s. > Events: Request: 〈bcb ,Broadcast |m〉: Broadcasts a message mto all processes. > Indication: 〈bcb ,Deliver |p,l,m〉: Delivers a
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
message mwith label `broadcast by process p. > Properties: BCCH1: Validity: If a correct process pbroadcasts a message m, then every correct process eventually delivers m. > BCCH2: No duplication: For every process pand label `, every correct process eventually delivers at most one message with label `and sender p. > BCCH3: Integrity: If some correct process delivers a message mwith sender pand process pis correct, then mwas previously broadcast by p. > BCCH4: Consistency: If some correct process delivers a message mwith label `and sender s,and another correct process delivers a message m’ with label `and sender s, then m=m’ . 3.3.1 Byzantine Consistent Channel The idea of the Byzantine consistent channel (Algorithm 4) is to use multiple instances of the Byzantine consistent broadcast abstraction. Since the sender is pre-determined in this abstraction, an instance is created for every process. Therefore, for every process an instance exists, whereby the process is the sender. Since at most one message may be sent, a new instance with the corresponding sender process is created after every deliver event of the broadcast instance. Requirements. The algorithm has no additional requirements. However, if for example the Authenti-cated echo broadcast is used as an implementation of the Byzantine consistent broadcast abstraction, the requirements for this algorithm have to be considered. Algorithm overview. A per-sender sequence number is used as a label implementation. It is set to 0 for every process during initialization. Then an instance of Byzantine consistent broadcast is created for every process. The instances have a unique name, which includes the sender process and the sequence number of this process. In the case of a broadcast event on the channel, the broadcast event of the instance, where the process itself is the sender, is triggered. Since an instance may only broadcast one message,
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
a ready flag is used. If an instance of Byzantine consistent broadcast delivers, the channel also delivers. Then, a new instance is created for this process and the corresponding sequence number is incremented. If the process is also the sender process of the new instance, then the ready flag is set to > TRUE , as the new instance may broadcast another message. 15 Correctness. Together with the properties of the labels and the Byzantine consistent broadcast abstrac-tion, the four properties may be shown directly. Algorithm 4 Byzantine Consistent Channel. Implements: ByzantineConsistentChannel, instance bcch . Uses: ByzantineConsistentBroadcast, multiple instances. upon event 〈bcch , Init 〉 do n := [ 0]n ready := FALSE forall p ∈ Π do Initialize a new instance of ByzantineConsistentBroadcast with sender p named bcb.p.n[p] upon event 〈bcch , Broadcast | m〉 such that ready = TRUE do trigger 〈bcb.self.n[self] , Broadcast | m〉 ready := FALSE upon event 〈bcb.p.n[p] , Deliver | p, m〉 do trigger 〈bcch , Deliver | p, n[p] , m〉 n[p] := n[p] + 1 Initialize a new instance of ByzantineConsistentBroadcast with sender p named bcb.p.n[p] if p = self then ready := TRUE 16 4Design and Implementation For the implementation of the algorithms in DistAlgo, we will represent the algorithms implementing the modules as DistAlgo processes. Even if this seems unexpected, this choice is reasonable. Similar to the algorithms in our abstract model, DistAlgo processes contain definitions of event handlers and methods. However, a DistAlgo process represents a process in our system model as well, since a DistAlgo process is connected to others by links. ## 4.1 Byzantine Consistent Broadcast 4.1.1 Authenticated Echo Broadcast The initialization event consists of two flags sentecho and delivered that are set to FALSE . In addition, a variable echos is initialized with FALSE for
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
all processes in the system. This event is realized conveniently in DistAlgo by using the setup method. A Python dictionary is used as data structure for echos . To send messages to all processes later on, the identifiers of all processes are required. For this purpose, the argument procs is used. The number of processes n and the number of Byzantine processes f are used to calculate the bound whether sufficiently many ECHO messages have been received to deliver or not. Since the bound is a static value, it is pre-calculated and stored in the variable quorumbound , so it only needs to be calculated once. The argument sender contains the identifier of the pre-defined sender process. The last argument msg is an empty string by default, it only contains the message to be broadcast for the sender process. Eventually, if the process is the sender, the broadcast helper method is directly called. def setup(procs:set, n:int, f:int, sender:da.common.ProcessId, msg:str = ''): self.sentecho = False self.delivered = False self.echos = dict((p, False ) for p in procs) self.is_sender = True if sender == self else False self.quorumbound = (self.n + self.f) / 2 if self.is_sender: broadcast() Also the broadcast method is similar to the pseudocode counterpart. However, it should be mentioned that this is implemented as a helper method and not as an event. The reason for this choice and the resulting consequences are discussed in Chapter 5. 17 def broadcast(): send(('SEND', self.msg), to = procs) The following receive handler is used to handle received SEND messages. The SEND message is sent by the sender process. This is verified using the from argument. The other condition, that no ECHO mes-sages have been sent so far, is directly tested in the handler definition in the pseudocode implementation. This is not possible in
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
DistAlgo, hence an if statement is used. > def receive(msg=('SEND', m), from_= self.sender): > if not (self.sentecho): self.sentecho =True > send(('ECHO', m), to= self.procs) To handle the ECHO messages another handler is defined as in pseudocode. In this handler, the from argument is no longer used to determine whether the sender of the message is a certain process. In this case, the identifier of the sender is stored in the variable p. Within the following block, the identifier can be accessed using this variable p. Since the Python data structure dictionary is used for the variable echos , the messages are stored in a similar way as in the pseudocode. At the end, a helper method check echos received is called. The underlying idea is explained in the next paragraph. > def receive(msg=('ECHO', m), from_= p): > if self.echos[p] == False :self.echos[p] =mcheck_echos_received() The helper method contains an extensive condition. The condition corresponds to the condition of the last event handler specified in the pseudocode. First, it is verified that the flag delivered is FALSE . Then a quantification is used to check whether a message m from echos exists which fulfills the condition in the has argument. With an aggregation, it is checked if the given set is larger than the variable bound . It is also verified that m is a message and not the initial value FALSE . The aggregated set is formed by a comprehension. It consists of all processes in the system from which the message m was received in an > ECHO message. If the complete condition holds, the helper method deliver is called. In this paragraph, it becomes clear that DistAlgo queries provide an elegant way to implement extensive conditions. In the pseudocode, this condition was defined as an event handler. Since in
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
DistAlgo only receive handlers for messages may be defined, a direct translation is not possible. However, given that the condition only depends on the variables echos and delivered , it is sufficient to check the condition only in case the variables have been changed. The helper method call in the receive handler above is used for this purpose. > def check_echos_received(): > if not (self.delivered) and > some(m in self.echos.values(), has=( len(setof(p, pin procs, self.echos[p] == m)) >self.quorumbound and m!= False )): deliver(m) The helper method deliver sets delivered to TRUE and outputs the message in the terminal. > def deliver(m: str): self.delivered =True > output(m) As in every DistAlgo process, a run method is required. In this case, a simple await statement is used. It waits indefinitely, as FALSE never becomes TRUE , nevertheless incoming messages are handled and the corresponding receive handlers are triggered. 18 def run(): > await (False ) To create and start the processes, we use the main function. All processes in the system are of the same class AuthEchoBroadcast , whose methods and receive handlers are described above. The sender process is also of the same class, but it has other arguments for the setup statement, especially the message being broadcast, thus the setup statement is called separately for this process. The algorithm uses the Authenticated perfect link abstraction as links. To use TCP for the message exchange between processes, a config statement is used. However, TCP does not fully comply with an Authenticated perfect link abstraction; in particular, authenticity is not guaranteed by TCP . This issue is discussed in Chapter 5. > def main(): config(channel={'reliable','fifo'}) #use TCP > nprocesses =10 f=2message ='This is atest message.' procs =new(AuthEchoBroadcast, num= nprocesses) procs_without_sender =procs.copy() sender =procs_without_sender.pop() setup(procs_without_sender, (procs, nprocesses, f, sender)) setup(sender, (procs, nprocesses, f,
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
sender, message)) start(procs) Alternative. Await statements can also be used as internal events in DistAlgo. The condition that is checked in the event handler in the pseudocode may also be placed in an await statement. Since an effort was made to implement the await statements efficiently, the performance is not considerably lower . The check echos received method and the corresponding calls are no longer needed. This alternative version does not use busy waiting since the block in the while loop is only executed once. When the process starts, the run method is called. Then, the await statement waits until the condition for delivering the message becomes TRUE . The deliver helper method is called, which sets the variable delivered to > FALSE , which will exit the while loop. > def run(): > while not self.delivered: > await (some(m in self.echos.values(), has=( len(setof(p, pin procs, self.echos[p] == m)) >self.quorumbound and m!= False ))) deliver(m) The complete implementation can be found in the appendix. 4.1.2 Signed Echo Broadcast The initial step of implementing the pseudocode of the Signed echo broadcast algorithm is to provide the functions sign and verifysgn . For this purpose, an ordinary Python class Crypto is imported. This class provides sign and verifysgn as static methods. The actual implementation is irrelevant, it is only assumed that the methods fulfill the requirements of a digital signature scheme . The initialization and the broadcast method are implemented analogously to the Authenticated echo broadcast . Additionally, another Python dictionary sigma is initialized, in which the signatures of the ECHO messages are stored later on. > def setup(procs:set, n:int, f:int, sender:da.common.ProcessId, msg:str =''): self.sentecho =False 19 self.sentfinal = False self.delivered = False self.echos = dict((p, False ) for p in procs) self.sigma = dict((p, False ) for p in procs) self.is_sender
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
= True if sender == self else False self.quorumbound = (self.n + self.f) / 2 if self.is_sender: broadcast() def broadcast(): output('BROADCAST \' ', self.msg, '\' ') send(('SEND', self.msg), to= procs) To create a signature, the sign method of the Crypto class is used. The ECHO messages are no longer sent to all processes in the system, but only back to the sender process. def receive(msg=('SEND', message), from_= self.sender): if not (self.sentecho): self.sentecho = True signature = Crypto.sign(self, repr(self) + 'ECHO' + message) send(('ECHO', message, signature), to= self.sender) The following receive handler is only relevant to the sender process because only this process receives > ECHO messages. The received signatures are stored in the variable sigma . With every modification of the echos variable, it is checked if sufficiently many ECHO messages were received. If so, the FINAL message including the signatures is sent to all processes. def receive(msg=('ECHO', message, signature), from_= p): if self.is_sender: if self.echos[p] == False and Crypto.verifysig(source, repr(source) + 'ECHO' + message, signature): self.echos[p] = message self.sigma[p] = signature check_echos_received() def check_echos_received(): if not (self.delivered) and some(m in self.echos.values(), has=( len(setof(p, p in procs, self.echos[p] == m)) > self.quorumbound and m != False and not (self.sentfinal)) ): send_final(m) def send_final(m: str): self.sentfinal = True send(('FINAL', m, self.sigma ), to= self.procs) If a process receives a FINAL message, it verifies the received signatures. If there are sufficiently many valid signatures for this message, then the message is delivered. Similarly, no event handler is used to check the condition. Instead, it is checked immediately after a FINAL message has been received. def receive(msg=('FINAL', message, sigma), from_= source): if not (self.delivered) and len(setof(p, p in self.procs, sigma[p] and Crypto.verifysig(p, repr(p) + 'ECHO' + message, sigma[p]))) > self.quorumbound: self.delivered = True output(message) The run method and the main function are the
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
same as in the Authenticated echo broadcast implementa-tion. 20 4.2 Byzantine Reliable Broadcast The description of the initialization, the broadcast method, and the receive handler for handling the > SEND and ECHO messages is omitted since these are almost identical to the corresponding structures in the Authenticated echo broadcast implementation. The READY message receive handler is analogous to the pseudocode. Then, two helper methods are defined, which are required later. The method send ready sends the message to all processes in the system and sets the flag sentready to TRUE to ensure that READY messages are only sent once per process. The method deliver sets delivered to TRUE and outputs the given message in the terminal. > def receive(msg=('READY', message), from_= source): > if self.readys[source] == False :self.readys[source] =message > def send_ready(m: str): self.sentready =True > send(('READY', m), to= self.procs) > def deliver(m: str): self.delivered =True > output(m) Instead of checking the three conditions when receiving specific messages, a multi-part await statement is used in this case. The only reason for this choice is the readability of the code. Another option is to write helper methods that check the conditions and call them whenever a relevant message is received as in the implementations before. The while loop does not involve busy waiting since most of the time the process waits for one of the three expressions to become TRUE . The first part represents the event in the pseudocode, which sends the READY messages if sufficiently many ECHO messages are received. The second part is the amplification step, as described in the previous chapter. The last part delivers the message if there are sufficiently many processes from which a READY message with a certain message has been received, which was represented as the last event in the pseudocode implementation. All
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
three parts use the helper methods described above. > def run(): > while not (self.delivered): > if await (some(m in self.echos.values(), has=( len(setof(p, pin procs, self.echos[p] == m)) >self.quorumbound and > m!= False and not (self.sentready)) ): send_ready(m) > elif some(m in self.readys.values(), has=( len(setof(p, pin procs, self.readys[p] == m)) >self.f and > m!= False and not (self.sentready)) ): send_ready(m) > elif some(m in self.readys.values(), has=( len(setof(p, pin procs, self.readys[p] == m)) >2 * self.f and > m!= False )): deliver(m) The main function is omitted, as it is the same as in the algorithms described before. ## 4.3 Byzantine Consistent Channel Until now, the pseudocode of the algorithms consisted of two layers, the algorithm layer, which im-plemented the algorithm, and the link layer, which was implemented by a Authenticated perfect link abstraction. Even if DistAlgo does not support a layered architecture due to the lack of local events, this was not an issue for the implementations, since the underlying layer was the link layer. This layer is available in every DistAlgo process by using the send and receive statements as described in Chapter 2. 21 However, the Byzantine consistent channel algorithm uses a third layer of multiple, dynamically gener-ated instances of Byzantine consistent broadcast . For the implementation in DistAlgo, we have to find a way to exchange information between those two layers directly without using messages. The main idea is to integrate the functionality of the Byzantine consistent broadcast directly in the process body of the Byzantine consistent channel . The dynamically created instances of Byzantine consistent broadcast are only virtual. More precisely, a label is added to all messages belonging to the third layer in the pseudocode. It follows from the properties of the label that an instance is uniquely identified by a label. Therefore the receiving
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
DistAlgo process is able to determine the virtual instance of the received message. In this implementation, the Authenticated echo broadcast implementation is used, but another algorithm implementing Byzantine consistent broadcast would also be possible. The first part of the setup method initializes the data structures for the Byzantine consistent channel itself. The second part initializes the data structures of the Authenticated echo broadcast algorithm. However, to distinguish the instances, different data structures are used than in the original implementation. The former flags are modeled as sets, while the variable echos is still a Python dictionary. The key now consists of a label and a process. The label is implemented as per sender sequence number, thus a label consists of the identifier of the sender process and the corresponding sequence number. A nested for-loop is necessary since it requires for every process an instance, such that for each process an instance exists with this process as a sender. This is the purpose of the outer loop. The Authenticated echo broadcast itself requires a FALSE in the variable echos for every process at the beginning. > def setup(procs:set, nprocesses:int, f:int): self.n = dict((p, 0) for pin procs) self.ready =True > self.quorumbound =(self.nprocesses +self.f) /2self.sentecho =set() self.delivered =set() self.echos =dict() > for sender in procs: > for pin procs: self.echos[(0, sender), p] = False To start a broadcast, a normal message exchange is used. With the following receive handler, the main function may send a BROADCAST message to a process, which then broadcasts the message. In the pseu-docode, the ready flag is set to FALSE and the broadcast event of the corresponding instance is triggered. Since there are no instances in this DistAlgo implementation, a SEND message with the associated label is sent. In this case, this is only the sequence number, since
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
the identifier of the sender process is also the sender of the SEND message and may be obtained by using the from argument. > def receive(msg=('BCCH', 'BROADCAST', m)): > if self.ready: bcb_broadcast(m) self.ready =False def bcb_broadcast(m: str): send(('BCB', 'SEND', m, self.n[self]), to =procs) The following receive handlers are copied from the Authenticated echo broadcast and adapted to the new data structures. The variable sentecho is modeled as a set. If a label, consisting of the identifier of the sender process and the associated sequence number, is in the set, the corresponding flag is TRUE ,otherwise it is FALSE . This implementation has several advantages. Since the flag is initially FALSE ,no action is required whenever a new sequence number is used. In addition, membership checks are efficient in Python and a more complicated dictionary data structure is avoided. The variable delivered is modeled analogously. 22 def receive(msg=('BCB', 'SEND', m, sequence_number), from_= sender): > if not ((sequence_number, sender) in self.sentecho): self.sentecho.add((sequence_number, sender)) send(('BCB', 'ECHO', m, sender, sequence_number), to= self.procs) > def receive(msg=('BCB', 'ECHO', m, sender, sequence_number), from_= p): > if self.echos[(sequence_number, sender), p] == False :self.echos[(sequence_number, sender), p] =mcheck_echos_received() The next method is copied and adapted to the new data structure again. The Python method items returns key-value pairs as tuples in a list. In this case the key consists of a process, from which the ECHO message was sent, and the corresponding label. The value contains the message. With this information, it is verified that delivered with this label is still false. Furthermore, it is checked if the process has received ECHO messages with this label and a message other than FALSE from sufficient processes. If this condition is TRUE , the bcb deliver helper method is called. > def check_echos_received(): > if some(item in self.echos.items(), has=( > not (item
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
in self.delivered) and > len(setof(tup, tup in self.echos.keys(), self.echos[tup] == item)) >self.quorumbound and > item != False )): bcb_deliver(item, item) The bcb deliver method adds the label to the set delivered . This has the same effect as setting the flag delivered to TRUE in the Authenticated echo broadcast . In the pseudocode implementation, a new instance would then be created for this sender process. Without instances, only the data structures for the new label have to be modified. In other words, the variable echos is initialized to FALSE for every process with this new label. The two flags sentecho and delivered do not need to be adjusted, as they are modeled as sets as described before. If the process itself was the sender of the message, then ready is set to TRUE again, allowing another message to be broadcast. It is important to remember that a broadcast sends the message back to the sender as well. > def bcb_deliver(label:tuple, m:str): self.delivered.add(label) bcch_deliver(label, m) > def bcch_deliver(label:tuple, m:str): new_sequence_number =n[label] +1 > for pin procs: self.echos[(new_sequence_number, label), p] =False if label == self: self.ready =True > output(m, label) The main method consists of the creation of the processes, which is analogous as in the algorithms described before. Then, some messages are broadcast. The main function has also a TCP interface and may send messages to processes. In this case, four BROADCAST messages are sent, two of them directly after each other. There is not sufficient time for the process to broadcast the message, and ready will still be FALSE , therefore, this message will not be sent. The work statement waits for some seconds. During this time, the message is broadcast and the process will be ready again for the next message. > def main(): ... procs =new(ByzantineConsistentChannel, num= nprocesses)
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
23 setup(procs, (procs, nprocesses, f)) start(procs) sender = procs.pop() sender2 = procs.pop() send(('BCCH', 'BROADCAST', 'test'), to= sender) send(('BCCH', 'BROADCAST', 'test2'), to= sender) # not ready yet work() send(('BCCH', 'BROADCAST', 'test3'), to= sender) send(('BCCH', 'BROADCAST', 'test4'), to= sender2) 24 5Conclusion ## 5.1 Discussion The objective to implement some Byzantine-fault tolerant algorithms in DistAlgo was achieved. Fur-thermore, the DistAlgo code is quite similar to the pseudocode, several handlers could even be translated directly. Nevertheless, some issues arose which are discussed in this section. Links. All the algorithms described before use the Authenticated perfect link abstraction. Up to this point, DistAlgo does not offer a way to exchange messages using a link that satisfies authenticity , for example TCP with TLS, as only UDP and TCP are offered. Alternatively, the authentication could be realized in the process definitions. Since this would make the algorithms more difficult to understand, this thesis did not pursue this idea any further. But even without complete correctness, the implementations allow us to examine the message flows and to understand the behavior of the algorithms more easily. Layered architecture. DistAlgo does not support a layered architecture as in the composition model. This is mainly a problem in the implementation of the Byzantine consistent channel algorithm. The pseudocode of the algorithm could not be implemented directly in DistAlgo. In practice, many imple-mentations of similar algorithms collapse the notion of the instances and distinguish the instances simply by the label . Nevertheless, the implementation is less structured and more difficult to understand. Event handlers. Minor differences between the abstract model and DistAlgo have also some con-sequences. In DistAlgo, only event handlers in the context of messages exist. Events triggered if a condition is fulfilled do not exist. There are different approaches, two of them have been already used in the implementations
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
above. On the one hand, helper methods may be used that check the condition and are always called, if a variable on which the condition depends changes. Another possibility, as in the implementation of the Authenticated double-echo broadcast , is to use an await statement. Broadcast event. Since DistAlgo processes may only communicate using messages after setup, start-ing a broadcast is not trivial. In the implementations of the three Byzantine consistent broadcast algo-rithms, the message is passed directly as an argument during setup. Thus, sending a broadcast message using a normal message is avoided. However, it is important to note that the broadcast process may also include a helper method, which creates or fetches a message to be broadcast. Such an implementation has been avoided, as this conflicts with the goal of keeping the implementation as close as possible to the pseudocode. In the Byzantine consistent channel implementation, the approach using the setup method 25 is no longer possible since the sender is not pre-defined and there may be multiple messages to be broad-cast. To keep things simple, the rather unattractive way that a BROADCAST message is sent to a process was chosen. As long as the process is correct and is not already busy, the process then broadcasts the received message. Sender process. Some algorithms contain events that are only triggered on the sender process, such as the broadcast event in Byzantine consistent broadcast algorithms. In DistAlgo different types of processes may be defined, for example a class may be defined for the sender process and another for all other processes. As a result, the normal processes would be without methods that only the sender process will use. This approach was not chosen for two reasons. Firstly, because the differences to the pseudocode would be increased, and secondly, the
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
class of the sender process would contain a lot of duplicated code, since the sender process would only be an extension of a normal process. ## 5.2 Future work It will be interesting to improve the implementations. On the one hand, we could provide authenticity and thus make the correctness of the algorithms complete. On the other hand, some parts of the code became difficult to understand as a result of the adaptation to DistAlgo. Here we could make the implementation less bound to the pseudocode and therefore better adapt it to DistAlgo. As an example, consider the Byzantine consistent channel implementation, where we could simplify the structure if we completely abandon the concept of instances also in the method names and data structures. Another possibility is to extend the features of DistAlgo itself. Probably it makes more sense to implement a message exchange that satisfies the Authenticated perfect link abstraction directly in DistAlgo. This way, programming with DistAlgo remains as abstract as it is today. A major modification would be to allow a layered architecture and a composition model that allows multiple, even dynamically created instances running on a process. This would bring more flexibility and it would be easier to implement the described algorithms. 26 AExtra material ## A.1 Running DistAlgo programs The algorithms were developed and tested on Ubuntu 16.04 LTS. 1. Python: Install Python 3.5, 3.6 or 3.7 2. DistAlgo: Install DistAlgo with pip: pip3 install pyDistAlgo 3. Repository: Clone the repository: 4. Run: Navigate to a folder and follow the instructions in the corresponding readme.md file More information can be found in the repository of the DistAlgo project . 27 A.2 DistAlgo example program This is the complete DistAlgo program, which is described in parts in Chapter 2. import sys import da class Bob
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
(process): def setup(alice:da.common.ProcessId): self.greeted = False def run(): send(('Hi Alice',), to=alice) if await (self.greeted == True ): send(('Bye',), to=alice) def receive(msg=('Hi Bob',), from_=p): output("Hi Bob received from", p) self.greeted = True ; class Alice (process): def setup(n_bobs:int): pass def run(): await (len(setof(p, received(('Bye',), from_= p))) == n_bobs) output('Bye from all Bobs received') def receive(msg=('Hi Alice',), from_=p): send(('Hi Bob',), to=p) def main(): n_bobs = 3 alice = new(Alice, num= 1) bobs = new(Bob, num= n_bobs) setup(alice, (n_bobs,)) setup(bobs, (alice,)) start(alice) start(bobs) 28 A.3 Authenticated Echo Broadcast This is the complete DistAlgo program of the Authenticated echo broadcast implementation described in Chapter 4. class AuthEchoBroadcast (process): def setup(procs:set, n:int, f:int, sender:da.common.ProcessId, msg:str = ''): self.sentecho = False self.delivered = False self.echos = dict((p, False ) for p in procs) self.is_sender = True if sender == self else False self.quorumbound = (self.n + self.f) / 2 if self.is_sender: broadcast() def broadcast(): send(('SEND', self.msg), to = procs) def receive(msg=('SEND', m), from_= self.sender): if not (self.sentecho): self.sentecho = True send(('ECHO', m), to= self.procs) def receive(msg=('ECHO', m), from_= p): if self.echos[p] == False :self.echos[p] = mcheck_echos_received() def check_echos_received(): if not (self.delivered) and some(m in self.echos.values(), has=( len(setof(p, p in procs, self.echos[p] == m)) > self.quorumbound and m != False ) ): deliver(m) def deliver(m: str): self.delivered = True output(m) def run(): await (False ) def main(): config(channel={'reliable','fifo'}) nprocesses = 10 f = 2message = 'This is a test message.' procs = new(AuthEchoBroadcast, num= nprocesses) procs_without_sender = procs.copy() sender = procs_without_sender.pop() setup(procs_without_sender, (procs, nprocesses, f, sender)) setup(sender, (procs, nprocesses, f, sender, message)) start(procs) 29 Bibliography C. Cachin, R. Guerraoui, and L. Rodrigues, Introduction to Reliable and Secure Distributed Pro-gramming (Second Edition) . Springer, 2011. Y. Liu, S. Chand, and S. Stoller, “Moderately complex paxos made simple: High-level executable specification of distributed algorithms,” PPDP ’19: Proceedings
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
of the 21st International Sympo-sium on Principles and Practice of Programming Languages 2019 , Mar. 2019, arXiv:1704.00082v4. Y. Liu, B. Lin, and S. Stoller, DistAlgo Language Description , liu/distalgo/language.pdf, Mar. 2017. DistAlgo Readme.md on GitHub , Mar. 2020. RFC 793 - Transmission Control Protocol , Sep. 1981. Y. Liu, S. Stoller, and B. Lin, “From clarity to efficiency for distributed algorithms,” ACM Trans-actions on Programming Languages and Systems (TOPLAS) , vol. 39, no. 12, pp. 7–10, Jul. 2017, arXiv:1412.8461v4. 30 Erkl¨ arung Erkl¨ arung gem¨ ass Art. 30 RSL Phil.-nat. 18 Ich erkl¨ are hiermit, dass ich diese Arbeit selbstst¨ andig verfasst und keine anderen als die angegebenen Quellen benutzt habe. Alle Stellen, die w¨ ortlich oder sinngem¨ ass aus Quellen entnommen wurden, habe ich als solche gekennzeichnet. Mir ist bekannt, dass andernfalls der Senat gem¨ ass Artikel 36 Absatz 1 Buchstabe r des Gesetzes vom 5. September 1996 ¨ uber die Universit¨ at zum Entzug des auf Grund dieser Arbeit verliehenen Titels berechtigt ist. F¨ ur die Zwecke der Begutachtung und der ¨ Uberpr¨ ufung der Einhaltung der Selbst¨ andigkeitserkl¨ arung bzw. der Reglemente betreffend Plagiate erteile ich der Universit¨ at Bern das Recht, die dazu erforder-lichen Personendaten zu bearbeiten und Nutzungshandlungen vorzunehmen, insbesondere die schriftliche Arbeit zu vervielf¨ altigen und dauerhaft in einer Datenbank zu speichern sowie diese zur ¨ Uberpr¨ ufung von Arbeiten Dritter zu verwenden oder hierzu zur Verf¨ ugung zu stellen. 31
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
Title: Reliable Broadcast despite Mobile Byzantine Faults URL Source: Markdown Content: # HAL Id: hal-04277831 Preprint submitted on 9 Nov 2023 HAL is a multi-disciplinary open access archive for the deposit and dissemination of sci-entific research documents, whether they are pub-lished or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers. L’archive ouverte pluridisciplinaire HAL , est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d’enseignement et de recherche français ou étrangers, des laboratoires publics ou privés. Distributed under a Creative Commons Attribution 4.0 International License # Reliable Broadcast despite Mobile Byzantine Faults # Silvia Bonomi, Giovanni Farina, Sébastien Tixeuil # To cite this version: Silvia Bonomi, Giovanni Farina, Sébastien Tixeuil. Reliable Broadcast despite Mobile Byzantine Faults. 2023. hal-04277831 Reliable Broadcast despite Mobile Byzantine Faults ∗ ## Silvia Bonomi 1, Giovanni Farina 1, and S´ ebastien Tixeuil 21Sapienza University of Rome, Rome, Italy > 2 ## Sorbonne Universit´ e, CNRS, LIP6, Institut Universitaire de France, Paris, France Abstract We investigate the solvability of the Byzantine Reliable Broadcast and Byzantine Broadcast Channel problems in distributed systems affected by Mobile Byzantine Faults. We show that both problems are not solvable even in one of the most constrained system models for mobile Byzantine faults defined so far. By endowing processes with an additional local failure oracle, we provide a solution to the Byzantine Broadcast Channel problem. # 1 Introduction Byzantine Reliable Broadcast (BRB) is a fundamental primitive in fault-tolerant distributed systems ensuring that all correct processes eventually deliver the same message from a defined sender regardless of its correctness. Defined by Bracha as a building block for a Byzantine-tolerant consensus protocol, BRB has been widely adopted and
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
investigated since then, thanks to its abil-ity to prevent arbitrarily (i.e., Byzantine) faulty processes from equivocating by sending different messages to different processes. It has been introduced as a one-shot primitive that allows a pre-defined process in the system to spread a single message and generalized as a Byzantine Broadcast Channel (BBC) primi-tive to allow every process to spread an arbitrary number of messages. BRB has been used to construct several fault-tolerant distributed solutions, solving more complex problems such as register abstractions, consensus problems, and distributed ledgers. Thus, it has been analyzed in the literature from various perspectives, such as minimizing bandwidth consumption , or latency [20, 1]. A fundamental perspective to consider is the investigation of the feasibility of BRB and BBC when assuming no permanent failures. In this paper, we > ∗Part of the content of this paper has been published in 1are interested in analyzing BRB and BBC solvability considering a dynamic process failure model , i.e., a model in which every process may potentially fail and recover, causing a potentially continuous change in a process’s failure state throughout the system’s lifetime. Some examples of systems considering dy-namic process failures are crash-recovery systems [28, 5], self-stabilizing systems [15, 16], and Mobile Byzantine tolerant systems [17, 6]. In this work, we con-sider the Mobile Byzantine Failure (MBF) model, in which all processes may alternate between periods of correct behavior and periods of arbitrary behav-ior (i.e., Byzantine). Indeed, the failure state of processes is governed by an external attacker capable of compromising and controlling a set of processes in the system, and such a set is dynamic. The MBF model captures some of the features of the most frequent attacks targeting distributed systems and re-lated countermeasures, where the process’s faults are primarily due to external malicious causes
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
rather than internal misbehavior, and tools such as software rejuvenation techniques , intrusion detection systems , and trusted exe-cution environments are available. Despite several fundamental distributed problems have been analyzed in the literature considering the MBF model (i.e., Byzantine agreement [17, 6], approximate Byzantine agreement [32, 9], and registers emulation ), to the best of our knowledge the BRB problem has never been studied so far in such settings. Thus, our objective in this paper is the investigation of BRB and BBC in the presence of MBFs. In particular, our contributions are: 1. we formalize the Mobile Byzantine Reliable Broadcast (MBRB) and Mo-bile Byzantine Broadcast Channel (MBBC) as a natural extension of the BRB and BBC specifications to deal with MBFs. Indeed, the standard specifications for BRB and BBC primitives consider a static failure model ,where every process is either permanently correct or faulty; 2. we prove several impossibility results, mainly showing that MBRB and MBBC cannot be implemented without additional knowledge provided by a powerful oracle reporting about processes’ failure state; 3. we introduce such a powerful oracle and provide a protocol for solving MBBC in a synchronous round-based system; 4. we analyze a weaker MBBC specification that can be realized without the oracle. Let us note that being a natural extension of BRB and BBC primitives, the MBRB and MBBC primitives prevent faulty processes from equivocat-ing, namely from sending different information to different processes, and can be used as building block for other fault-tolerant primitives. For example, MBRB/MBBC primitives can extend mobile Byzantine fault-tolerant register abstractions to support Byzantine clients . Our work not only offers an anal-ysis of a specific problem but also provides several insights for other distributed system problems where the failure state of a process is dynamic and partially 2or entirely unknown. We
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
consider relatively strong assumptions in our system model, the same as those considered in related work, in order determine fun-damental solvability conditions. Relaxation of most of these assumptions has already been partially investigated . The rest of the paper is structured as follows. After reviewing related work on implementations of the BRB primitive and contributions considering mobile Byzantine failures in Section 2, we formalize the system model in Section 3. We introduce the new specifications for the Mobile Byzantine Reliable Broadcast and the Mobile Byzantine Broadcast Channel problems in Section 4. Section 5 presents some impossibilities for the specifications we defined. To overcome some of the identified impossibilities and solve the Mobile Byzantine Broad-cast Channel problem, we consider a powerful oracle, we propose a protocol in Section 6, and we analyze a weaker Mobile Byzantine Broadcast Channel specification that is realizable without any oracle in Section 7. # 2 Related Work The Byzantine Reliable Broadcast (BRB) abstraction has been introduced by Bracha as a building block for a Byzantine-tolerant consensus protocol in a distributed system where at most f processes are permanently arbitrary (Byzantine) faulty. Thanks to its ability to guarantee agreement among correct processes over the set of delivered messages, a BRB primitive has been used as a building block from several fault-tolerant solutions, and has been intensely investigated under several system and failure models, with the final aim of ex-tending its power and optimizing different performance metrics. Imbs and Raynal proposed a protocol that improves latency (in terms of the number of rounds of message exchanges) compared to Bracha. Guerraoui et al. relaxed the BRB specification, allowing each property to be violated with a fixed and arbitrarily small probability. Backes and Cachin and Raynal discussed extensions of the BRB problem; the former assuming
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
both Byzantine faulty processes and fail-stop failures, the latter distinguishing between two dif-ferent kinds of Byzantine behaviors, i.e. those attempting to prevent the liveness and those attempting to prevent the safety of the BRB. Recently, Guerraoui et al. and Li et al. extended BRB to distributed systems with dynamic membership: in any given view (i.e. set of participating processes, governed by the processes themselves), the set of Byzantine processes remains the same; however, two consecutive views allow for different sets of Byzantine processes. By contrast, our work considers a static system membership (i.e., a fixed set of processes participating in the protocol) but a dynamic failure model, where Byzantine processes may change (that is, recover, and get Byzantine again) dur-ing the same view. To the best of our knowledge, all existing BRB protocols that assumed arbitrary process failures, except the aforementioned works by Guerraoui et al. and Li et al. , considered a static failure model i.e., they assumed that the set of Byzantine processes does not change. Mobile Byzantine Failure (MBF) models have been introduced to capture 3various types of faults, such as external attacks, virus infections, or even ar-bitrary behaviors caused by software bugs, using a single model encompassing detection and rejuvenation capabilities. In all these models, failures are ab-stracted by an omniscient adversary that can control up to f mobile Byzantine agents. Every agent is located in a process and makes it Byzantine faulty un-til the omniscient adversary decides to move it to another process. The main differences between existing MBF models are in the power of the omniscient adversary (i.e., when it can move the agents) and in the awareness that every process has about its failure state. Most MBF models considered round-based computations and can be classified according to Byzantine mobility constraints:
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
under constrained mobility the adversary can move agents only when pro-tocol messages are sent (similarly to how viruses would propagate), while under unconstrained mobility [4, 6, 17, 24, 31, 27] agents do not move with messages but rather during specific phases of the round. More in detail, Reischuk con-sidered malicious agents stationary for a given period; Ostrovsky and Yung introduced the notion of mobile viruses and defined the adversary as an entity that can inject and distribute faults; finally, Garay , Banu et al. , Sasaki et al. , and Bonnet et al. considered that processes execute synchronous rounds and mobile agents can move from one process to another in a specific phase of the round, which subsequently affects each process’s ability to adhere to the algorithm. As a result, the set of Byzantine faulty processes at any given moment is limited in size; however, its composition may change from one round to the next, and the impact of past compromises may linger if not properly ad-dressed by the protocol. The aforementioned works [17, 4, 31, 6] also differ due to the assumption about the knowledge that processes have about their previous infection. In the Garay model , a process can detect its infection after the agent leaves it. Conversely, Sasaki et al. investigated a model where pro-cesses cannot detect when agents leave. Finally, Bonnet et al. considered an intermediate setting where not faulty processes control the messages they send (in particular, they send the same message to all destinations, and they do not send spurious information). Bonomi et al. [10, 11] decoupled algorithm rounds from Mobile Byzantine agent movement ( round-free model ). The problems an-alyzed under MBF models are Byzantine agreement [17, 4, 31, 6], approximate Byzantine agreement [32, 30, 9], and
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
Byzantine-tolerant registers [10, 8, 11]. To the best of our knowledge, no efforts have been made to investigate the BRB problem in the presence of MBFs. All existing works that assume MBFs rely on some kind of best-effort communication subsystem (i.e., no guarantees exist when a process is controlled by a Mobile Byzantine agent), potential equivoca-tions and omissions introduced by faulty processes are directly addressed by the main investigated primitive (e.g., consensus, register). The existence of a BRB primitive can simplify the definition of other mobile Byzantine fault-tolerant primitives, similar to the case of the static failure model . 43 System Model We consider a distributed system composed of a set of n processes Π = {p1, p 2 . . . p n}, each associated with a unique identifier. Processes communicate through message passing. We assume that a process can communicate with any other process through a reliable , authenticated , point-to-point link abstraction . This means that messages sent over such channels cannot be altered, dropped, or duplicated, and the identity of the sender cannot be forged. A reliable authenticated point-to-point link abstraction exposes two operations: (i) P2P .send (prcv , m ) which sends the message m to the receiver process prcv , and (ii) P2P .deliver (psnd , m ) which notifies the reception of the message m from a sender process psnd .We measure the time according to a fictional global clock T (not accessible to processes) spanning over the set of natural numbers N. We refer to the starting time of the system as t0, the i-th time instant since the beginning of the execution as ti, and a period of time between time tb and te as Tb,e := [tb, t e) : tb, t e ∈ T; tb < t e.Each process
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
executes a distributed protocol P consisting of a set of local al-gorithms. Each algorithm in P is represented by a finite state automaton whose transitions correspond to computation and communication steps. A computa-tion step denotes a computation executed locally by a given process, while a communication step denotes the sending or receiving of a message. Computa-tion steps and communication steps are generally called events . Each process maintains a set of variables. This set and the current value of those variables denote the state of a process. Definition 1 (Local Execution History) . A local execution history is an alter-nating sequence s0, e 0, s 1, e 1, . . . of states and events of a process pi, such that state sj+1 results from state sj by executing event ej . We assume that the local algorithms composing P are stored in a tamper-proof read-only memory. Processes may fail and we assume that they are affected by Mobile Byzantine Failures (MBF). That is, we assume the existence of an omniscient adversary that controls up to f > 0 mobile Byzantine agents and that can “move” such agents from one set of processes to another. When the adversary places a Byzantine agent on a process pi, the agent takes control of pi, letting it behave arbitrarily. For example, pi may omit to send/receive messages, alter the con-tent of messages, alter its process state regardless of its local algorithm, and execute arbitrary code. However, we assume that the mobile Byzantine agents cannot compromise the code stored in the tamper-proof memory. Thus, when the Byzantine agent leaves pi, pi resumes executing its local algorithm correctly (albeit from a possibly corrupted state). We assume that the adversary can move each mobile agent independently of the others. Still, any agent must remain on a
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
process for a period of time lasting at least ∆ s ∈ Q+ (rational positive numbers), i.e., once arrived, an agent compromises a node for at least ∆s consecutive time units, and when ∆ s i B(ti) for b ≤ i < e ). Definition 3 (Correct process) . A process pi is correct when it is
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
not faulty, that is, pi is correct at time tk if it is not controlled by a Byzantine agent at time tk. Similarly, a process pi is correct in the period Tb,e if it remains correct between times tb and te. Let us remark that when a process pi is correct, it executes P but potentially it may start its execution from a compromised state (due to a previous corruption performed by a mobile Byzantine agent). We denote by C(tk) the set of correct processes at time tk and by C(Tb,e ) the set of correct processes throughout the period Tb,e (that is, C(Tb,e ) = ⋂ > i C(ti) for b ≤ i t j , t e − tb ≥ ∆c, p i ∈ C(Tb,e ). Informally, the notion of ∆ c-infinitely often correct process captures the possi-bility that a process is not permanently faulty, but correct for at least ∆ c units of time after mobile Byzantine agents have left it. In the following, we will consider several alternative settings for our system model: 6• system timing assumptions : we consider either a synchronous (SYNC )or an asynchronous (ASYNC ) system. When considering a synchronous system, we assume that there is an upper bound on the time required to
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
perform local computation on the processes and an upper bound on the time required by a message to be delivered via a P2P link, both of them known by all processes. In addition, we assume that the computation evolves in sequential synchronous rounds r1, r 2, . . . , r j , . . . . Every round rj is divided into three phases: (i) send where processes transmit messages to their intended receivers, (ii) receive where processes collect messages sent during the send phase of the current round, and (iii) compute where processes process received messages, and prepare those that need to be sent in the following round. Contrarily, in an asynchronous setting, we are not assuming any upper bound, and the computation progresses as soon as an event is generated by a process. • mobile Byzantine agent synchronization : we consider three differ-ent types of mobility with different degrees of synchronization between mobile Byzantine agents. In particular, we will consider movement that are either synchronized (S-MOB +), synchronous (S-MOB ), or asynchronous (A-MOB ) that abstract MBF models existing in the literature. In the A-MOB model, mobile Byzantine agents move independently and once the move-ment occurs, the agent remains at the destination node for at least ∆ s,with ∆ s unknown to the processes (see ITU model in ). In the S-MOB model, mobile Byzantine agents move independently, and, also in this case, once the movement happens the agent remains on the destination node for at least ∆ s. Unlike the previous case, ∆ s is known to the processes (see the ITB model in ). The S-MOB + model is a particular case of the S-MOB model specific for synchronous systems where the computation evolves in synchronous rounds. Indeed, in this case ∆ s is expressed
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
in terms of round, and mobile Byzantine agents can move only between two consecutive rounds, i.e. after the computation phase of a round ri and before the send phase of round ri+1 1(see Garay’s MBF model ). Let us stress that in the S-MOB + setting every process is either faulty or cor-rect for an entire round. Therefore, for ease of presentation, we say that a process is faulty or correct in the round rk in the S-MOB + systems and extend the notation of C(t) and B(t) accordingly, that is, with C(rk) and B(rk), respectively, referring to the sets of correct and faulty processes in the round rk. Furthermore, we measure the time with the number of rounds. • failure awareness : we assume that every process pi is either aware or un-aware about a mobile Byzantine agent moving away from pi. We abstract this knowledge by introducing two different local oracles that reveal in-formation to process pi. Specifically, we consider: basic failure awareness (OBFA ) and full failure awareness (OFFA ). In the OBFA case, a process pi > 1The agents’ movements are thus synchronized with the synchronous rounds. 7knows when (i.e., in which time unit) a mobile agent moves away from pi;in the OFFA case, a processes pi additionally know when the agent arrived to pi (i.e., pi know the entire period Tb,e in which it was faulty). More formally: Definition 5 (Basic Failure Awareness Oracle OBFA ). If a mobile Byzantine agent leaves from a process pi at time tj , then the failure awareness oracle OBFA generates a cured () event on pi at time tj+1 . Observe that OBFA informs pi as soon as pi becomes free from mobile Byzantine agents, and thus allows pi to take corrective actions ( e.g. to avoid spreading
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
compromised information). However, OBFA does not provide any information about the length of the period pi was faulty. Definition 6 (Full Failure Awareness Oracle OFFA ). If a mobile Byzantine agent takes control of a process pi at time tj and leaves pi at time tk, then the full failure awareness oracle OFFA generates a cured () event on pi at time tk+1 , and returns the time label tj when invoking operation faulty at () . For the sake of notation, we refer to setting where no oracle is available as ONFA .Let us remark that both OBFA and OFFA are local oracles, i.e., they provide information to the actual process where the events occurred; thus, a process pi is not aware of the failure state of any other process pj .Note that the assumptions considered in our system model are equivalent to or less constrained than those in other works dealing with mobile Byzantine agents [17, 4, 31, 6]. The only exceptions are the OFFA oracle and the notion of ∆ c-infinitely often correct process, which have not been considered before. In the remainder of the paper, we will characterize the specific setting con-sidered in terms of system timing assumptions, agent synchronization, and failure awareness by specifying a triple 〈α, β, γ 〉 where α ∈ {SYNC , ASYNC }, β ∈ { A-MOB , S-MOB , S-MOB +} and γ ∈ {O BFA , OFFA , ONFA }. With slight abuse of notation, we will use ” ∗ ” in a triple when the specific dimension is not relevant to prove our claims. # 4 Mobile BRB and BBC Specification Informally Byzantine Reliable Broadcast (BRB) [12, 14] is a communication primitive that enables all processes of a distributed system to agree on the delivery of a single
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
message disseminated by a pre-defined process called the source , while the Byzantine Broadcast Channel (BBC) primitive extends BRB allowing all processes to disseminate an arbitrary number of messages so that all correct processes eventually deliver the same set of messages 2.Let us note that in the original BRB and BBC specifications the source is either always correct or always faulty in a given execution. Conversely, in our > 2The formal specification of BRB and BBC primitives are provided in the Appendix A. 8settings, it is possible that the source of a message changes its failure state multiple times (even during a single broadcast instance) making the original specification no more suitable. Thus, we extend the BRB and BBC, by formal-izing the Mobile Byzantine Reliable Broadcast (MBRB) and the Mobile Byzan-tine Broadcast Channel (MBBC) problems to capture challenges imposed by mobile Byzantine faults. We aim to specify two communication primitives ac-cessible by every process and exposing the MBRB/MBBC.Broadcast( m) and MBRB/MBBC.Deliver( s,m) operations, where m is a message and s is a process identifier. We say that a process pi “MBRB/MBBC-broadcasts a message m” when it executes MBRB/MBBC.Broadcast( m),and pi “MBRB/MBBC-delivers a message m from ps” when pi generates the MBRB/MBBC.Deliver( s, m ) event. Similarly to other communication prim-itives, the MBRB/MBBC-broadcast operation is triggered to disseminate a message, while MBRB/MBBC-deliver notifies message deliveries. We asso-ciate two additional parameters to both primitives, ∆ b ∈ N+ and ∆ c ∈ N+,characterizing the length of two periods (detailed in the specifications’ proper-ties). We use the character “*” in our specifications when the actual value of the reference parameter is irrelevant. Informally, a MBRB (∆ b, ∆c) communication primitive guarantees that, given a source process ps and a message m generated by ps while it is correct (for at least ∆b
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
time units), m is reliably delivered by any ∆ c-infinitely often correct process pj in a period where pj is correct. Similarly to BRB, this primitive is specified by considering an instance for every message generated by the identified source. More formally, a MBRB (∆ b, ∆c) communication primitive must guarantee the following properties: • (∆ b, ∆c)-Validity : If there exists a period Ti,j lasting at least ∆ b where a process ps is correct in Ti,j and executes MBRB.Broadcast (m), then at least one ∆ c-infinitely often correct process pd eventually executes MBRB.Deliver (s,m) while correct. • No duplication : Every process pd executes MBRB.Deliver (s,∗) at most once when correct, namely pd MBRB-delivers at most one message from ps among all times tk ∈ T such that pd ∈ C(Tk,k +1 ). • ∆b-Integrity : If a process pd is correct at time tk and executes MBRB.Deliver (s,m), then either ps was correct in Ti,j = [ ti, t i+∆ b ), with ti ≤ tk, and executed MBRB.Broadcast (m) at time ti, or ps was faulty at some ti ≤ tk. • Consistency : If some process is correct at time tk and executes MBRB.Deliver (s, m ), and another process is correct at time tl and ex-ecutes MBRB.Deliver (s, m ′), then m = m′. • ∆c-Totality : If some process is correct at time tk and executes MBRB.Deliver (s, ∗), then every ∆ c-infinitely often correct process even-tually executes MBRB.Deliver (s, ∗). 9The MBBC communication primitive is the natural extension of the BBC and its specification extends the one of the MBRB. In particular, the MBBC primitive guarantees that multiple messages generated by a source process (while it is correct for at least ∆ b consecutive time units) will be eventually delivered by any
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
process pj that is ∆ c-infinitely often correct in a period in which pj is correct. More formally, a MBBC (∆ b,∆ c) communication primitive must guarantee the following properties: • (∆ b, ∆c)-Validity : If there exists a period Ti,j lasting at least ∆ b where a process ps is correct in Ti,j and executes MBRB.Broadcast (m), then at least one ∆ c-infinitely often correct process pd eventually executes MBRB.Deliver (s,m) while correct. • No duplication : Every process pd executes MBBC.Deliver (s,m), with message m and source s, at most once when correct, namely, it MBBC-delivers a message m from ps at most once among all times tk such that pd ∈ C(Tk,k +1 ). • ∆b-Integrity : If a process pd is correct at time tk and executes MBRB.Deliver (s,m), then either ps was correct in Ti,j = [ ti, t i+∆ b ), with ti ≤ tk, and executed MBRB.Broadcast (m) at time ti, or ps was faulty at some ti ≤ tk. • ∆c-Agreement : If some process is correct at time tk and executes MBRB.Deliver (s, m ), then every ∆ c-infinitely often correct process eventually executes MBRB.Deliver (s, m ). Note that the specifications rule the MBRB/MBBC.Deliver (s, m ) opera-tions in times when processes are correct. Operations executed when a process is faulty cannot be controlled and thus are not relevant to the specification. Fur-thermore, note that when a process is controlled by a mobile Byzantine agent, it may execute arbitrary code and alter its local memory. Such a process has no information about what occurred when compromised (except the fact of being previously compromised in case an oracle is available). This makes the imple-mentation of the presented communication primitives particularly challenging and will lead to proving several impossibility results that are
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
specific to mobile Byzantine faults in the following sections. # 5 Impossibility Results This section presents several impossibility results for the MBRB and MBBC problems. In particular, Theorems 7 and 9 prove the impossibility of solv-ing both MBRB and MBBC if the system is asynchronous, or if the agents’ 10 movements are asynchronous. Then, assuming a synchronous system and syn-chronized agents, Theorems 10 and 12 state the impossibility of solving MBRB with the strongest failure oracle we considered, OFFA , and the impossibility of solving MBBC with the weaker failure oracle, OBFA . These latter impossibilities arise from the fact that a correct process cannot infer other processes’ failure state from their behavior. Thus, they cannot distinguish messages that must be delivered from those that can be safely dropped. Table 1 provides an overview of the impossibilities proved in this Section based on the specific considered settings. Theorem 7. There exists no protocol P implementing the Mobile Byzan-tine Reliable Broadcast (resp. Mobile Byzantine Broadcast Channel) in 〈ASYNC , S-MOB , OFFA 〉.Proof. In order to prove our claim we first show that it is impossible for any protocol P solving MBRB to generate an execution satisfying both (∆ b, ∆c)-Validity and ∆ c-Totality . Then we extend our arguments to prove the claim also for MBBC, where it is impossible to satisfy both (∆ b, ∆c)-Validity and ∆c-Agreement .Let us consider a process ps that is correct at a certain time tbcast , that triggers MBRB.broadcast( m) at time tbcast , and that remains correct for a period ∆ src ≥ ∆b after tbcast . If P exists, it needs to guarantee (∆ b, ∆c)-Validity for the message m. As a consequence, if there exists a ∆ c-infinitely often correct process pdest , P must guarantee that eventually a MBRB.deliver(
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
s, m ) event is generated from pdest . To guarantee both (∆ b, ∆c)-Validity and ∆ c-Totality pdest must be different from ps. It is therefore necessary that in P psrc sends the message m through the reliable authenticated links at least once to allow a ∆c-infinitely often correct process pdest to become aware of the message. Let us remark that under the ASYNC timing assumptions, there not exists any upper bound on the time required to exchange a message over a P2P link. In particular, given a message m sent by a process pi to a process pj at a certain time t using a reliable authenticated perfect point-to-point link, we can only guarantee that m will be delivered to pj at some time t′ > t but it is not possible to estimate its latency d = t′ − t (i.e., the time needed to deliver m). As a consequence, it is easily to identify a scenario where a single mobile Byzantine agent moves n times in Tt,t ′ and corrupts in sequence every processes pi in the system right after the message is P2P-delivered on pi, discarding the message when received (mimic the loss of the message) and thus preventing a process pdest 6 = ps from delivering m.The reasoning can be extended considering many processes pi and for a MBBC instance with respect the properties (∆ b, ∆c)-Validity and ∆c-Agreement , and the claim follows. Let us note that Theorem 7 holds assuming the most constrained agent’s mobility model available in an asynchronous system (i.e., S-MOB ) and the most powerful failure oracle ( OFFA ) considered. It follows that the MBRB and MBBC 11 problems cannot be solved in ASYNC assuming a less constrained environment, as stated in the following Corollary. Corollary 8. There
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
exists no protocol P implementing the Mobile Byzan-tine Reliable Broadcast (resp. Mobile Byzantine Broadcast Channel) in 〈ASYNC , M, O 〉, with M ∈ { A-MOB , S-MOB } and O ∈ {O FFA , OBFA }.Proof. The claim follows from the same argument provided as in Theorem 7, given that the 〈ASYNC , S-MOB , OFFA 〉 setting is the strongest possible for the parameters M and O. Theorem 9. There exists no protocol P implementing the Mobile Byzan-tine Reliable Broadcast (resp. Mobile Byzantine Broadcast Channel) in 〈SYNC , A-MOB , OFFA 〉.Proof. The proof follow from Theorem 7 by observing that the same misbehav-ior occurs both in the 〈SYNC , A-MOB , OFFA 〉 and 〈ASYNC , S-MOB , OFFA 〉 settings. Indeed, if the latency of the communication δ is bounded due to the SYNC model, it is always possible to find a value for ∆ s s of a process ps that is correct for ∆ b ≥ 2 rounds and executes MBRB.Broadcast( m′) in round r1.Subsequently, ps remains correct for the successive ∆ 1 rounds, it gets perma-nently faulty from round r∆b+∆ 1+1 (namely ∀rj ∈ [r∆b+∆ 1+1 , ∞), p s ∈ B(rj )), and it executes MBRB.Broadcast( m′′
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
) in round r∆b+∆ 1+1 . We remark that the failure state of any process may change unexpectedly due to the move-ment of a Byzantine agent. Let us consider another local execution history H′′ > s of process ps where the failure state of ps evolves in the opposite way from H′ > s , that is process ps is faulty in rounds rj ∈ [r1, r ∆b+∆ 1 ] and executes MBRB.Broadcast( m′) in round r1; subsequently, ps is permanently correct from round r∆b+∆ 1+1 (namely ∀rj ∈ [r∆b+∆ 1+1 , ∞), p s ∈ C(rj )) and executes MBRB.Broadcast( m′′ ) in round r∆b+∆ 1+1 . Notice that in both histories ps executes the MBRB.Broadcast operation only once while correct. We provide a graphical representation of the two histories in Figure 1a. Let us con-sider a process p1 6 = ps that is correct for the entire lifetime of the system (i.e. ∀rj , p 1 ∈ C(rj )), thus p1 is also an ∆ c-infinitely often correct process for any value of ∆ c ∈ N. The two execution histories H′ > s and H′′ > s are indistinguishable to p1 because the same operations and events occurred on ps. Process p1 is not aware of the failure state of ps (i.e. it has no access to the failure oracle on ps). Even defining an algorithm A that allows process ps to share the information 12 ……… > ΔbΔ1 > H’ s > m’ m’’ > ……… > ΔbΔ1 > m’ m’’ > H’’ s > XXXXX > XXXXXX > r1 > r1 (a) Graphical representations for Theorem 10 … > Δ1Δ2 > H’ 1 > m > Ø… > … > Δ1Δ2 > H’’ 1 > Ø… > CURED() > CURED() > XXXXX > rΔ1 >
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
rΔ1 > XXXXXXX (b) Graphical representations for Theorem 12. Figure 1: Graphical representations for Theorems’ proof. obtained from OFFA with process p1 through the point-to-point primitive, pro-cess p1 cannot distinguish an execution of A where ps is correct and reveals a previous faulty state, from another where ps is faulty, and maliciously reports the same information. According to the Validity property of the MBRB specification, process p1 executing P must MBRB-deliver a message from ps considering both histories because process ps MBRB-broadcasts a message when correct. If P makes process p1 eventually MBRB-deliver message m′, then the Validity property is violated in H′′ > s , because process p1 never MBRB-delivers m′′ (according to the No-duplication property) that is broadcast when ps is correct. If P makes process p1 eventually MBRB-deliver message m′′ , then the Validity property is violated in H′ > s for the same reason. This is a contradiction and the claim follows regardless of the value of ∆ b and ∆ c.Theorem 10 states the impossibility in solving MBRB assuming the most con-strained assumptions we considered. Corollary 11 extends the result to less constrained settings. Corollary 11. If ∆b ∈ N+ and ∆b ≥ 2 rounds, then there exists no proto-col P implementing a Mobile Byzantine Reliable Broadcast primitive in 〈SYNC , S-MOB +, OBFA 〉 or in 〈SYNC , S-MOB , ∗〉 .Proof. The claim follows from the same argument provided in Theorem 10 give that the considered settings assume either a less constrained agent mobility model ( S-MOB ) or a failure oracle providing less knowledge ( OBFA ). Theorem 12. If ∆b ∈ N+ and ∆b ≥ 2 rounds, then there exists no protocol P implementing a Mobile Byzantine Reliable Channel primitive in 〈SYNC , S-MOB +, OBF A 〉.Proof. For the sake
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
of contradiction, let us assume that such a protocol P ex-ists. Let us assume a permanently correct process ps (i.e. ∀rj , p s ∈ C(rj )) that 13 ASYNC SYNC S-MOB + > OBFA OFFA > 77 > (Cor. 11) (Th. 10) S-MOB 7OBFA OFFA > 77 > (Cor. 8) (Cor. 11) (Cor. 11) A-MOB 77 > (Cor. 8) (Th. 9) > (a) MBRB > ASYNC SYNC S-MOB + > OBFA OFFA > 7(* Sec 7 )3 > (Th. 12) (Th. 16 )S-MOB 7OBFA OFFA > (Cor. 8) 7? > A-MOB 77 > (Cor. 8) (Th. 9) > (b) MBBC Table 1: Summary of the solvability results. executes MBBC.Broadcast( m) in rounds r1. Let us consider the local execu-tion history H′ > 1 of a process p1 that is correct in rounds rj ∈ [r1, r ∆1 ], ∆1 ∈ N,and executes MBBC.Deliver( m) in round r∆1 ; subsequently, p1 gets faulty for ∆ 2 consecutive rounds, ∆ 2 ∈ N, it wipes its local state (i.e. initialises all the process variables) in round r∆1+∆ 2 , and it gets permanently correct from round r∆1+∆ 2+1 (namely ∀ri ∈ [r∆1+∆ 2+1 , ∞), p 1 ∈ C(ri)). Let us consider another local execution history H′′ > 1 of process p1 that is faulty in rounds rj ∈ [r1, r ∆1+∆ 2 ] and it wipes its local state in round r∆1+∆ 2 ; sub-sequently, p1 gets permanently correct from round r∆1+∆ 2+1 (namely ∀rj ∈ [r∆1+∆ 2+1 , ∞), p 1 ∈ C(rj )). We provide a graphical representation in Figure 1b. In round r∆1+∆ 2+1 , process p1 has the same local state in both histories and the OBFA oracle generates the same cured () event on process p1. Process p1 does not know what happened during the
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
previous rounds. It is even defining an algorithm A that allows any process pi to share and retrieve the state and events occurred on the process through the point-to-point primitive: process pi can execute such a protocol either as correct or as faulty, and the two executions would be indistinguishable by any other process. According to the Validity property of the MBBC specification, process p1 executing P must MBBC-deliver message m from ps in both histories. In round r∆1+∆ 2+1 process p1 has the same local state on both histories, thus it can act in one only way, specifically it can command or not process pi to deliver message m from ps. In the positive case, the protocol violates the No duplication property in history H′ > 1 , in the negative case the Validity property is violated by the protocol in H′′ > 1 . This leads to a contradiction and the claim follows regardless to the value of ∆ 1,∆ 2, and ∆ c. Discussion. Contrarily to what we could expect, the MBRB and MBBC prob-lems are impossible to solve in settings ( e.g. , 〈SYNC , S-MOB +, ONFA /BFA 〉) where the register abstraction and consensus problems are solvable [17, 4, 31, 6, 10, 8, 11]. The intuition behind this is that other problems addressed under the MBF model have a semantics that do not require to execute a particular oper-ation (the delivery of a message in our case) at most once and depending on a precedent failure state of the process. Indeed, both the register abstractions and consensus set constraints on a local value stored by the processes (respectively, 14 the shared value and the decided value) but no primitive operation is associated with their update in their specification. Contrarily, MBRB and MBBC intro-duce constraints
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
on the deliveries of messages that depend on the actual and previous failure states of the processes, generating thus symmetry conditions that are impossible to break without violating one of the properties charac-terizing the specification. In particular, the main challenge is to ensure that a single broadcast instance does not generate multiple deliveries to the same process while it is correct. Another counter-intuitive result is that consider-ing a setting stronger than the one considered in related works ( e.g. , 〈SYNC , S-MOB +, OFFA 〉), the MBRB problem is impossible to solve while the MBBC one is possible (see Section 6). In the static Byzantine failure model (where ev-ery process is always either correct or faulty in a given execution), the channel specification extends the broadcast one allowing multiple broadcast from the same source. As a matter of fact, in the mobile Byzantine failure model such an extension is less constrained with respect to the broadcast: in MBRB, every process can execute only one broadcast operation for the entire lifetime of the system, whereas MBBC allows multiple broadcasts from the same source; if a process is faulty and executes a broadcast, then it is not allowed to execute a subsequent broadcast when correct in the future in the MBRB specification (No duplication property), while it is in MBBC. Finally, note that other prim-itives, such as consensus or register abstractions, are not useful in solving the MBRB/MBBC problems. Consider again the execution depicted in Figure 1a, correct process may agree or may store a set of delivered messages (according to the MBRB/MBBC specifications) but a single process ( ps in the example), in the settings we characterized, cannot infer if it has already delivered or not a message if it was previously compromised. # 6 A Protocol for MBBC in
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
〈SYNC, S-MOB +, # OFFA 〉 Theorem 12 and Corollary 11 motivate the definition of a stronger local ora-cle than those considered in related work dealing with mobile Byzantine faults, OF F A : both MBRB and MBBC are impossible to solve in the ( 〈SYNC , S-MOB +, ONFA /BFA 〉) settings. Theorem 10 states the impossibility in solving MBRB even in ( 〈SYNC , S-MOB +, OFFA 〉). This Section investigates the remaining open problem-setting: the solvability of MBBC in ( 〈SYNC , S-MOB +, OFFA 〉). Specifically, we start by defining PM BBC −RB , a protocol implementing the MBBC(∆ b, ∆c) communication primitive. Then, we prove its correctness and fault-tolerance optimality. ## 6.1 PM BBC −RB : Protocol Description PM BBC −RB is an extension of Bracha’s algorithm aimed to solve the MBBC problem. It inherits Bracha’s diffusion mechanism: a payload message m is ex-changed inside three protocol messages, SEND , ECHO , and READY . The former 15 is initially sent by the source process to all peers, and the latter are subsequently diffused by all correct processes to all peers if certain conditions are met, namely certain quorums are reached. The pseudo-code of PM BBC −RB is shown in Algorithm 1. This solution over-comes the impossibility stated in Theorem 12 by leveraging on OF F A and by fixing the round index (i.e., the moment in time) where MBBC-deliveries must occur. Every protocol’s message contains the information about a specific MBBC-broadcast instance, specifically the source process label s, the message (payload) m, and the round counter rb when the broadcast instance started. An MBBC-broadcast instance proceeds in four consecutive rounds in PM BBC −RB .In the first round rb, the protocol’s message SEND is computed by ps and en-queued to P2P -send to
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
all processes in the subsequent round. Every process that P2P -receives a SEND message in round rb+1 from ps computes the ECHO protocol’s message for 〈s, r b, m 〉 and enqueues it to P2P -send to all peers. In round rb+2 , the processes that receive sufficiently many ECHO messages (more than ( n + f )/2) for an MBBC-broadcast instance from distinct peers generate the related READY protocol’s message to P2P -send to all processes. Finally, in round rb+3 , the processes that receive a sufficient number of READY messages (more than 2 f ) for an MBBC-broadcast instance from distinct peers MBBC-deliver the associated message m from ps. An additional protocol’s message with respect to Bracha , i.e. ABORT , is exchanged in PM BBC −RB to guarantee the Agreement property in case of a faulty source. In PM BBC −RB , if a correct process ps executes MBBC.Broadcast( m) in round rb, then every process that is correct in round rb+3 triggers MBBC.Deliver (s,m) in the compute phase of that round; every process that is faulty in round rb+3 MBBC-delivers the message m from ps at the first round rk > r b+3 it is correct. We plug the fault-tolerant round counter defined by Bonnet at al. inside the PM BBC −RB protocol, enabling all correct processes to share the same value for the round index (that is assumed as an integer value). Its purpose is to fix the single round where the delivery of a certain message can take place. The round counter features are summarised in the following remark. Remark 13 (Round counter correctness ) . In 〈SYNC, S-MOB +, OBFA /FFA 〉,if n > 3f then every correct process pi in round rj stores the same value for the round index (namely
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
the variable rc in Algorithm 1) during compute phase. We stress the fact that protocol’s messages in PM BBC −RB (SEND , ECHO , READY , and ABORT ) must be propagated in specific rounds with respect to the beginning of the MBBC-broadcast, in order to progress till the delivery of the associated message m.For ease of better understanding, we give a detailed description of PM BBC −RB in Appendix C, and we illustrate some examples of its execution in Appendix B and within the proof of Lemma 14. 16 Algorithm 1 PM BBC −RB 1: procedure Init 2: To send ← ∅ , Sends ← ∅ , cured ← False , rc ← 1 3: Echos ← {} , Readys ← {} , Aborts ← {} . map, 〈s, r, m 〉 : set of process ids 4: RC ← {} . map, process id : round value 5: procedure Broadcast (m) 6: To send ← To send ∪ {〈 SEND , s, rc, m 〉} 7: upon OFFA .cured do 8: cured ← True Send Phase 9: if cured then 10: To send ← ∅ 11: for pk ∈ To send do 12: for q ∈ Π do 13: P2P .send (q, pk) Receive Phase 14: Sends ← ∅ , Echos ← {} , Readys ← {} , Aborts ← {} , RC ← {} 15: upon P2P .deliver (q , 〈Type , s, r b, m 〉) do 16: if s = q and Type = SEND then 17: Sends ← Sends ∪ {〈 s, r b, m 〉} 18: if Type = ECHO then 19: Echos[ 〈s, r b, m 〉] ← Echos[ 〈s, r b, m 〉] ∪ { q} 20: if Type = READY then 21: Readys[ 〈s, r b, m 〉] ← Readys[
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
〈s, r b, m 〉] ∪ { q} 22: if Type = ABORT then 23: Aborts[ 〈s, r b, m 〉] ← Aborts[ 〈s, r b, m 〉] ∪ { q} 24: upon P2P .deliver (q , 〈ROUND , j〉) do 25: RC[ q] ← j Compute Phase 26: To send ← ∅ , rc ← getMajority (RC. values ) 27: for 〈s, r b, m 〉 ∈ Sends do 28: if rc = rb+1 then 29: To send ← To send ∪ {〈 ECHO , s, r b, m〉} 30: for 〈s, r b, m 〉 ∈ Echos do 31: if |Echos[ 〈s, r b, m 〉]| > (n + f )/2 then 32: To send ← To send ∪ {〈 READY , s, r b, m〉} 33: else if |Echos[ 〈s, r b, m 〉]| > f then 34: To send ← To send ∪ {〈 ABORT , s, r b, m〉} 35: for 〈s, r b, m 〉 ∈ Aborts do 36: if |Aborts[ 〈s, r b, m 〉]| > f then 37: |Readys[ 〈s, r b, m 〉] ← ∅ 38: for 〈s, r b, m 〉 ∈ Readys do 39: if |Readys[ 〈s, r b, m 〉]| > 2f then 40: if ((rc = rb+3 ) or (cured and rc > r b+3 and OFFA .faulty at ≤ rb+3 )) and (@〈s, r k , m 〉 ∈ Readys : ( |Readys 〈s, r k , m 〉| > 2f ) ∧ (rk < r b)) then 41: Deliver (s,m) 42: To send ← To send ∪ {〈 READY , s, r b, m〉} 43: cured ← False , rc ← rc+1, To send ← To send ∪ {〈 ROUND , rc 〉} ## 6.2 Correctness Proofs We remark that in S-MOB + mobile agents
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
can move only between the compute and send phase of two consecutive rounds. This implies that ∆ s is assumed greater than or equal to one round. Such mobility model has the following effects to the agents’ capabilities: at the beginning of a round rj , mobile agents can potentially control the messages that are diffused by 2 f processes, the ones where the mobile agents are placed in rj and the others where they were in the previous round rj−1 (they can set in round rj−1 the messages that will 17 be exchange by freed processes in round rj ). This capability can partially be mitigated by the local failure detector OFFA : a process can discard all messages queued to be send right after the failure detector notifies the cured () event. It follows that, at the beginning of a round, at most f processes may not participate in the protocol and at most f may have a Byzantine behavior. The following Lemmas and Theorem state the correctness of PM BBC −RB in solving the MBBC problem and its fault-tolerance optimality with respect to the number of tolerated mobile agents. Lemma 14. If ∆b ≥ 2 rounds and ∆c ≥ 1 round, then PM BBC −RB solves the Mobile Byzantine Broadcast Channel problem (MBBC) in 〈SYNC, S-MOB +, OFFA 〉 if n > 5f .Proof. For simplicity, we give the proof assuming the minimum values for ∆ b and ∆ c. The arguments extend to higher values. (∆ b = 2 rounds , ∆c = 1 round )-Validity : We prove that if we assume ∆ b =2 rounds, ∆ c = 1 round, and a process ps is correct in round rb when it executes MBBC.Broadcast (m), then every process that is ∆ c-infinitely often correct eventually
|
{
"page_id": null,
"source": 7365,
"title": "from dpo"
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.