1

Selecting leader in a clique in

O (n log n)

By Pierre A.Humblet

Presented by: Anat Berkman, 236357 Distributed Algorithms , Technion

2

Problem background

Arbitrary non empty subset wake up spontaneously ans start executing common asynchronous distributed algorithm

5 17

19 2

67

1 2

3

4

4

32

1

3

Assumption

● Messages arrive without error after an arbitrary but finite delay

4

The algorithm

● Main idea : as long as a node did not surrender he tries to capture other nodes according to the edges. First he tries to capture the node at the end point of edge #1, then #2 and so on.

5 17

19 2

67

1 2

3

4

4

32

1

5

5 wants to capture 17

5 17

2. Let me ask my master

3. Master, 5 want to have a fight1. TEST: I want to capture you!

17

4. Lets have a fight: 5 vs 17

6

5 wants to capture 17

5 17

2. Let me ask my master

3. Master, 5 want to have a fight1. TEST: I want to capture you!

17

4. Lets have a fight: 5 vs 17

5. Answer to the fight6. If 5 won- tell him

7

Wake up call

WINNER(A)

A: B:

8

Wake up call

WINNER(A)

A:STATE:active

SIZE:0MASTER:A

B:STATE:active

SIZE:0MASTER:B

STATE is active\stopped. Active means he was not captured yetSIZE is the size of my kingdom MASTER is the identity of my master

9

A process the message of type “WINNER”

A:STATE:active

SIZE:0MASTER:A

WINNER(A)

If ID=id (yes)if state='active' then SIZE=SIZE+1If SIZE=N stopif STATE='active' then

send TEST(SIZE,ID) on edge SIZE

B:STATE:active

SIZE:0MASTER:B

10

A process the message of type “WINNER”

A:STATE:active

SIZE:1MASTER:A

WINNER(A)

If ID=id (yes)if state='active' then SIZE=SIZE+1if SIZE=N stop!if STATE='active' then

send TEST(SIZE,ID) on edge SIZE

B:STATE:active

SIZE:0MASTER:B

11

A process the message of type “WINNER”

A:STATE:active

SIZE:1MASTER:A

WINNER(A)

If ID=id (yes)if state='active' then SIZE=SIZE+1if SIZE=N stop!if STATE='active' then

send TEST(SIZE,ID) on edge SIZE

B:STATE:active

SIZE:0MASTER:B

12

A process the message of type “WINNER”

A:STATE:active

SIZE:1MASTER:A

WINNER(A)

If ID=id (yes)If STATE='active' then SIZE=SIZE+1If SIZE=N stopif STATE='active' then

Send TEST(SIZE,ID) on edge SIZE

B:STATE:active

SIZE:0MASTER:B

TEST(1,A)

13

B process the message of type “TEST” on edge 1

A:STATE:active

SIZE:1MASTER:A

WINNER(A)

If e >= SIZE then: \\{not in our domain, tell the master}EDGE_TO(id)=ePENDING=PENDING+1IF PENDING=1 then send TEST(size,id) on EDGE_TO(MASTER)

else put TEST(size,if) in PENDING_SET

B:STATE:active

SIZE:0MASTER:B

TEST(1,A)EDGE_TO(MASTER)= -1

14

B process the message of type “TEST” on edge 1

A:STATE:active

SIZE:1MASTER:A

WINNER(A)

If e >= SIZE then: \\{not in our domain, tell the master}EDGE_TO(id)=e \\{not in our domain, tell the master}PENDING=PENDING+1IF PENDING=1 then send TEST(size,id) on EDGE_TO(MASTER)

else put TEST(size,if) in PENDING_SET

B:STATE:active

SIZE:0MASTER:B

TEST(1,A)EDGE_TO(MASTER)=-1EDGE_TO(A)=1

15

B process the message of type “TEST” on edge 1

A:STATE:active

SIZE:1MASTER:A

WINNER(A)

If e >= SIZE then: \\{not in our domain, tell the master}EDGE_TO(id)=ePENDING=PENDING+1IF PENDING=1 then send TEST(size,id) on EDGE_TO(MASTER)

else put TEST(size,if) in PENDING_SET

B:STATE:active

SIZE:0MASTER:B

TEST(1,A)EDGE_TO(MASTER)=-1EDGE_TO(A)=1PENDING=0+1=1

PENDING is the number of messages I received but did not finished responding

16

B process the message of type “TEST” on edge 1

A:STATE:active

SIZE:1MASTER:A

WINNER(A)

If e >= SIZE then: \\{not in our domain, tell the master}EDGE_TO(id)=ePENDING=PENDING+1IF PENDING=1 then send TEST(size,id) on EDGE_TO(MASTER)

else put TEST(size,if) in PENDING_SET

B:STATE:active

SIZE:0MASTER:B

TEST(1,A)

EDGE_TO(MASTER)=-1EDGE_TO(A)=1PENDING=0+1=1

TEST(1,A)

17

B process the message of type “TEST” on edge -1

A:STATE:active

SIZE:1MASTER:A

WINNER(A)

If e >= SIZE then: \\{not in our domain, tell the master}EDGE_TO(id)=ePENDING=PENDING+1IF PENDING=1 then send TEST(size,id) on EDGE_TO(MASTER)

else put TEST(size,if) in PENDING_SET

B:STATE:active

SIZE:0MASTER:B

TEST(1,A)

EDGE_TO(MASTER)=-1EDGE_TO(A)=1PENDING=0+1=1

TEST(1,A)

18

B process the message of type “TEST” on edge -1

A:STATE:active

SIZE:1MASTER:A

WINNER(A)

If e >= SIZE then: \\{not in our domain, tell the master}EDGE_TO(id)=ePENDING=PENDING+1IF PENDING=1 then send TEST(size,id) on EDGE_TO(MASTER)

else put TEST(size,if) in PENDING_SETelse \\(e<SIZE)

If (size,id) > (SIZE,ID) thenSTATE='stopped'send WINNER(id) on edge e

B:STATE:stopped

SIZE:0MASTER:B

TEST(1,A)

EDGE_TO(MASTER)=-1EDGE_TO(A)=1PENDING=0+1=1

TEST(1,A)

19

B process the message of type “TEST” on edge -1

A:STATE:active

SIZE:1MASTER:A

WINNER(A)

If e >= SIZE then: \\{not in our domain, tell the master}EDGE_TO(id)=ePENDING=PENDING+1IF PENDING=1 then send TEST(size,id) on EDGE_TO(MASTER)

else put TEST(size,if) in PENDING_SETelse \\(e<SIZE)

If (size,id) > (SIZE,ID) then \\if (1,A) > (0,B) YES!!!! lexicographic orderSTATE='stopped'send WINNER(id) on edge e

B:STATE:stopped

SIZE:0MASTER:B

TEST(1,A)

EDGE_TO(MASTER)=-1EDGE_TO(A)=1PENDING=0+1=1

TEST(1,A)WINNER(A)

20

B process the message of type “WINNER(A)” on edge -1

A:STATE:active

SIZE:1MASTER:A

WINNER(A)

B:STATE:stopped

SIZE:0MASTER:A

TEST(1,A)

EDGE_TO(MASTER)=-1EDGE_TO(A)=1PENDING=0+1=1

TEST(1,A)WINNER(A)If ID=id

ElseIf MASTER <> id //if B<>A

MASTER=idsend WINNER(id) on EDGE_TO(A)

PENDING=PENDING-1If PENDING > 0 then ..

21

B process the message of type “WINNER(A)” on edge -1

A:STATE:active

SIZE:1MASTER:A

WINNER(A)

B:STATE:stopped

SIZE:0MASTER:A

TEST(1,A)

EDGE_TO(MASTER)=-1EDGE_TO(A)=1PENDING=0+1=1

TEST(1,A)WINNER(A)If ID=id

ElseIf MASTER <> id //if B<>A

MASTER=idsend WINNER(id) on EDGE_TO(A)

PENDING=PENDING-1If PENDING > 0 then ..

WINNER(A)

22

B process the message of type “WINNER(A)” on edge -1

A:STATE:active

SIZE:1MASTER:A

WINNER(A)

B:STATE:stopped

SIZE:0MASTER:A

TEST(1,A)

EDGE_TO(MASTER)=-1EDGE_TO(A)=1PENDING=1-1=0

TEST(1,A)WINNER(A)If ID=id

ElseIf MASTER <> id //if B<>A

send WINNER(id) on EDGE_TO(A)PENDING=PENDING-1If PENDING > 0 then ..

WINNER(A)

23

A process the message of type “WINNER(A)” on edge 1

A:STATE:active

SIZE:1MASTER:A

WINNER(A)

B:STATE:stopped

SIZE:0MASTER:A

TEST(1,A)

EDGE_TO(MASTER)=-1EDGE_TO(A)=1PENDING=1-1=0

TEST(1,A)WINNER(A)If ID=id

ElseIf MASTER <> id //if B<>A

send WINNER(id) on EDGE_TO(A)PENDING=PENDING-1If PENDING > 0 then ..

WINNER(A)

24

A process the message of type “WINNER(A)” on edge 1

A:STATE:active

SIZE:2MASTER:A

WINNER(A)

B:STATE:stopped

SIZE:0MASTER:A

TEST(1,A)

EDGE_TO(MASTER)=-1EDGE_TO(A)=1PENDING=1-1=0

TEST(1,A)WINNER(A)If ID=id \\ if A=A

if STATE='active then SIZE=SIZE+1 if SIZE=N then STOP

ElseIf MASTER <> id //if B<>A

send WINNER(id) on EDGE_TO(A)PENDING=PENDING-1If PENDING > 0 then ..

WINNER(A)

25

A process the message of type “WINNER(A)” on edge 1

A:STATE:active

SIZE:1MASTER:A

WINNER(A)

B:STATE:stopped

SIZE:0MASTER:A

TEST(1,A)

EDGE_TO(MASTER)=-1EDGE_TO(A)=1PENDING=1-1=0

TEST(1,A)WINNER(A)If ID=id \\ if A=A

if STATE='active then SIZE=SIZE+1 if SIZE=N then STOP – you are the leader!!!!!!!!!!

ElseIf MASTER <> id //if B<>A

send WINNER(id) on EDGE_TO(A)PENDING=PENDING-1If PENDING > 0 then ..

WINNER(A)

26

The algorithm

● When node ID receive WINNER(id) :if ID=id then

if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been

lost send TEST(SIZE,ID) on

edge SIZE● else if MASTER <>id then

MASTER=id send WINNER(id) on EDGE_TO(id)

PENDING=PENDING-1● if PENDING > 0 then send a message

from

PENDING_SET on edge EDGE_TO(MASTER)

27

The algorithm

● When node ID receive TEST(size,id) on edge e:● if e < SIZE then//message comes from our

domainif (size,id) > (SIZE,ID) then //lexicographic

STATE='stopped' send WINNER(id) on edge e

else send WINNER(ID) on edge e

else //message from outsize the domainEDGE_TO(id) = ePENDING = PENDING +1if PENDING =1 then

send TEST(size,id) on EDGE_TO(MASTER)

else put TEST(size,id) in

PENDING_SET

28

STATE active

SIZE 0

MASTER B

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER C

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

ExampleSTATE active

SIZE 0

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

WINNER(A)

A:

WINNER(C)

C:

D:

B:

E:

WINNER(D)

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

29

STATE active

SIZE 0

MASTER B

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER C

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

A<B<C<D<...STATE active

SIZE 0

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

WINNER(A)

A:

WINNER(C)

C:

D:

B:

E:

WINNER(D)

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

30

if ID=id then if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE active

SIZE 0

MASTER B

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER C

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

ASTATE active

SIZE 1

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

WINNER(A)

A:

WINNER(C)

C:

D:

B:

E:

WINNER(D)

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

31

if ID=id then if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE active

SIZE 0

MASTER B

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER C

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

ASTATE active

SIZE 1

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

WINNER(A)

A:

WINNER(C)

C:

D:

B:

E:

WINNER(D)

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

32

if ID=id then if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE active

SIZE 0

MASTER B

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER C

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

ASTATE active

SIZE 1

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

WINNER(A)

A:

WINNER(C)

C:

D:

B:

E:

WINNER(D)

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

TEST(1,A)

F GF

H

I J

33

if ID=id then if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE active

SIZE 0

MASTER B

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 1

MASTER C

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

CSTATE active

SIZE 1

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

WINNER(A)

A:

WINNER(C)

C:

D:

B:

E:

WINNER(D)

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

TEST(1,C)

F GF

H

I J

34

If e < SIZE //message comes from our Else //message from outsize the domain

EDGE_TO(id) = ePENDING = PENDING +1If PENDING =1 then send TEST(size,id) on EDGE_TO(MASTER)

else put TEST(size,id) in PENDING_SET

STATE active

SIZE 0

MASTER B

PENDING

1

EDGE_TO

A-1

INPUT_SET

PENDING_SET

STATE active

SIZE 1

MASTER C

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

B-process A's messageSTATE active

SIZE 1

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

WINNER(A)

A:

WINNER(C)

C:

D:

B:

E:

WINNER(D)

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

TEST(1,A)

F GF

H

I J

35

If e < SIZE //message comes from our Else //message from outsize the domain

EDGE_TO(id) = ePENDING = PENDING +1If PENDING =1 then send TEST(size,id) on EDGE_TO(MASTER)

else put TEST(size,id) in PENDING_SET

STATE active

SIZE 0

MASTER B

PENDING

2

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

TEST(1,C)

STATE active

SIZE 1

MASTER C

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 1

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

WINNER(A)

A:

WINNER(C)

C:

D:

B:

E:

WINNER(D)

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

B-process C's message(1,C)

36

If e < SIZE //message comes from our Else //message from outsize the domain

EDGE_TO(id) = ePENDING = PENDING +1If PENDING =1 then

send TEST(size,id) on EDGE_TO(MASTER) else put TEST(size,id) in PENDING_SET

STATE active

SIZE 0

MASTER B

PENDING

2

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

TEST(1,C)

STATE active

SIZE 1

MASTER C

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 1

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

B-process B's message (test(1,A))

WINNER(A)

A:

WINNER(C)

C:

D:

B:

E:

WINNER(D)

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

37

If e < SIZE //message comes from our If (size,id) > (SIZE,ID) then //lexicographic

STATE='stopped'Send WINNER(id) on edge e

ElseSend WINNER(ID) on edge e

STATE STOPPED

SIZE 0

MASTER B

PENDING

2

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

TEST(1,C)

STATE active

SIZE 1

MASTER C

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 1

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

B-process B's message (test(1,A))

WINNER(A)

A:

WINNER(C)

C:

D:

B:

E:

WINNER(D)

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

WINNER(A)

F GF

H

I J

38

●if ID=id then

●ELSE if MASTER <>id then MASTER=id

send WINNER(id) on EDGE_TO(id) PENDING=PENDING-1

● if PENDING > 0 then send a message from PENDING_SET on edge EDGE_TO(MASTER)

STATE STOPPED

SIZE 0

MASTER A

PENDING

1

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE active

SIZE 1

MASTER C

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 1

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

B-process B's message WINNER(A)

WINNER(A)

A:

WINNER(C)

C:

D:

B:

E:

WINNER(D)

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

WINNER(A)

TEST(1,C)

F GF

H

I J

39

●if ID=id then

●if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE STOPPED

SIZE 0

MASTER A

PENDING

1

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE active

SIZE 1

MASTER C

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 2

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

A-process B's message WINNER(A)

A:

C:

D:

B:

E:

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

TEST(2,A)

F GF

H

I J

40

If e < SIZE //message comes from our domainIf (size,id) > (SIZE,ID) then //lexicographic

STATE='stopped'Send WINNER(id) on edge e

ElseSend WINNER(ID) on edge e

STATE STOPPED

SIZE 0

MASTER A

PENDING

1

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE active

SIZE 1

MASTER C

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 2

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

A-process B's message TEST(1,C)

A:

C:

D:

B:

E:

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

WINNER(A)

F GF

H

I J

41

●if ID=id then●else if MASTER <>id then MASTER=id

send WINNER(id) on EDGE_TO(id) PENDING=PENDING-1● if PENDING > 0 then send a message from PENDING_SET on edge EDGE_TO(MASTER)

STATE STOPPED

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE active

SIZE 1

MASTER C

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 2

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

B-process A's message WINNER(A)

A:

C:

D:

B:

E:

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

42

If e < SIZEElse //message from outsize the domain

EDGE_TO(id) = ePENDING = PENDING +1If PENDING =1 then

send TEST(size,id) on EDGE_TO(MASTER)Else put TEST(size,id) in PENDING_SET

STATE STOPPED

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE active

SIZE 1

MASTER C

PENDING

1

EDGE_TO

A-2

INPUT_SET

PENDING_SET

STATE active

SIZE 2

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

C-process A's message TEST(2,A)

A:

C:

D:

B:

E:

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

TEST(2,A) F GF

H

I J

43

If e < SIZE //message comes from our domainIf (size,id) > (SIZE,ID) then //lexicographic

STATE='stopped'Send WINNER(id) on edge e

ElseSend WINNER(ID) on edge e

STATE STOPPED

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER C

PENDING

1

EDGE_TO

A-2

INPUT_SET

PENDING_SET

STATE active

SIZE 2

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

C-process C's message TEST(2,A)

A:

C:

D:

B:

E:

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

WINNER(A) F GF

H

I J

44

if ID=id then else if MASTER <>id then

MASTER=id send WINNER(id) on EDGE_TO(id)

PENDING=PENDING-1 if PENDING > 0 then send a message from PENDING_SET on edge EDGE_TO(MASTER)

STATE STOPPED

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER A

PENDING

0

EDGE_TO

A-2

INPUT_SET

PENDING_SET

STATE active

SIZE 2

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

C-process C's message WINNER(A)

A:

C:

D:

B:

E:

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

WINNER(A)

F GF

H

I J

45

●if ID=id then if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE STOPPED

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER A

PENDING

0

EDGE_TO

A-2

INPUT_SET

PENDING_SET

STATE active

SIZE 3

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

A-process C's message WINNER(A)

A:

C:

D:

B:

E:

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 0

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

TEST(3,A)

F GF

H

I J

46

●if ID=id then if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE STOPPED

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER A

PENDING

0

EDGE_TO

A-2

INPUT_SET

PENDING_SET

STATE active

SIZE 3

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

D-process awake WINNER(D)

A:

C:

D:

B:

E:

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 1

MASTER D

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

TEST(1,D)

F GF

H

I J

47

If e < SIZEElse //message from outsize the domain

EDGE_TO(id) = ePENDING = PENDING +1If PENDING =1 then

send TEST(size,id) on EDGE_TO(MASTER) else put TEST(size,id) in PENDING_SET

STATE STOPPED

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER A

PENDING

0

EDGE_TO

A-2

INPUT_SET

PENDING_SET

STATE active

SIZE 3

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

D-process A message TEST(3,A)

A:

C:

D:

B:

E:

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE active

SIZE 1

MASTER D

PENDING

1

EDGE_TO

A-1

INPUT_SET

PENDING_SET

TEST(3,A)

F GF

H

I J

48

If e < SIZE //message comes from our domainIf (size,id) > (SIZE,ID) then //lexicographic

STATE='stopped'Send WINNER(id) on edge e

ElseSend WINNER(ID) on edge e

STATE STOPPED

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER A

PENDING

0

EDGE_TO

A-2

INPUT_SET

PENDING_SET

STATE active

SIZE 3

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

D-process D message TEST(3,A)

A:

C:

D:

B:

E:

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER D

PENDING

1

EDGE_TO

A-1

INPUT_SET

PENDING_SET

WINNER(A)

F GF

H

I J

49

if ID=id then else if MASTER <>id then

MASTER=id send WINNER(id) on EDGE_TO(id)

PENDING=PENDING-1 if PENDING > 0 then send a message from PENDING_SET on edge EDGE_TO(MASTER)

STATE STOPPED

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER A

PENDING

0

EDGE_TO

A-2

INPUT_SET

PENDING_SET

STATE active

SIZE 3

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

D-process D message WINNER(A)

A:

C:

D:

B:

E:

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER A

PENDING

0

EDGE_TO

A-1

INPUT_SET

PENDING_SET

WINNER(A)

F GF

H

I J

50

●if ID=id then if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE STOPPED

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER A

PENDING

0

EDGE_TO

A-2

INPUT_SET

PENDING_SET

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

A-process D message WINNER(A)

A:

C:

D:

B:

E:

STATE active

SIZE 0

MASTER E

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER A

PENDING

0

EDGE_TO

A-1

INPUT_SET

PENDING_SET

TEST(4,A)

F GF

H

I J

51

If e < SIZEElse //message from outsize the domain

EDGE_TO(id) = ePENDING = PENDING +1If PENDING =1 then

send TEST(size,id) on EDGE_TO(MASTER) Else put TEST(size,id) in PENDING_SET

STATE STOPPED

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER A

PENDING

0

EDGE_TO

A-2

INPUT_SET

PENDING_SET

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

E-process A message TEST(4,A)

A:

C:

D:

B:

E:

STATE active

SIZE 0

MASTER E

PENDING

1

EDGE_TO

A-1

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER A

PENDING

0

EDGE_TO

A-1

INPUT_SET

PENDING_SET

TEST(4,A)

F GF

H

I J

52

If e < SIZE //message comes from our domainIf (size,id) > (SIZE,ID) then //lexicographic

STATE='stopped'Send WINNER(id) on edge e

ElseSend WINNER(ID) on edge e

STATE STOPPED

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER A

PENDING

0

EDGE_TO

A-2

INPUT_SET

PENDING_SET

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

E-process E message TEST(4,A)

A:

C:

D:

B:

E:

STATE stopped

SIZE 0

MASTER E

PENDING

1

EDGE_TO

A-1

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER A

PENDING

0

EDGE_TO

A-1

INPUT_SET

PENDING_SET

WINNER(A)

F GF

H

I J

53

if ID=id then else if MASTER <>id then

MASTER=id send WINNER(id) on EDGE_TO(id)

PENDING=PENDING-1 if PENDING > 0 then send a message from PENDING_SET on edge EDGE_TO(MASTER)

STATE STOPPED

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER A

PENDING

0

EDGE_TO

A-2

INPUT_SET

PENDING_SET

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

E-process E message WINNER(A)

A:

C:

D:

B:

E:

STATE stopped

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER A

PENDING

0

EDGE_TO

A-1

INPUT_SET

PENDING_SET

WINNER(A)

F GF

H

I J

54

●if ID=id then if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

F woke up

A:

C:

D:

B:

E:STATE active

SIZE 1

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

55

●if ID=id then if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

F woke up

A:

C:

D:

B:

E:STATE active

SIZE 1

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

TEST(1,F)

56

If e < SIZE //message comes from our Else //message from outsize the domain

EDGE_TO(id) = ePENDING = PENDING +1If PENDING =1 then

send TEST(size,id) on EDGE_TO(MASTER) else put TEST(size,id) in PENDING_SET

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

G process the message TEST from F

A:

C:

D:

B:

E:STATE active

SIZE 1

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

STATE active

SIZE 0

MASTER E

PENDING

1

EDGE_TO

F-1

INPUT_SET

PENDING_SET

TEST(1,F)

57

If e < SIZE //message comes from our If (size,id) > (SIZE,ID) then //lexicographic

STATE='stopped'Send WINNER(id) on edge e

ElseSend WINNER(ID) on edge e

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

G process the message TEST from G

A:

C:

D:

B:

E:STATE active

SIZE 1

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

STATE stopped

SIZE 0

MASTER E

PENDING

1

EDGE_TO

F-1

INPUT_SET

PENDING_SET

WINNER(F)

58

●if ID=id then

●ELSE if MASTER <>id then MASTER=id

send WINNER(id) on EDGE_TO(id) PENDING=PENDING-1

● if PENDING > 0 then send a message from PENDING_SET on edge EDGE_TO(MASTER)

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

G process message WINNER from G

A:

C:

D:

B:

E:STATE active

SIZE 1

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

STATE stopped

SIZE 0

MASTER F

PENDING

0

EDGE_TO

F-1

INPUT_SET

PENDING_SET

WINNER(F)

59

●if ID=id then

●if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

F process message WINNER(F) from G

A:

C:

D:

B:

E:STATE active

SIZE 2

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

TEST(2,F)

60

If e < SIZE //message comes from our Else //message from outsize the domain

EDGE_TO(id) = ePENDING = PENDING +1If PENDING =1 then

send TEST(size,id) on EDGE_TO(MASTER) else put TEST(size,id) in PENDING_SET

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

H process message TEST from F

A:

C:

D:

B:

E:STATE active

SIZE 2

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

TEST(2,F)

STATE active

SIZE 0

MASTER H

PENDING

1

EDGE_TO

F-1

INPUT_SET

PENDING_SET

61

If e < SIZE //message comes from our If (size,id) > (SIZE,ID) then //lexicographic

STATE='stopped'Send WINNER(id) on edge e

ElseSend WINNER(ID) on edge e

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

H process message TEST from H

A:

C:

D:

B:

E:STATE active

SIZE 2

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

WINNER(F)

STATE stopped

SIZE 0

MASTER H

PENDING

1

EDGE_TO

F-1

INPUT_SET

PENDING_SET

62

●if ID=id then

●ELSE if MASTER <>id then MASTER=id

send WINNER(id) on EDGE_TO(id) PENDING=PENDING-1

● if PENDING > 0 then send a message from PENDING_SET on edge EDGE_TO(MASTER)

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

H process message WINNER(F) from H

A:

C:

D:

B:

E:STATE active

SIZE 2

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

WINNER(F)

STATE stopped

SIZE 0

MASTER F

PENDING

0

EDGE_TO

F-1

INPUT_SET

PENDING_SET

63

●if ID=id then

●if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

F process message WINNER(F) from H

A:

C:

D:

B:

E:STATE active

SIZE 3

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

TEST(3,F)

64

If e < SIZE //message comes from our Else //message from outsize the domain

EDGE_TO(id) = ePENDING = PENDING +1If PENDING =1 then

send TEST(size,id) on EDGE_TO(MASTER) else put TEST(size,id) in PENDING_SET

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

I process message TEST from F

A:

C:

D:

B:

E:STATE active

SIZE 3

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

TEST(3,F)

STATE active

SIZE 0

MASTER I

PENDING

1

EDGE_TO

F-1

INPUT_SET

PENDING_SET

65

If e < SIZE //message comes from our If (size,id) > (SIZE,ID) then //lexicographic

STATE='stopped'Send WINNER(id) on edge e

ElseSend WINNER(ID) on edge e

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

I process message TEST from I

A:

C:

D:

B:

E:STATE active

SIZE 3

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

WINNER(F)

STATE stopped

SIZE 0

MASTER I

PENDING

1

EDGE_TO

F-1

INPUT_SET

PENDING_SET

66

●if ID=id then

●ELSE if MASTER <>id then MASTER=id

send WINNER(id) on EDGE_TO(id) PENDING=PENDING-1

● if PENDING > 0 then send a message from PENDING_SET on edge EDGE_TO(MASTER)

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

I process message WINNER(F) from I

A:

C:

D:

B:

E:STATE active

SIZE 3

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

WINNER(F)

STATE stopped

SIZE 0

MASTER F

PENDING

0

EDGE_TO

F-1

INPUT_SET

PENDING_SET

67

●if ID=id then

●if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

F process message WINNER(F) from H

A:

C:

D:

B:

E:STATE active

SIZE 4

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

TEST(4,F)

68

If e < SIZE //message comes from our Else //message from outsize the domain

EDGE_TO(id) = ePENDING = PENDING +1If PENDING =1 then

send TEST(size,id) on EDGE_TO(MASTER) else put TEST(size,id) in PENDING_SET

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

J process message TEST from F

A:

C:

D:

B:

E:STATE active

SIZE 4

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

STATE active

SIZE 0

MASTER J

PENDING

1

EDGE_TO

F-1

INPUT_SET

PENDING_SET

TEST(4,F)

69

If e < SIZE //message comes from our If (size,id) > (SIZE,ID) then //lexicographic

STATE='stopped'Send WINNER(id) on edge e

ElseSend WINNER(ID) on edge e

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

J process message TEST from J

A:

C:

D:

B:

E:STATE active

SIZE 4

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

STATE stopped

SIZE 0

MASTER J

PENDING

1

EDGE_TO

F-1

INPUT_SET

PENDING_SET

WINNER(F)

70

If e < SIZE //message comes from our If (size,id) > (SIZE,ID) then //lexicographic

STATE='stopped'Send WINNER(id) on edge e

ElseSend WINNER(ID) on edge e

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

J process message WINNER(F) from J

A:

C:

D:

B:

E:STATE active

SIZE 4

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

STATE stopped

SIZE 0

MASTER F

PENDING

0

EDGE_TO

F-1

INPUT_SET

PENDING_SET

WINNER(F)

71

if ID=id then

if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

F process message WINNER(F) from J

A:

C:

D:

B:

E:STATE active

SIZE 5

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

TEST(5,F)

72

If e < SIZE //message comes from our Else //message from outsize the domain

EDGE_TO(id) = ePENDING = PENDING +1If PENDING =1 then

send TEST(size,id) on EDGE_TO(MASTER) else put TEST(size,id) in PENDING_SET

STATE active

SIZE 4

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

C process message TEST(5,F) from F

A:

C:

D:

B:

E:STATE active

SIZE 5

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F GF

H

I J

TEST(5,F)

STATE stopped

SIZE 1

MASTER A

PENDING

1

EDGE_TO

A-2F-5

INPUT_SET

PENDING_SET

73

●if ID=id then

●if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE STRPPED

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

STATE stopped

SIZE 1

MASTER A

PENDING

0

EDGE_TO

A-2

INPUT_SET

PENDING_SET

STATE active

SIZE 5

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

A-process E message WINNER(A)

A:

C:

D:

B:

E:

STATE stopped

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1

INPUT_SET

PENDING_SET

STATE stopped

SIZE 5

MASTER A

PENDING

0

EDGE_TO

A-1

INPUT_SET

PENDING_SET

TEST(1,C)

TEST(5,A)

F GF

H

I J

74

If e < SIZE //message comes from our domainIf (size,id) > (SIZE,ID) then //lexicographic

STATE='stopped'Send WINNER(id) on edge e

STATE stopped

SIZE 5

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

A process message TEST(5,F) from C

A:

C:STATE active

SIZE 5

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F

STATE stopped

SIZE 1

MASTER A

PENDING

1

EDGE_TO

A-2F-5

INPUT_SET

PENDING_SET

if (5,F) > (5,A)WINNER(F)

75

●if ID=id then●else if MASTER <>id then MASTER=id

send WINNER(id) on EDGE_TO(id) PENDING=PENDING-1● if PENDING > 0 then send a message from PENDING_SET on edge EDGE_TO(MASTER)

STATE stopped

SIZE 5

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

C process message WINNER(F) from A

A:

C:

STATE active

SIZE 5

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F

STATE stopped

SIZE 1

MASTER F

PENDING

0

EDGE_TO

A-2F-5

INPUT_SET

PENDING_SET

WINNER(F)

76

●if ID=id then if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE stopped

SIZE 5

MASTER A

PENDING

EDGE_TO

INPUT_SET

PENDING_SET

F process message WINNER(F) from C

A:

C:

STATE active

SIZE 6

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F

STATE stopped

SIZE 1

MASTER F

PENDING

0

EDGE_TO

A-2F-5

INPUT_SET

PENDING_SET

TEST(6,F)

77

If e < SIZEElse //message from outsize the domain

EDGE_TO(id) = ePENDING = PENDING +1If PENDING =1 then

send TEST(size,id) on EDGE_TO(MASTER) else put TEST(size,id) in PENDING_SET

STATE stopped

SIZE 5

MASTER A

PENDING

1

EDGE_TO

F-5

INPUT_SET

PENDING_SET

A process message TEST(6,F) from F

A:

C:

STATE active

SIZE 6

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F

STATE stopped

SIZE 1

MASTER F

PENDING

0

EDGE_TO

A-2F-5

INPUT_SET

PENDING_SET

TEST(6,F)

78

If e < SIZE //message comes from our domainIf (size,id) > (SIZE,ID) then //lexicographic

STATE='stopped'Send WINNER(id) on edge e

ElseSend WINNER(ID) on edge e

STATE stopped

SIZE 5

MASTER A

PENDING

1

EDGE_TO

F-5

INPUT_SET

PENDING_SET

A process message TEST(6,F) from A

A:

C:

STATE active

SIZE 6

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F

STATE stopped

SIZE 1

MASTER F

PENDING

0

EDGE_TO

A-2F-5

INPUT_SET

PENDING_SET

WINNER(F)

79

if ID=id then

else if MASTER <>id then MASTER=id

send WINNER(id) on EDGE_TO(id) PENDING=PENDING-1

if PENDING > 0 then send a message from PENDING_SET on edge EDGE_TO(MASTER)

STATE stopped

SIZE 5

MASTER F

PENDING

0

EDGE_TO

F-5

INPUT_SET

PENDING_SET

A process message WINNER(F) from A

A:

C:

STATE active

SIZE 6

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F

STATE stopped

SIZE 1

MASTER F

PENDING

0

EDGE_TO

A-2F-5

INPUT_SET

PENDING_SET

WINNER(F)

80

if ID=id then

if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!If STATE='active' then \\no fight has been lost

send TEST(SIZE,ID) on edge SIZE

STATE stopped

SIZE 5

MASTER F

PENDING

0

EDGE_TO

F-5

INPUT_SET

PENDING_SET

F process message WINNER(F) from A

A:

STATE active

SIZE 7

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

F

B:

TEST(7,F)

STATE STOPPED

SIZE 0

MASTER A

PENDING

0

EDGE_TO

A-1C-2

INPUT_SET

PENDING_SET

81

B process message TEST(F)

A:

STATE active

SIZE 7

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

B:A:

C:

D:

B:

E:

F GF

H

I J

TEST(7,F)

82

A:

STATE active

SIZE 7

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

B:A:

C:

D:

B:

E:

F GF

H

I J

WINNER(F)

83

A:

STATE active

SIZE 7

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

B:A:

C:

D:

B:

E:

F GF

H

I J

WINNER(F)

84

A:

STATE active

SIZE 8

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

B:A:

C:

D:

B:

E:

F GF

H

I J

TEST(8,F)

85

A:

STATE active

SIZE 8

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

B:A:

C:

D:

B:

E:

F GF

H

I J

TEST(8,F)

86

A:

STATE active

SIZE 8

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

B:A:

C:

D:

B:

E:

F GF

H

I J

WINNER(F)

87

A:

STATE active

SIZE 8

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

B:A:

C:

D:

B:

E:

F GF

H

I J

WINNER(F)

88

A:

STATE active

SIZE 9

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

B:A:

C:

D:

B:

E:

F GF

H

I J

TEST(9,F)

89

A:

STATE active

SIZE 9

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

B:A:

C:

D:

B:

E:

F GF

H

I J

TEST(9,F)

90

A:

STATE active

SIZE 10

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

B:A:

C:

D:

B:

E:

F GF

H

I J

WINNER(F)

if ID=id then if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!

91

A:

STATE active

SIZE 10

MASTER F

PENDING

0

EDGE_TO

INPUT_SET

PENDING_SET

B:A:

C:

D:

B:

E:

F GF

H

I J

if ID=id then if STATE='active' then SIZE=SIZE+1if SIZE=N then stop!

WE HAVE A LEADER!!!!!!!!!!!

92

Correctness

● We would like to show :● 1. Termination● 2. One leader is elected and only one

93

Termination

● We will show:1. The number of messages is bounded2. There is no deadlocktherefore the algorithm stop after a finite number of messages.

94

Termination- proof

The number of messages is bounded:

Each processor can send at most N-1 TEST messages. TEST message can cause at most more 3 messages (to the master,from the master,to the origin node-only if won). So total there is at most messages.4 ⋅𝑛2

95

Termination- proof

There is no deadlock:

Assume there is a deadlock. Now let's look at the processor with the highest (SIZE,ID). He waits for an answer for his TEST message. Assume node u received the TEST message. Node u will eventually deliver it to it's master. At the end of the battle one will win and continue (send more TEST messages or win)- no deadlock.

Bounded number of messages + no deadlock = termination

96

One leader is elected● Define 'domain' of node ID at time t as the set

of nodes from which it has receive winner(ID), including itself and the node was active.

● The domain size can not decrease

● For each active node: the domain size equal to SIZE: (from the code upon receiving WINNER(ID))

This is the only line SIZE is changed

if ID=id then if STATE='active' then SIZE=SIZE+1

97

● Let be the domain of node B at time tb● Lemma 1:● Proof: assume v in from time and in

v joins so

we will show by induction on j- the number of new masters v had after till (include)

𝐷𝐵𝑡 𝑏

𝐷𝐵𝑡 𝑏∩𝐷 𝐴

𝑡 𝑎≠∅→ ∣ 𝐷𝐵𝑡𝑏 ∣≠ ∣𝐷 𝐴

𝑡 𝑎 ∣

𝑡𝑎𝐷 𝐴𝑡𝑏

𝐷𝐵 ∣𝐷𝐵𝑡 𝑏∣> ∣ 𝐷𝐴

𝑡 𝑎 ∣

𝑡𝑎 𝑡𝑏

98

● Basis j=1:v belonged to domain A and then joined domain B (directly).

AB

V

B sent TEST to v, who gave it to A. At time t', A processed this message: TEST(Bsize,B) 𝑡 𝐴<𝑡 ′<𝑡𝐵

v joined B so : either or but B>A. After v join Domain B Domain A no longer increase .In both cases after v join B :

∣𝐷𝐵𝑡 𝑏∣> ∣ 𝐷𝐴

𝑡 ′ ∣

∣𝐷𝐵 ∣> ∣ 𝐷𝐴 ∣ ∣𝐷𝐵 ∣=∣𝐷 𝐴∣

99

● Step: if the statement holds for some natural number j=x, then the statement holds for j=x+1.From the correctness for j=x we know that

as in the basis we can prove that so total we can have:

∣𝐷𝑥

𝑡𝑥 ∣> ∣𝐷 𝐴𝑡 ′ ∣

∣𝐷𝑥+1𝑡 𝑥+1 ∣> ∣𝐷𝑥

𝑡 𝑥 ∣

∣𝐷𝑥+1𝑡 𝑥+1 ∣> ∣𝐷𝑥

𝑡 𝑥 ∣> ∣𝐷 𝐴𝑡 ′ ∣

100

● So we proved that

in other words:𝐷𝐵

𝑡 𝑏∩𝐷 𝐴𝑡 𝑎≠∅→ ∣ 𝐷𝐵

𝑡𝑏 ∣≠ ∣𝐷 𝐴𝑡 𝑎 ∣

∣𝐷𝐵𝑡 𝑏∣=∣𝐷 𝐴

𝑡𝑎 ∣→𝐷𝐵𝑡 𝑏∩𝐷 𝐴

𝑡 𝑎=∅

101

● Rank the nodes in order of decreasing order of SIZE at termination, breaking ties arbitrarily and denote by Si the final SIZE of the i”th ranked node. Lemma 2:

Proof:

●

each once was in the same size of Si. By lemma1 we know they all disjoin. If we divide all nodes (N) equally we will get

𝑆 𝑖≤𝑁𝑖

𝑆1 ,𝑆2 , . ..𝑆𝑖− 1

𝑆 𝑖≤𝑁𝑖

∣ 𝑆1∣≥ ∣𝑆2∣ ≥ ∣𝑆3 ∣≥ ... ∣𝑆𝑛 ∣

102

ONE LEADER

● The node with the largest (SIZE,ID) is S1, it is not possible it lost a fight (if it has there was Si with larger SIZE). So he won all the fights- at termination it's size is N. the size of S2 is smaller than S1 (lemma2 + S1 with SIZE=N) so S2 did not win. Same for all other nodes.

103

Complexity

● Each domain can at most send TEST message as it's size so:assume k woke up arbitrary (each test message can cause at most three more messages)

So total we have O(N log(k)) messages

4 ⋅(𝑁1 +𝑁2

+𝑁3

+...+𝑁𝑘 )

104

Lower bound

From the paper

“Optimal lower bounds for some distributed algorithms for a

complete network of predecessors “

Written by: E.Korach, S.Moran, S.Zaks

105

Main Idea- lower bound

● The adversary will always choose the “longest algorithm”. So we look at all possible executions, then we drop messages which don't use “new” edges, and we show that even if we drop messages our best algorithm is still bounded byΩ (𝑛 log𝑛)

106

Lower bound

● Let A be a distributed algorithm acting on graph G=(V,E). Execution of A may consist events: sending a message, receiving a message or doing local computation.

● We assume no two message are sent in exactly the same time, therefor in each execution we associate a sequence

● SEND = ⟨ 𝑠𝑒𝑛𝑑1 , 𝑠𝑒𝑛𝑑2 , . ..𝑠𝑒𝑛𝑑𝑘 ⟩

107

● For every event where is the node sending the message and

is the edge used by it● Example 1

● Example 2

𝑠𝑒𝑛𝑑𝑖=(𝑣 (𝑠𝑒𝑛𝑑𝑖 ) ,𝑒 (𝑠𝑒𝑛𝑑𝑖 ))𝑣 (𝑠𝑒𝑛𝑑𝑖 )𝑒 (𝑠𝑒𝑛𝑑𝑖 )

V1 V2 SEND= <(v1,(v1,v2))>

V1 V2 SEND= <>

108

● Let SEND(t) be the prefix of length t of SEND,

● If t<t' then we say SEND(t') is an extension of SEND(t) and SEND(t)<SEND(t')

𝑆𝐸𝑁𝐷 (𝑡 )= ⟨𝑠𝑒𝑛𝑑1 , 𝑠𝑒𝑛𝑑2 , . ..𝑠𝑒𝑛𝑑𝑡 ⟩𝑆𝐸𝑁𝐷 (0 )=⟨⟩

109

● Let NEW=NEW(SEND) be the subsequence of SEND that consist of all the events that use previously unused edges.

V1 V21

2

SEND= <(v1,(v1,v2)),(v2,(v1,v2)) >NEW = <(v1,(v1,v2)) >

110

● G(NEW(t)) = (V,E(NEW(t)))where E(NEW(t)) is the set of edges used in NEW(t). NEW(t) - prefix of size t of NEW

● Example:

V1 V21

2

V3

G

V1 V2

G(NEW(1))

V3

111

● If for every execution of the algorithm A the corresponding graph G(NEW) is connected then we term this algorithm global.

112

● The edge complexity e(A) of an algorithm A acting on a graph G is the maximal length of a sequence NEW over all executions of A

● The message complexity m(A) of an algorithm A acting on a graph G is the maximal length of a sequence SEND over all executions of A.

● Clearly𝑚 (𝐴 )≥𝑒 (𝐴)

113

● For each algorithm A and graph G we define the exhaustive set of A with respect to G, denoted by EX(A,G) (or E(A)) as the set of all the sequences NEW(t) corresponding to possible executions of A

114

Axiom 1

● The empty sequence is in EX(A,G)

intuitive explanation: EX(A,G) is the set of all the sequences NEW(t) corresponding to possible executions of A, in particular EX(A,G) includes the sequence corresponding to NEW(0).

115

Axiom 2

● If two sequences NEW1,NEW2 which do not interfere with each other are in EX(A,G) then so is also their concatenation NEW1 NEW2°

Other nodes

New1

New2

116

Axiom 3

● If NEW(t) is a sequence in EX(A,G) with last element (v,e), and if e' is an unused edge adjacent to v, then the sequence obtained from NEW(t) by replacing e by e' is also in EX(A,G)Other nodes

(v,e)

Other nodes

e

The adversary

Other nodes

(v,e')

Other nodes

e'

117

Axiom 4

● If NEW(t) is in EX(A,G) and C is a proper subgraph of G(NEW(t)) which is a union of some connected components, then there is an extension of NEW(t) in which the first new message (v,e) satisfies v in C. (A global)

Other nodes

C1

C2C

It is impossible that it's the end of the algorithm (and the other nodes sleep)

118

Lemma 1

● Lemma 1: Let A be a global algorithm acting on a complete graph G=(V,E) and let

● then there exists a sequence of messages NEW in EX(A,G) such that G(NEW) has one connected component whose set of vertexes is U and the vertexes in V-U are isolated

𝑈⊆𝑉

119

Lemma 1

● Proof:By induction we will build:If there is nothing to prove.

If ( assume v1, v2) : we start with the empty sequence (axiom 1). Define C={v1},with axiom 4 we have extension which starts in v1. We have unused edged (v1,v2) so according to axiom 3 we can replace it.

∣𝑈 ∣≤1

∣𝑈 ∣=2

120

Lemma 1

● Proof: the main idea is we can keep this process as long we have an unused edge:

Each iterate we pick a node from C(4). If it's connected to all it's neighbors in C- we done. Else- we can connect it to a neighbor it's not connected to (3), we can proceed until there is a node which is saturated (and then C is connected component)

Other nodes

121

Theorem 1

● Theorem 1: let A be a global algorithm acting on a completed graph G with n nodes. Then the edge complexity e(A) of A is at least O(n log n).

● Proof: for a subset U of V we define e(U) to be the maximal length of a sequence NEW in EX(A,G), which induces a graph that has a connected component whose set of vertexes is U and isolated vertexes otherwise (Exist from lemma 1)

122

Theorem 1- proof

● Definenote: e(n) is the edge complexity of A.

● Now we will prove that

Let U be a disjoint union of and {v} such that |U1|=|U2|=k so e(U)=e(2k+1).

𝑒 (𝑘)=𝑚𝑖𝑛 {𝑒 (𝑈 )∣𝑈⊆𝑉 ,∣𝑈 ∣=𝑘 }

𝑒 (2k+1 )≥2𝑒 (𝑘 )+𝑘+1(𝑘<𝑛2 )

𝐶=𝑈 1∪𝑈 2

𝑈 1 ,𝑈 2

123

Other nodes

C

U2U1

v U

124

NEW=NEW1 NEW2 (axiom 2)

Other nodes

C

U2U1

v U

°

NEW1 NEW2

125

Axiom4: edge from C

Other nodes

C

U2U1

v U

NEW1 NEW2

126

Axiom4: edge from C

Other nodes

C

U2U1

v U

NEW1 NEW2

127

Axiom3: replace with unused edge

Other nodes

C

U2U1

v U

NEW1 NEW2

Unused edges between U1 and U2

128

Axiom3: replace with unused edge

Other nodes

C

U2U1

v U

NEW1 NEW2

Unused edges between U1 and U2

129

Axiom3: replace with unused edge

Other nodes

C

U2U1

v U

NEW1 NEW2

Unused edges between U1 and U2

130

Axiom3: replace with unused edge-at least k times

Other nodes

C

U2U1

v U

NEW1 NEW2

Unused edges between U1 and U2

131

Change C

Other nodes

C

U2U1

v

NEW1 NEW2

132

Change C- axiom 4+3

Other nodes

C

U2U1

v

NEW1 NEW2

133

Change C- axiom 4+3

Other nodes

C

U2U1

v

NEW1 NEW2

Unused edge

134

Change C- axiom 4+3

Other nodes

C

U2U1

v

NEW1 NEW2

135

Total at least: e(U1)+e(U2)+k+1

Other nodes

C

U2U1

v

NEW1 NEW2

136

● Let U be a disjoint union of and {v} such that |U1|=|U2|=k so e(U)=e(2k+1). Define Let NEW1,NEW2 be sequences in EX(A,G) of lengths e(U1),e(U2) inducing subgraphs G1,G2 that have one connected component with vertex set U1,U2 respectively (all other isolated). These two sequences do not interfere with each other and by axiom2 their concatenation NEW=NEW1 NEW2 is also in EX(A,G).

𝐶=𝑈 1∪𝑈 2

𝑈 1 ,𝑈 2

°

137

● C satisfies the assumptions of axiom 4 , each node in C has at least k unused edges, so there is an extension of NEW by a message (v',e) where v' in C. by axiom 3 we can change this with one of the unused edges. This process can be repeated until at least one vertex in C saturates all its edges to other vertexes in C. this requires at least k messages along previously unused edges.

● We change C to include now also {v} and from axiom 4+3 we will get an edge to v.

𝑒 (2k+1 )=𝑒 (𝑈 )≥𝑒 (𝑈 1 )+𝑒 (𝑈 2 )+𝑘+1≥2𝑒 (𝑘 )+𝑘+1

138

● So we have:

By induction we will show that for

𝑒 (2k+1 )≥2𝑒 (𝑘 )+𝑘+1

𝑛=2𝑖−1 ,𝑒 (1 )=0

𝑒 (𝑛 )≥ 𝑛+12log(𝑛+1

2 )¿

139

𝑏𝑎𝑠𝑖𝑠 : 𝑖=1 :𝑛=21−1=1

𝑒 (1 )=1≥ 22log (1 )=0

𝑎𝑠𝑠𝑢𝑚𝑒𝑡 h𝑒𝑐𝑜𝑟𝑟𝑒𝑡𝑛𝑒𝑠𝑠𝑜𝑓𝑛=2𝑖−1∧𝑠 h𝑜𝑤𝑓𝑜𝑟 2 (𝑖+1)−1

❑/2k+1=2𝑖+1−1𝑠𝑜𝑘=2𝑖−1𝑒 (2𝑖+1−1 )≥2𝑒 (2𝑖−1 )+2𝑖−1+1

≥2𝑒 (𝑛)+2𝑖≥2𝑛+12log𝑛+12

+2𝑖=¿2 ⋅ 2𝑖

2log

2𝑖

2+2𝑖=2𝑖 ⋅ log 2

𝑖

2+2𝑖=¿2𝑖 ⋅ log 2𝑖 −1+2𝑖=❑/2𝑖+1−1=𝑁

𝑁+12

log𝑁 +14

+𝑁 +14

=𝑁+12⋅ log 𝑁+1

2+ log 1

2+𝑁+1

4=¿𝑁 +1

2log𝑁+12

−𝑁−14

≥𝑁+12

log𝑁 +12

140

Conclusion

Theorem 2: Let A be a global algorithm acting on a complete graph G with n nodes. Then the message complexity m(A) is

If k nodes woke up we get

As we seen Humblet algorithm was therefore it reaches the lower bound.

Ω (𝑛 log𝑛)

Ω (𝑛 log𝑘 )

𝑂 (𝑛 log𝑘 )

141

142

T H A N K

YO

U