Distributed computing and networking 15th international conference

Specifically, for this case, we establish a tight bound of cn c2−1 for the rendezvous time, in case agents have sense of direction.. Any rendezvous algorithm in the white board model requ

15th International Conference, ICDCN 2014

Coimbatore, India, January 2014

Proceedings

Distributed Computing and Networking

Lecture Notes in Computer Science 8314

Commenced Publication in 1973

Founding and Former Series Editors:

Gerhard Goos, Juris Hartmanis, and Jan van Leeuwen

Mainak Chatterjee Jian-nong Cao

Kishore Kothapalli Sergio Rajsbaum (Eds.)

Distributed Computing and Networking

15th International Conference, ICDCN 2014

Coimbatore, India, January 4-7, 2014

Proceedings

1 3

Mainak Chatterjee

University of Central Florida

Dept of Electrical Engineering and Computer Science

P.O Box 162362, Orlando, FL 32816-2362, USA

Springer Heidelberg New York Dordrecht London

Library of Congress Control Number: 2013954779

CR Subject Classification (1998): C.2, D.1.3, D.2.12, C.2.4, D.4, F.2, F.1.2, H.4LNCS Sublibrary: SL 1 – Theoretical Computer Science and General Issues

© Springer-Verlag Berlin Heidelberg 2014

This work is subject to copyright All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed Exempted from this legal reservation are brief excerpts in connection with reviews or scholarly analysis or material supplied specifically for the purpose of being entered and executed on a computer system, for exclusive use by the purchaser of the work Duplication of this publication

or parts thereof is permitted only under the provisions of the Copyright Law of the Publisher’s location,

in ist current version, and permission for use must always be obtained from Springer Permissions for use may be obtained through RightsLink at the Copyright Clearance Center Violations are liable to prosecution under the respective Copyright Law.

The use of general descriptive names, registered names, trademarks, service marks, etc in this publication does not imply, even in the absence of a specific statement, that such names are exempt from the relevant protective laws and regulations and therefore free for general use.

While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made The publisher makes no warranty, express or implied, with respect to the material contained herein.

Typesetting: Camera-ready by author, data conversion by Scientific Publishing Services, Chennai, India

Printed on acid-free paper

Welcome to the 15th International Conference on Distributed Computing andNetworking (ICDCN 2014) The conference this year was hosted by Amrita Uni-versity on its scenic Coimbatore campus, following the tradition set by previousICDCN conferences held at reputed institutions including IITs, IIITs, TIFR,and Infosys.

ICDCN started 14 years ago as an international workshop and quickly emerged

as a premier conference devoted to the latest research results in distributed puting and networking The conference today attracts high-quality submissionsand top speakers from all over the world

com-An excellent technical program consisting of 32 full papers and eight shortpapers was put together thanks to the dedicated efforts of the program chairs,Sergio Rajsbaum and Kishore Kothapalli (Distributed Computing) and Jian-nong Cao and Mainak Chatterjee (Networking), and the Program Committeemembers We thank all the authors who submitted papers to the conference andall the reviewers for taking the time to provide thoughtful reviews Springer’scontinued support of ICDCN by publishing the main proceedings of the confer-ence is greatly appreciated

ICDCN 2014 featured a number of additional events, including keynote ers, panel discussion, workshops, tutorials, industry forum, and doctoral sympo-sium Rupak Biswas (NASA, Ames), Prasad Jayanti (Dartmouth College), andMisha Pavel (National Science Foundation, USA) gave the keynote talks.Thanks to the workshop chairs and their teams, four workshops on cutting-edge topics were planned:

speak-1 ComNet-IoT: Computing and Networking for Internet of Things

2 CoNeD: Complex Network Dynamics

3 VirtCC: Virtualization and Cloud Computing

4 SPBDA: Smarter Planet and Big Data Analytics

The workshops were held on the first day of the conference and were open

to all conference attendees This year ACM In-Cooperation status was solicitedfor the main conference as well as for each of the workshops, and the workshopproceedings are expected to appear in the ACM digital library

Sajal Das and Sukumar Ghosh, the Steering Commitee co-chairs, providedtheir guidance at every step of the planning process Their accumulated wisdomfrom steering the ICDCN conferences since inception was invaluable

Thanks to Amrita University’s vice-chancellor, Dr Venkat Rangan, for ing the conference, and to the organizing co-chairs, Prashant Nair and K Gan-gadharan, and their entire team at Amrita for excellent local arrangements Last

host-but not least, the generous support of the sponsors of the ICDCN conferenceand workshops is greatly appreciated.

On behalf of the entire ICDCN conference team, thanks to everyone whohelped make ICDCN 2014 a successful and memorable event

Dilip Krishnaswamy

It gives us great pleasure to present the proceedings of the 15th InternationalConference on Distributed Computing and Networking (ICDCN), which washeld during January 4–7, 2014, in Coimbatore, India Over the years, ICDCNhas grown as a leading forum for presenting state-of-the-art resrach in distributedcomputing and networking.

This year we received 110 submissions by authors from 26 countries To view these submissions and to create the technical program, a Technical ProgramCommittee (TPC) consisting of 57 experts in distributed computing and net-working was formed Eventually, 32 full papers and 8 short papers were selectedafter the review phase followed by the discussion phase All papers were reviewed

re-by at least three reviewers The help of additional reviewers was sought in somecases

Each track selected its best papers The selection was done by an adhoccommittee comprising four to five TPC members It is our pleasure to announcethat the Best Paper Award in the Distributed Computing Track was authored

by Varsha Dani, Valerie King, Mahnush Movahedi, and Jared Saia for the papertitled “Quorums Quicken Queries: Efficient Asynchronous Secure MultipartyComputation.” For the Networking track, the Best Paper was awarded to thepaper titled “InterCloud RAIDer: A Do It Yourself Multi-cloud Private DataBackup System” authored by Chih Wei Ling and Anwitaman Datta

Besides the technical sessions of ICDCN 2014, there were a number of otherevents including workshops, keynote speeches, tutorials, industry sessions, paneldiscussions, and a PhD forum

We thank all authors who submitted papers to ICDCN 2014 Compared

to previous years, we feel that the quality of the papers in terms of technicalnovelty was better We thank the Program Committee members and externalreviewers for their diligence and commitment, both during the reviewing processand during the online discussion phase We would also like to thank the generalchairs and the Organizing Committee members for their continuous support inmaking ICDCN 2014 a grand success

Jiannong CaoKishore KothapalliSergio Rajsbaum

ICDCN 2014 was organized by Amrita University, Coimbatore, India.

General Chairs

Program Chairs

Distributed Computing Track

Networking Track

SAR China

Doctoral Forum Chairs

Demo Chairs

Tutorial Chairs

Industry Track Chairs

Workshop Chairs

Nalini Venkatasubramanian University of California, Irvine, USA

Publicity Chairs

Advisory Board

Industry Track Chairs

Organizing Secretary

Steering Committee Co-chairs

Sanjoy Paul Accenture, India

Program Committee

Networking Track Program Committee

India

India

India

Dan Wang Hong Kong Polytechnic University, Hong Kong,

SAR ChinaNalini Venkatasubramanian University of California, Irvine, USA

Distributed Computing Track Program Committee

Germany

Sandeep HansWei-Lun Hung

Eleni KanellouMarcin KikKamil KluczniakYaron KoralAnissa LamaniI-Ting LeeErwan Le MerrerLukas Li

Xiapu LuoXiaoqiang MaAlex Matveev

Michal SzydelkoCorentin TraversVasileios Trigonakis

Prabhat UpadhyayWeichao WangShu YangYuan YangMarcin ZawadaMarek ZawirskiHang Zhao

Mutual Exclusion, Agreement, and Consensus

Fast Rendezvous on a Cycle by Agents with Different Speeds 1

Ofer Feinerman, Amos Korman, Shay Kutten, and Yoav Rodeh

Iterative Byzantine Vector Consensus in Incomplete Graphs 14

Nitin H Vaidya

Mutual Exclusion Algorithms in the Shared Queue Model 29

Junxing Wang and Zhengyu Wang

On the Signaling Problem 44

Gal Amram

Parallel and Multi-core Computing

Optimization of Execution Time under Power Consumption Constraints

in a Heterogeneous Parallel System with GPUs and CPUs 66

Pawel Czarnul and Pawel Ro´ sciszewski

Multicore Parallelization of the PTAS Dynamic Program

for the Bin-Packing Problem 81

Anirudh Chakravorty, Thomas George, and Yogish Sabharwal

Energy Accounting and Control with SLURM Resource and Job

Management System 96

Yiannis Georgiou, Thomas Cadeau, David Glesser, Danny Auble,

Morris Jette, and Matthieu Hautreux

Distributed Algorithms I

Asynchronous Reconfiguration for Paxos State Machines 119

Leander Jehl and Hein Meling

A Causal Checkpointing Algorithm for Mobile Computing

Environments 134

Astrid Kiehn, Pranav Raj, and Pushpendra Singh

Gathering and Exclusive Searching on Rings under Minimal

Assumptions 149

Gianlorenzo D’Angelo, Alfredo Navarra, and Nicolas Nisse

Online Algorithms to Generate Slices for Regular Temporal Logic

Predicates 165

Aravind Natarajan, Neeraj Mittal, and Vijay K Garg

Transactional Memory

HiperTM: High Performance, Fault-Tolerant Transactional Memory 181

Sachin Hirve, Roberto Palmieri, and Binoy Ravindran

Non-interference and Local Correctness in Transactional Memory 197

Petr Kuznetsov and Sathya Peri

A TimeStamp Based Multi-version STM Algorithm 212

Priyanka Kumar, Sathya Peri, and K Vidyasankar

Distributed Algorithms II

Optimized OR-Sets without Ordering Constraints 227

Madhavan Mukund, Gautham Shenoy R., and S.P Suresh

Quorums Quicken Queries: Efficient Asynchronous Secure Multiparty

Computation 242

Varsha Dani, Valerie King, Mahnush Movahedi, and Jared Saia

Conscious and Unconscious Counting on Anonymous Dynamic

Networks 257

Giuseppe Antonio Di Luna, Roberto Baldoni, Silvia Bonomi, and

Ioannis Chatzigiannakis

On Probabilistic Snap-Stabilization 272

Karine Altisen and St´ ephane Devismes

P2P and Distributed Networks

Backward-Compatible Cooperation of Heterogeneous P2P Systems 287

Hoang Giang Ngo, Luigi Liquori, and Chan Hung Nguyen

Towards a Peer-to-Peer Bandwidth Marketplace 302

Mihai Capot˘ a, Johan Pouwelse, and Dick Epema

A Fault Tolerant Parallel Computing Scheme of Scalar Multiplication

for Wireless Sensor Networks 317

Yanbo Shou and Herv´ e Guyennet

Conflict Resolution in Heterogeneous Co-allied MANET:

A Formal Approach 332

Soumya Maity and Soumya K Ghosh

Resource Sharing and Scheduling

Batch Method for Efficient Resource Sharing in Real-Time Multi-GPU

Systems 347

Uri Verner, Avi Mendelson, and Assaf Schuster

Impairment-Aware Dynamic Routing and Wavelength Assignment

in Translucent Optical WDM Networks 363

Sriharsha Varanasi, Subir Bandyopadhyay, and Arunita Jaekel

Mobility Aware Charge Scheduling of Electric Vehicles for Imbalance

Reduction in Smart Grid 378

Joy Chandra Mukherjee and Arobinda Gupta

Effective Scheduling to Tame Wireless Multi-Hop Forwarding 393

Chen Liu, Janelle Harms, and Mike H MacGregor

Cellular and Cognitive Radio Networks

Dynamic Gateway Selection for Load Balancing in LTE Networks 408

Sakshi Patni and Krishna M Sivalingam

Exploiting Scalable Video Coding for Content Aware Downlink Video

Delivery over LTE 423

Ahmed Ahmedin, Kartik Pandit, Dipak Ghosal, and Amitabha Ghosh

Stochastic Model for Cognitive Radio Networks under Jamming

Attacks and Honeypot-Based Prevention 438

Suman Bhunia, Xing Su, Shamik Sengupta, and Felisa V´ azquez-Abad

Backbone Networks

InterCloud RAIDer: A Do-It-Yourself Multi-cloud Private Data Backup

System 453

Chih Wei Ling and Anwitaman Datta

Improved Heterogeneous Human Walk Mobility Model with Hub

and Gateway Identification 469

Zunnun Narmawala and Sanjay Srivastava

FlowMaster: Early Eviction of Dead Flow on SDN Switches 484

Kalapriya Kannan and Subhasis Banerjee

Short Papers

A Simple Lightweight Encryption Scheme for Wireless Sensor

Networks 499

Kamanashis Biswas, Vallipuram Muthukkumarasamy,

Elankayer Sithirasenan, and Kalvinder Singh

Analyzing the Network Connectivity Probability of a Linear VANET

in Nakagami Fading Channels 505

Ninsi Mary Mathew and Neelakantan P.C.

Max-Min-Path Energy-Efficient Routing Algorithm – A Novel

Approach to Enhance Network Lifetime of MANETs 512

Vijayalakshmi Ponnuswamy, Sharmila Anand John Francis, and

Abraham Dinakaran J.

Towards a New Internetworking Architecture: A New Deployment

Approach for Information Centric Networks 519

Amine Abidi, Sonia Mettali Gammar, Farouk Kamoun,

Walid Dabbous, and Thierry Turletti

Energy-Efficient Multimedia Communication for Cognitive Radio

Networks 525

Ansuman Bhattacharya, Koushik Sinha, and Bhabani P Sinha

Stabilizing Dining with Failure Locality 1 532

Hyun Chul Chung, Srikanth Sastry, and Jennifer L Welch

Machine Learning in a Policy Driven Grid Environment 538

Kumar Dheenadayalan, Maulik Shah, Abhishek Badjatya, and

Biswadeep Chatterjee

Not So Synchronous RPC: RPC with Silent Synchrony Switch

for Avoiding Repeated Marshalling of Data 544

Fatema Tuz Zohora, Md Yusuf Sarwar Uddin, and

Johra Muhammad Moosa

Author Index 551

with Different Speeds

Ofer Feinerman1,, Amos Korman2,, Shay Kutten3,, and Yoav Rodeh4

1 The Shlomo and Michla Tomarin Career Development Chair,

Weizmann Institute of Science, Rehovot, Israel

2 CNRS and University Paris Diderot, Paris, France

3 Faculty of IR&M, Technion, Haifa 32000, Israel

4 Jerusalem College of Engineering

Abstract The difference between the speed of the actions of different

processes is typically considered as an obstacle that makes the ment of cooperative goals more difficult In this work, we aim to highlightpotentialbenefits of such asynchrony phenomena to tasks involving sym-

achieve-metry breaking Specifically, in this paper, identical (except for theirspeeds) mobile agents are placed at arbitrary locations on a (continuous)cycle of length n and use their speed difference in order to rendezvous

fast We normalize the speed of the slower agent to be 1, and fix thespeed of the faster agent to be somec > 1 (An agent does not know

whether it is the slower agent or the faster one.) The straightforward

distributed-race (DR) algorithm is the one in which both agents simply

start walking until rendezvous is achieved It is easy to show that, inthe worst case, the rendezvous time of DR isn/(c − 1) Note that in the

interesting case, wherec is very close to 1 (e.g., c = 1+1/n k), this bound

becomes huge Our first result is a lower bound showing that, up to amultiplicative factor of 2, this bound is unavoidable, even in a model thatallows agents to leave arbitrary marks (thewhite board model), even as-

suming sense of direction, and even assumingn and c are known to agents.

That is, we show that under such assumptions, the rendezvous time ofany algorithm is at least 2(c−1) n ifc  3 and slightly larger (specifically,

n

matches the lower bound for the casec  2, and almost matches it when

c > 2 Moreover, our algorithm performs under weaker assumptions than

those stated above, as it does not assume sense of direction, and it allowsagents to leave only a single mark (a pebble) and only at the place wherethey start the execution Finally, we investigate the setting in which nomarks can be used at all, and show tight bounds forc  2, and almost

tight bounds forc > 2.

Keywords: rendezvous, asynchrony, heterogeneity, speed, cycle, pebble,

white board, mobile agents

Supported by the Clore Foundation, the Israel Science Foundation (FIRST grant

no 1694/10) and the Minerva Foundation

 Supported by the ANR project DISPLEXITY, and by the INRIA project GANG.

Supported in part by the ISF and by the Technion TASP center.

M Chatterjee et al (Eds.): ICDCN 2014, LNCS 8314, pp 1–13, 2014.

c

 Springer-Verlag Berlin Heidelberg 2014

1 Introduction

The difference between the speed of the actions of different entities is typicallyconsidered disruptive in real computing systems In this paper, we illustrate

some advantages of such phenomena in cases where the difference remains fixed

throughout the execution1 We demonstrate the usefulness of this manifestation

of asynchrony to tasks involving symmetry breaking More specifically, we showhow two mobile agents, identical in every aspect save their speed, can lever theirspeed difference in order to achieve fast rendezvous

Symmetry breaking is a major issue in distributed computing that is pletely absent from traditional sequential computing Symmetry can often pre-vent different processes from reaching a common goal Well known examplesinclude leader election [3], mutual exclusion [14], agreement [4,25] and renaming[6] To address this issue, various differences between processes are exploited Forexample, solutions for leader election often rely on unique identifiers assumed

com-to be associated with each entity (e.g., a process) [3] Another example of adifference is the location of the entities in a network graph Entities located indifferent parts of a non-symmetric graph can use this knowledge in order tobehave differently; in such a case, a leader can be elected even without usingunique identifiers [26] If no differences exist, breaking symmetry deterministi-cally is often impossible (see, e.g., [3,27]) and one must resort to randomizedalgorithms, assuming that different entities can draw different random bits [19]

We consider mobile agents aiming to rendezvous See, e.g., [7,13,22,23,24,27]

As is the case with other symmetry breaking problems, it is well known that if theagents are completely identical then rendezvous is, in some cases, impossible Infact, a large portion of the research about rendezvous dealt with identifying theconditions under which rendezvous was possible, as a result of some asymetries.Here, the fact that agents have different speeds implies that the mere feasibility ofrendezvous is trivial, and our main concern is therefore the time complexity, that

is, the time to reach a rendezvous More specifically, we study the case where theagents are identical except for the fact that they have different speeds of motion.Moreover, to isolate the issue of the speed difference, we remove other possibledifferences between the agents For example, the agents, as well as the graphover which the agents walk, are assumed to be anonymous To avoid solutions

of the kind of [26], we consider a symmetric graph, that is, specifically, a cycletopology Further symmetry is obtained by hiding the graph features That is,

an agent views the graph as a continuous cycle of length n, and cannot even

distinguish between the state it is at a node and the state it is walking over anedge

1Advantages can also be exploited in cases where the difference in speed follows some

stochastic distribution, however, in this initial study, we focus on the simpler fullydeterministic case That is, we assume a speed heterogeneity that is arbitrary butfixed throughout the execution

1.2 The Model and the Problem

The problem of rendezvous on a cycle: Consider two identical deterministic agents placed on a cycle of length n (in some distance units) To ease the descrip- tion, we name these agents A and B but these names are not known to the agents.

Each agent is initially placed in some location on the cycle by an adversary andboth agents start the execution of the algorithm simultaneously An agent canmove on the cycle at any direction Specifically, at any given point in time, anagent can decide to either start moving, continue in the same direction, stop,

or change its direction The agents’ goal is to rendezvous, namely, to get to be

co-located somewhere on the cycle2 We consider continuous movement, so thisrendezvous can occur at any location along the cycle An agent can detect thepresence of another agent at its location and hence detect a rendezvous Whenagents detect a rendezvous, the rendezvous task is considered completed

Orientation issues: We distinguish between two models regarding orientation The first assumes that agents have the sense of direction [8], that is, we assume

that the agents can distinguish clockwise from the anti-clockwise In the secondmodel, we do not assume this orientation assumption Instead, each agent hasits own perception of which direction is clockwise and which is anti-clockwise,but there is no guarantee that these perceptions are globally consistent (Hence,e.g., in this model, if both agents start walking in their own clockwise direction,they may happen to walk in opposite directions, i.e., towards each other)

The pebble and the white board models: Although the agents do not hold any

direct means of communication, in some cases we do assume that an agent canleave marks in its current location on the cycle, to be read later by itself and by

the other agent In the pebble model, an agent can mark its location by dropping

a pebble [10,11] Both dropping and detecting a pebble are local acts takingplace only on the location occupied by the agent We note that in the case wherepebbles can be dropped, our upper bound employs agents that drop a pebbleonly once and only at their initial location [1,9,24] On the other hand, ourcorresponding lower bound holds for any mechanism of (local) pebble dropping

Moreover, this lower bound holds also for the seemingly stronger ’white board

model, in which an agent can change a memory associated with its currentlocation such that it could later be read and further manipulated by itself or theother agent [20,16,17]

Speed: Each agent moves at the same fixed speed at all times; the speed of

an agent A, denoted s(A), is the inverse of the time t α it takes agent A to

2In some sense, this rendezvous problem reminds also the cow-path problem, see,

e.g., [5] Here, the agents (the cow and the treasure she seeks to find) are bothmobile (in the cow-path problem only one agent, namely, the cow, is mobile) It wasshown in [5] that if the cow is initially located at distanceD from the treasure on

the infinite line then the time to find the treasure can be 9D, and that 9 is the best

multiplicative constant (up to lower order terms inD).

traverse one unit of length For agent B, the time t β and speed s(B) are defined analogously Without loss of generality, we assume that agent A is faster, i.e., s(A) > s(B) but emphasize that this is unknown to the agents themselves.

Furthermore, for simplicity of presentation, we normalize the speed of the slower

agent B to one, that is, s(B) = 1 and denote s(A) = c where c > 1 We stress that the more interesting cases are when c is a function of n and arbitrarily close

to 1 (e.g., c = 1 + 1/n k , for some constant k) We assume that each agent has

a pedometer that enables it to measure the distance it travels Specifically, a

(local) step of an agent is a movement of one unit of distance (not necessarily

all in the same direction, e.g., in one step, an agent can move half a step in onedirection and the other half in the other direction) Using the pedometer, agentscan count the number of steps they took (which is a real number at any given

time) In some cases, agents are assumed to posses some knowledge regarding n and c; whenever used, this assumption will be mentioned explicitly.

Time complexity: The rendezvous time of an algorithm is defined as the worst

case time bound until rendezvous, taken over all pairs of initial placements ofthe two agents on the cycle Note, a lower bound for the rendezvous time that isestablished assuming sense of direction holds trivially for the case where no sense

of direction is assumed All our lower bounds hold assuming sense of direction

The Distributed Race (DR) algorithm: Let us consider a trivial algorithm, called Distributed Race (DR), in which an agent starts moving in an arbitrary direction,

and continues to walk in that direction until reaching rendezvous Note that

this algorithm does not assume knowledge of n and c, does not assume sense

of direction and does not leave marks on the cycle The worst case for thisalgorithm is that both agents happen to walk on the same direction Without loss

of generality, assume this direction is clockwise Let d denote the the clockwise distance from the initial location of A to that of B The rendezvous time t thus satisfies t · s(A) = t · s(B) + d Hence, we obtain the following.

Observation 1 The rendezvous time of DR is d/(c − 1) < n/(c − 1).

Note that in the cases where c is very close to 1, e.g., c = 1 + 1/n k, for some

constant k, the bound on the rendezvous time of DR is very large.

Our first result is a lower bound showing that, up to a multiplicative mation factor of 2, the bound of DR mentioned in Observation 1 is unavoidable,even in the white board model, even assuming sense of direction, and even assum-

approxi-ing n and c are known to agents That is, we show that under such assumptions,

the rendezvous time of any algorithm is at least n

2(c−1) if c  3 and slightly

larger (specifically, c+1 n ) if c > 3 We then manage to construct an algorithm that matches the lower bound precisely for the case c  2, and almost matches

it when c > 2 Specifically, when c  2, our algorithm runs in time 2(c−1) n and

when c > 2, the rendezvous time is n/c (yielding a (2 −2c)-approximation when

2 < c  3, and a ( c+1 c )-approximation when c > 3) Moreover, our algorithm

performs under weaker assumptions than those stated above, as it does not sume sense of direction, and allows agents to leave only a single mark (a pebble)and only at the place where they start the execution

as-Finally, we investigate the setting in which no marks can be used at all, and

show tight bounds for c  2, and almost tight bounds for c > 2 Specifically, for

this case, we establish a tight bound of cn

c2−1 for the rendezvous time, in case

agents have sense of direction With the absence of sense of direction, the samelower bound of cn

c2−1 holds, and we obtain an algorithm matching this bound forthe case c  2, and rather efficient algorithms for the case c > 2 Specifically, the rendezvous time for the case c  2 is c2cn −1 , for the case 2 < c  3, the rendezvous

time is c+1 2n , and for the case c > 3, the rendezvous time is c−1 n

The following lower bound implies that DR is a 2-approximation algorithm, and

it becomes close to optimal when c goes to infinity.

Theorem 1 Any rendezvous algorithm in the white board model requires at least

2(c−1) , c+1 n } time, even assuming sense of direction and even assuming n and c are known to the agents.

Proof We assume that agents have sense of direction; hence, both agents start

walking at the same direction We first show that any algorithm in the whiteboard model requires 2(c−1) n time Consider the case that the adversary locates

the agents at symmetric locations of the cycle, i.e., they are at distance n/2 apart Now consider any algorithm used by the agents Let us fix any c  such

that 1 < c  < c, and define the (continuous) interval

I :=



 2(c − 1)



.

For every (real) i ∈ I, let us define the following (imaginary) scenario S i In

scenario S i , each agent executes the algorithm for i steps and terminates3 We

claim that for every i ∈ I, the situation at the end of scenario S i is completelysymmetric: that is, the white board at symmetric locations contain the sameinformation and the two agents are at symmetric locations We prove this claim

by induction The basis of the induction, the case i = 0, is immediate Let us assume that the claim holds for scenario S i , for (real) i ∈ I, and consider scenario Si+ , for any positive  such that  < n4(1− c 

c ) Our goal is to show that the claim holds for scenario S i+4

3We can think of this scenario as if each agent executes another algorithm B, in

which it simulates preciselyi steps of the original algorithm and then terminates.

4Note that for somei ∈ I and some  < n

4(1− c 

c), we may have thati +  /∈ I Our

proof will show that the claim for S i+ holds also in such cases However, since wewish to show that the claim holds forS j, wherej ∈ I, we are not really interested

in those cases, and are concerned only with the cases wherei +  ∈ I and i ∈ I.

Consider scenario S i+ During the time interval [0, i c), both agents perform

the same actions as they do in the corresponding time interval in scenario S i Let

a denote the location of agent A at time i/c Now, during the time period [ c i , i+ c ],

agent A performs some movement all of which is done at distance at most  from

a (during this movement it may write information at various locations it visits);

then, at time i+ c , agent A terminates.

Let us focus on agent B (in scenario S i+) during the time period [i c , i] We claim that during this time period, agent B is always at distance at least  from

a Indeed, as long as it is true that agent B is at distance at least  from a, it performs the same actions as it does in scenario S i (because it is unaware of

any action made by agent A in scenario S i+, during the time period [c i , i+ c ])

Therefore, if at some time t  ∈ [ i

c , i], agent B is (in scenario Si+) at distance less

than  from a then the same is true also for scenario S i However, in scenario S i,

by the induction hypothesis, agent B was at time i at ¯a, the symmetric location

of a, that is, at distance n/2 from a Thus, to get from a distance less than  from a to ¯a, agent B needs to travel a distance of n/2 − , which takes n/2 − 

time This is impossible since

 2c <

n

2 − , where the first inequality follows from the definition of I and the second follows from the definition of  It follows that during the time period from [ i

c , i), agent

B behaves (in scenario Si+) the same as it does in the corresponding time

period in scenario S i Therefore, according to the induction hypothesis, at the

corresponding i’th steps in scenario S i+ , agent B is at distance n/2 from where agent A is at its i’th step (recall, agent A is at a at its i’th step), and the cycle

configuration (including the white boards) is completely symmetric Now, since

 < n/4, during the time period [i, i + ], agent B is still at a distance more than

 from a and remains unaware of any action made by agent A, during the time

period [i c , i+ c ] (Similarly, agent A, during the time period [ c i , i+ c ], is unaware

of any action made by agent B during this time period.) Hence, at each time

i  ∈ [i, i + ], agent B takes the same action as agent A in the corresponding time i  /c This establishes the induction proof To sum up, we have just shown that for any i ∈ I, the cycle configuration at the end of scenario S iis completelysymmetric

Now assume by contradiction that the rendezvous time t is less than the claimed one, that is, t < 2(c−1) n At time t, both agents meet at some location

u Since t ∈ I, the above claim holds for St Hence, at time t/c, agent A is at ¯ u, the symmetric location of u Since rendezvous happened at time t, this means that agent A traveled from ¯ u to u (i.e., a distance of n/2) during the time period

[t

c , t] Therefore t(1 −1

c )c  n/2, contradicting the assumption that t < n

2(c−1).This establishes that any algorithm requires 2(c−1) n time

We now show the simpler part of the theorem, namely, that the rendezvoustime of any algorithm in the white board model is at least c+1 n Let us represent

the cycle as the reals modulo n, that is, we view the cycle as the continuous

collection of reals [0, n], where n coincides with 0 Assume that the starting point of agent A is 0 Consider the time period T = [0, c+1 n − ], for some small positive  In this time period, agent A moves a total length of less than c+1 nc.

Let r (and , correspondingly) be the furthest point from 0 on the cycle that A

reached while going clockwise (or anti-clockwise, correspondingly), during that

time period Note that there is a gap of length larger than n− c+1 nc =c+1 n between

 and r This gap corresponds to an arc not visited by agent A during this time period On the other hand, agent B walks a total distance of less than n

c+1during

the time period T Hence, the adversary can locate agent B initially at some point in the gap between r and , such that during the whole time period T , agent B remains in this gap This establishes the c+1 n time lower bound, andconcludes the proof of the theorem

Note that the assumptions of the pebble model are weaker than the white boardmodel Hence, in view of Theorem 1, the following theorem establishes a tight

bound for the case where c  2, a (2 −2c )-approximation for the case 2 < c  3, and a (c + 1)/c-approximation for the case c > 3.

Theorem 2 There exists an algorithm that in the pebble model whose

ren-dezvous time is max { n

2(c−1) , n c } Moreover, this algorithm does not assume sense

of direction, uses only one pebble and drops it only once: at the initial position of the agent The algorithm assumes that agents know n and whether or not c > 2 Proof Consider the following algorithm Each agent (1) leaves a pebble at its

initial position and then starts walking in an arbitrary direction while countingthe distance travelled If (2) an agent reaches a location with a pebble for the

first time and (3) the distance it walked is strictly less than τ := min{n/2, n/c},

then (4) the agent turns around and walks continuously in the other direction.First note that if both agents happen to start walking in opposite directions(due to lack of sense of direction), then they walk until they meet In this simple

case, their relative speed is c + 1, hence rendezvous happens in time at most n

c+1 < max{ 2(c−1) n , n c } For the remaining of the proof, we consider the case

that both agents start walking at the same direction, which is without loss of

generality, the clockwise direction Let d be the initial clockwise distance from

A to B Consider three cases.

1 d = τ

Here, no agent turns around In other words, they behave exactly as in

DR If d = n/2, Observation 1 implies that the rendezvous time is n

2(c−1)

Otherwise, c > 2 and d = n/c By Observation 1, the rendezvous is reached

earlier, specifically, by time c−1 d =c(c−1) n

2 d < τ

In this case, Agent A will reach B’s starting point v B , at time d/c, before

B reaches A’s starting point vA Moreover, agent B does not turn, since its

initial distance to A’s starting point is at least τ At time d/c, agent B is at distance d/c clockwise from v B By the algorithm, Agent A then turns and walks anti-clockwise The anti-clockwise distance from A to B is then n−d/c Their relative speed is c + 1 Hence, they will rendezvous in an additional

time of n−d/c 1+c , since no agent may turn around after time d/c Hence, the

total time for reaching rendezvous is at most

d/c + n − d/c

d + n

1 + c . This function is maximized when d = τ where it is τ +n 1+c Now, if c  2, we have τ = n/2 and the rendezvous time is therefore 2(1+c) 3n Since c  2, the

later bound is at most 2(c−1) n On the other hand, if c > 2, we have τ = n/c and the rendezvous time is n/c.

3 d > τ

In this case, A doesn’t turn when it hits B’s initial position Consider the

following sub-cases

(a) The agents meet before B reaches A’s initial position.

In this case, the rendezvous time (as in DR) is d/(c − 1) On the other hand, the rendezvous time is at most n − d since B did not reach A’s initial position So d/(c − 1)  n − d A simple calculation now implies that the rendezvous time d/(c − 1) is at most n/c.

(b) Agent B reaches A’s initial position before rendezvous.

In this case, Agent B walks for d  = n − d time to first reach A’s initial position We first claim that d  < τ One case is that c  2, and thus,

τ = n/2 Since d > τ , we have d  < n/2 = τ The other case is that

c > 2, so τ = n/c We claim that also in this case, we have d  < τ Otherwise, we would have had d   n/c, which would have meant that the faster agent A would have had, at least, n/c time before B reached the initial position of A So much time would have allowed it to cover the whole cycle This contradicts the assumption that B reached A’s initial

position before rendezvous This establishes the fact that, regardless of

the value of c, we have d  < τ This fact implies that when agent B reaches A’s initial position, it turns around and both agents go towards each other By the time B turns around, A has walked a distance of cd 

Hence, at that point in time, they are n − cd  apart This implies to thefollowing rendezvous time:

d +n − cd 

2n − d

1 + c . Now recall that we are in the case that agent B reaches A’s initial position before they rendezvous This implies that n−d < n/c Hence, the running

4 Rendezvous without Communication

In this section, we consider the case that agents cannot use are marks (e.g., bles) to mark their location More generally, the agents cannot communicate inany way (before rendezvous)

peb-Theorem 3 Consider the setting in which no communication is allowed, and

assume both n and c are known to the agents.

1 The rendezvous time of any algorithm is, at least, cn

c2−1 , even assuming sense

Proof Let us first show the first part of the theorem, namely, the lower bound.

the algorithm, that is, the maximum time (over all initial placements and all

cycles of length n) for the agents (executing this algorithm) to reach rendezvous.

Recall, in this part of the theorem, we assume that agents have sense of direction.Without loss of generality, we assume that the direction an agent starts walking

(in particular, h(v) = u).

For each time t ∈ [0, ˆt], let d(t) denote the clockwise distance between the location b t ∈ CB of the slower agent B at time t and the homologous location h(at)∈ CB of the location a t ∈ CA of the faster agent A at time t Note that d(t) is a real value in [0, n) Initially, we assume that all reals in [0, n) are colored white As time passes, we color the corresponding distances by black, that is, at every time t, we color the distance d(t) ∈ [0, n) by black Note that the size of

the set of black distances is monotonously non-decreasing with time

We first claim that, by time ˆt, the whole range [0, n) is colored black To prove

by contradiction, assume that there is a real d ∈ [0, n) that remains white Now, consider the execution on a single cycle of length n, where agent A is initially

placed at anti-clockwise distance d from agent B In such a case, rendezvous is

not reached by time ˆt, contrary to the assumption that it is This implies that the time T it takes until all reals in [0, n) are colored black in the imaginary scenario, is a lower bound on the rendezvous time, that is, T  ˆt It is left to analyze the time T

With time, the change in the distance d(t) has to follow two rules:

– R1 After one time unit, the distance can change by at most 1 + c (the sum

of the agents’ speeds)

– R2 At time x, the distance, in absolute value is, at most, x(c − 1).

To see why Rule R2 holds, recall that the programs of the agents are identical

Hence, if agent A is at some point a ∈ C A , at A’s kth step, then agent B is at point b = h(a) at its own kth step This happens for agent B at time k and for agent A at time k/c Since A’s speed is c, the maximum it can get away from point a during the time period from k/c until c is c(k − k/c) = k(c − 1) Consider the path P := d(t) covering the range [0, n) in T time First, note that this path P may go several times through the zero point (i.e., when d(t) = 0).

At a given time s, we say that the path is on the right side, if the last time it left the zero point before time s was while going towards 1 Similarly, the path

is on the left, if the last time it left the zero point before time s was while going towards n − 1 Let x denote the largest point on the range [0, n) reached by the path while the path was on the right side Let y = n − x By time T , path P had to go left to distance y from the zero point Assume, w.l.o.g that x < y (In particular, x may be zero.) The fastest way to color these two points (and all

the rest of the points, since those lie between them), would be to go from zero

to the right till reaching x, then return to zero and go to distance y on the left Hence, T will be at least: T  c−1 x +c+1 n Indeed, Rule R2, applied to the time

of reaching distance x, implies the first term above The second term uses Rule R1 to capture the time that starts with the distance reaching x, proceeds with the distance reaching the zero point and ends when the distance reaches y when going left Since c > 1, we obtain

On the other hand, applying Rule R2 to the final destination y, we have T (c −

1) y = n − x This implies that:

Combining Equations 1 and 2, we get T  c2cn −1 This establishes the first part of

the theorem We now prove the second and third parts of the theorem, namely,the upper bounds

Proof of Parts 2 and 3: Note that the DR algorithm does not assume sense

of direction, and its complexity is the one required by the third part of the

theorem for the case c > 3 We now revise DR and consider an algorithm, called

Turn(k), which consists of two stages At the first stage, the agent walks over its

own clockwise direction for k steps Subsequently (if rendezvous hasn’t occurred

yet), the agent executes the second stage of the algorithm: it turns around andgoes in the other direction until rendezvous

Let us now concentrate on proving the second part of the theorem, and

as-sume that agents have sense of direction Here we consider Algorithm Turn(k),

c2−1 Since we assume sense of direction, both agents walk

initially in the same direction (clockwise) Assume by contradiction that

ren-dezvous hasn’t occurred by time k By that time, agent B took k steps Agent

A took those k steps by time k/c At that time, agent A turns (However, agent

B will turn only at time k) Hence, between those two turning times, there is a time duration k(1 −1c) where the two agents walk towards each other Hence,

at each time unit they shorten the distance between them by 1 + c Let d 

de-note the maximum distance between the agents at time k/c It follows that

d  > k(1 −1c )(1 + c) = n A contradiction This establishes the second part of

the theorem

We now prove the third part of the theorem, which focuses on the case where

no sense of direction is assumed Let us first consider the case c  2 Here we

apply the same algorithm above, namely Algorithm Turn(k), with parameter

k = c2cn −1 As proved before, if the two agents happen to start at the same

direction then rendezvous occurs by time c2cn −1 Hence, let us consider the case

that both agents walk initially at opposite directions Assume by contradiction,

that rendezvous hasn’t occurred by time k/c In this case, by time k/c the faster agent A walked k steps toward B, and the slower agent B walked k/c steps towards A Hence, the initial distance between them must be greater than k(1 + 1/c) = n/(c − 1) > n, a contradiction This proves the first item in Part 3

of the Theorem

Note that Algorithm DR establishes the third item in Part 3 of the Theorem

Hence, it is left to prove the second item in Part 3, namely, the case 2 < c  3.

For this case, we apply Algorithm Turn(k), with parameter k = c+1 cn First note,

if the two agents happen to start walking towards each other they continue to

do that until time k/c = c+1 n , hence they would meet by this time Therefor, wemay assume that initially, both agents start in the same direction In this case, if

rendezvous haven’t occurred by time k/c, then at this time agent A turns around, and both agents walk towards each other for at least k(1 − 1/c) more time (the time when agent B is supposed to turn) Since c > 2, we have k(1 − 1/c) > k/c, and hence, from the time agent A turns, both agents walk towards each other

We show how some form of asynchrony could be useful for solving a symmetrybreaking problem efficiently Our study could be considered as a first attempt

to harness the (unknown) heterogeneity between individuals in a cooperativepopulation towards more efficient functionality

There are many natural ways of further exploring this idea in future work.First, we have studied the exploitation of asynchrony for a specific kind of prob-lems It seems that it can be useful for other symmetry breaking problems as well.Another generalization: the “level” of asynchrony considered in this paper is very

limited: the ratio c between the speeds of the agents is the same throughout the

execution, and is known to the agents Exploiting a higher level of asynchronyshould also be studied, for example, the case that the speed difference is stochas-tic and changes through time

Our main interest was the exploitation of asymmetry, rather than the specificproblem of rendezvous Still, even for the rendezvous problem, this current studyleaves many open questions First, even for the limited case we study, not all ourbounds are completely tight, and it would be interesting to close the remaininggaps between our lower and upper bounds (these gaps hold for some cases when

c > 2) In addition, it would be interesting to study further the uniform case [21],

in which n and c are not known to agents Another direction is to generalize the

study to multiple agents (more than two, see, e.g., [15,18]) and to other graphclasses This would also allow one to study interactions between various means

of breaking symmetry (such as different speeds together with different locations

Asyn-5 Baeza-Yates, R.A., Culberson, J.C., Rawlins, G.J.E.: Searching in the plane form and Comput 106(2), 234–252 (1993)

In-6 Attiya, H., Bar-Noy, A., Dolev, D., Peleg, D., Reischuk, R.: Renaming in an chronous environment Journal of the ACM 37(3), 524–548 (1990)

asyn-7 Bampas, E., Czyzowicz, J., Gasieniec, L., Ilcinkas, D., Labourel, A.: Almost Op-timal Asynchronous Rendezvous in Infinite Multidimensional Grids In: Lynch,N.A., Shvartsman, A.A (eds.) DISC 2010 LNCS, vol 6343, pp 297–311 Springer,Heidelberg (2010)

8 Barri´ere, L., Flocchini, P., Fraigniaud, P., Santoro, N.: Rendezvous and Election ofMobile Agents: Impact of Sense of Direction Theory Comput Syst 40(2), 143–162(2007)

9 Baston, V., Gal, S.: Rendezvous search when marks are left at the starting points.Naval Research Logistics 48(8), 722–731 (2001)

10 Bender, M.A., Fernandez, A., Ron, D., Sahai, A., Vadhan, S.: The power of apebble: Exploring and mapping directed graphs In: Proc 30th ACM Symp onTheory of Computing (STOC), pp 269–287 (1998)

11 Blum, M., Kozen, D.: On the power of the compass (or, why mazes are easier tosearch than graphs) In: 19th Annual Symposium on Foundations of ComputerScience (FOCS 1978), October 16-18 (1978)

12 Czyzowicz, J., Dobrev, S., Krizanc, D., Kranakis, E.: The Power of Tokens: dezvous and Symmetry Detection for Two Mobile Agents in a Ring In: Geffert, V.,Karhum¨aki, J., Bertoni, A., Preneel, B., N´avrat, P., Bielikov´a, M (eds.) SOFSEM

Ren-2008 LNCS, vol 4910, pp 234–246 Springer, Heidelberg (2008)

13 Czyzowicz, J., Ilcinkas, D., Labourel, A., Pelc, A.: Asynchronous deterministicrendezvous in bounded terrains Theor Comput Sci 412(50), 6926–6937 (2011)

14 Dijkstra, E.W.: Self-stabilizing systems in spite of distributed control cations of the ACM 17(11), 643–644 (1974)

Communi-15 Dobrev, S., Flocchini, P., Prencipe, G., Santoro, N.: Multiple Agents RendezVous in

a Ring in Spite of a Black Hole In: Papatriantafilou, M., Hunel, P (eds.) OPODIS

2003 LNCS, vol 3144, pp 34–46 Springer, Heidelberg (2004)

16 Flocchini, P., Nayak, A., Schulz, A.: Cleaning an Arbitrary Regular Networkwith Mobile Agents In: Chakraborty, G (ed.) ICDCIT 2005 LNCS, vol 3816,

19 Itai, A., Rodeh, M.: Symmetry Breaking in Distributive Networks In: FOCS, pp.150–158 (1981)

20 Korach, E., Kutten, S., Moran, S.: A Modular Technique for the Design of EfficientDistributed Leader Finding Algorithms In: ACM PODC 1985, pp 163–174 (1985)

21 Korman, A., Sereni, J.-S., Viennot, L.: Toward More Localized Local Algorithms:Removing Assumptions Concerning Global Knowledge In: ACM PODC 2011, pp.49–58 (2011)

22 Kranakis, E., Krizanc, D., Markou, E.: The Mobile Agent Rendezvous Problem inthe Ring Morgan & Claypool Publishers (2010)

23 Kranakis, E., Krizanc, D., Rajsbaum, S.: Mobile Agent Rendezvous: A Survey.In: Flocchini, P., Gasieniec, L (eds.) SIROCCO 2006 LNCS, vol 4056, pp 1–9.Springer, Heidelberg (2006)

24 Kranakis, E., Santoro, N., Sawchuk, C.: Mobile Agent Rendezvous in a Ring In:ICDCS 2003, pp 592–599 (2003)

25 Suzuki, I., Yamashita, M.: Distributed Anonymous Mobile Robots: Formation ofGeometric Patterns SIAM J Computing 28(4), 1347–1363 (1999)

26 Yamashita, M., Kameda, T.: Computing on an Anonymous Network In: ACMPODC 1988, pp 117–130 (1988)

27 Yu, X., Yung, M.: Agent Rendezvous: A Dynamic Symmetry-Breaking Problem.In: Meyer auf der Heide, F., Monien, B (eds.) ICALP 1996 LNCS, vol 1099,

pp 610–621 Springer, Heidelberg (1996)

in Incomplete Graphs

Nitin H VaidyaDepartment of Electrical and Computer Engineering,

University of Illinois at Urbana-Champaign

nhv@illinois.edu

Abstract This work addresses Byzantine vector consensus, wherein the

input at each process is a d-dimensional vector of reals, and each cess is required to decide on a decision vector that is in the convex hull

pro-of the input vectors at the fault-free processes [9,12] The input vector

at each process may also be viewed as a point in the d-dimensional

Eu-clidean space Rd , where d > 0 is a finite integer Recent work [9,12] has

addressed Byzantine vector consensus, and presented algorithms with timal fault tolerance in complete graphs This paper considers Byzantine

op-vector consensus in incomplete graphs using a restricted class of iterative

algorithms that maintain only a small amount of memory across tions For such algorithms, we prove a necessary condition, and a suffi-cient condition, for the graphs to be able to solve the vector consensusproblem iteratively We present an iterative Byzantine vector consensusalgorithm, and prove it correct under the sufficient condition The nec-essary condition presented in this paper for vector consensus does not

itera-match with the sufficient condition for d > 1; thus, a weaker condition

may potentially suffice for Byzantine vector consensus

This work addresses Byzantine vector consensus (BVC), wherein the input at each process is a d-dimensional vector consisting of d real numbers, and each process is required to decide on a decision vector that is in the convex hull of the input vectors at the fault-free processes [9,12] The input vector at each process

may also be viewed as a point in the d-dimensional Euclidean space R d, where

d > 0 is a finite integer Due to this correspondence, we use the terms point and vector interchangeably Recent work [9,12] has addressed Byzantine vector

consensus, and presented algorithms with optimal fault tolerance in completegraphs The correctness conditions for Byzantine vector consensus (elaboratedbelow) cannot be satisfied by independently performing consensus on each ele-ment of the input vectors; therefore, new algorithms are necessary [9,12]

In this paper, we consider Byzantine vector consensus in incomplete graphs

us-ing a restricted class of iterative algorithms that maintain only a small amount

of memory across iterations We prove a necessary condition, and a sufficientcondition, for the graphs to be able to solve the vector consensus problem using

M Chatterjee et al (Eds.): ICDCN 2014, LNCS 8314, pp 14–28, 2014.

c

 Springer-Verlag Berlin Heidelberg 2014

such restricted algorithms We present an iterative Byzantine vector consensusalgorithm, and prove it correct under the sufficient condition; our proof of cor-rectness follows a structure previously used in our work to prove correctness ofother consensus algorithms [11,14] The use of matrix analysis tools in our proofs

is inspired by the prior work on non-fault tolerant consensus (e.g., [6]) For lack

of space, the proofs of most claims in the paper are omitted here Further detailscan be found in [15] The necessary condition presented in this paper for vec-

tor consensus does not match with the sufficient condition for d > 1; thus, it is

possible that a weaker condition may also suffice for Byzantine vector consensus

This paper extends our past work on scalar consensus (i.e., consensus with

scalar inputs) in incomplete graphs in presence of Byzantine faults [13], ing similarly restricted iterative algorithms The work in [13] yielded an exactcharacterization of graphs in which the scalar Byzantine consensus problem issolvable

us-Related Work: Approximate consensus has been previously explored in

syn-chronous as well as asynsyn-chronous systems Dolev et al [3] were the first toconsider approximate consensus in presence of Byzantine faults in asynchronoussystems Subsequently, for complete graphs, Abraham, Amit and Dolev [1] estab-lished that approximate Byzantine consensus is possible in asynchronous systems

if n ≥ 3f +1 Other algorithms for approximate consensus in presence of

Byzan-tine faults have also been proposed (e.g., [4]) Scalar consensus in incomplete

graphs under a malicious fault model in which the faulty nodes are restricted

to sending identical messages to their neighbors has also been explored by otherresearchers (e.g., [7,8])

The paper is organized as follows Section 2 presents our system model Theiterative algorithm structure considered in our work is presented in Section 3.Section 4 presents a necessary condition, and Section 5 presents a sufficient con-dition Section 5 also presents an iterative algorithm and proves its correctnessunder the sufficient condition The paper concludes with a summary in Section 6

The system is assumed to be synchronous.1The communication network is

mod-eled as a simple directed graph G( V, E), where V = {1, , n} is the set of n

processes, andE is the set of directed edges between the processes in V Thus,

|V| = n We assume that n ≥ 2, since the consensus problem for n = 1 is trivial Process i can reliably transmit messages to process j, j = i, if and only if the directed edge (i, j) is in E Each process can send messages to itself as well,

however, for convenience of presentation, we exclude self-loops from setE That

is, (i, i) ∈ E for i ∈ V We will use the terms edge and link interchangeably For each process i, let N −

i be the set of processes from which i has incoming edges That is, N −

i ={ j | (j, i) ∈ E } Similarly, define N+

i as the set of processes

to which process i has outgoing edges That is, N i+ = { j | (i, j) ∈ E } Since

1 Analogous results can be similarly derived for asynchronous systems, using the

asyn-chronous algorithm structure presented in [13] for the case of d = 1.

we exclude self-loops fromE, i ∈ N −

tentially collaborate with each other Moreover, the faulty processes are assumed

to have a complete knowledge of the execution of the algorithm, including thestates of all the processes, contents of messages the other processes send to eachother, the algorithm specification, and the network topology

We use the notation |X| to denote the size of a set or a multiset, and the

notationx to denote the absolute value of a real number x.

Byzantine vector consensus: We are interested in iterative algorithms that satisfy the following conditions in presence of up to f Byzantine faulty processes:

– Termination: Each fault-free process must terminate after a finite number

of iterations

– Validity: The state of each fault-free process at the end of each iteration

must be in the convex hull of the d-dimensional input vectors at the

fault-free processes

– -Agreement: When the algorithm terminates, the l-th elements of the

deci-sion vectors at any two fault-free processes, where 1≤ l ≤ d, must be within

 of each other, where  > 0 is a pre-defined constant.

Any information carried over by a process from iteration t to iteration t + 1 is considered the state of process t at the end of iteration t The above validity

condition forces the algorithms to maintain “minimal” state, for instance, cluding the possibility of remembering messages received in several of the pastiterations, or remembering the history of detected misbehavior of the neighbors

pre-We focus on such restricted algorithms with the iterative structure below

Iterative structure: Each process i maintains a state variable vi, which is a

d-dimensional vector The initial state of process i is denoted as vi[0], and it

equals the input provided to process i For t ≥ 1, vi [t] denotes the state of process i at the end of the t-th iteration of the algorithm At the start of the t-th iteration (t ≥ 1), the state of process i is vi [t − 1] The iterative algorithms

of interest will require each process i to perform the following three steps in the t-th iteration Each “value” referred in the algorithm below is a d-dimensional vector (or, equivalently, a point in the d-dimensional Euclidean space).

1 Transmit step: Transmit current state, namely v i [t −1], on all outgoing edges

3 Update step: Process i updates its state using a transition function T i as

follows T i is a part of the specification of the algorithm, and takes as input

the multiset r i [t] and state v i [t − 1].

The decision (or output) of each process equals its state when the algorithmterminates

We assume that each element of the input vector at each fault-free process

is lower bounded by a constant μ and upper bounded by a constant U The

iterative algorithm may terminate after a number of rounds that is a function of

μ and U μ and U are assumed to be known a priori This assumption holds in

many practical systems, because the input vector elements represent quantitiesthat are constrained For instance, if the input vectors represent locations in

3-dimensional space occupied by mobile robots, then U and μ are determined

by the boundary of the region in which the robots are allowed to operate [12]

In Section 4, we develop a necessary condition that the graph G( V, E) must

satisfy in order for the Byzantine vector consensus algorithm to be solvable usingthe above iterative structure In Section 5, we develop a sufficient condition, suchthat the Byzantine vector consensus algorithm is solvable using the above itera-tive structure in any graph that satisfies this condition We present an iterativealgorithm, and prove its correctness under the sufficient condition

Hereafter, when we say that an algorithm solves Byzantine vector consensus, we

mean that the algorithm satisfies the termination, validity and -agreement

con-ditions stated above Thus, the state the algorithm can carry across iterations isrestricted by the above validity condition Also, hereafter when we refer to an iter-ative algorithm, we mean an algorithm with the structure specified in the previous

section In this section, we state a necessary condition on graph G( V, E) to be able

to solve Byzantine vector consensus First we present three definitions

Definition 1

e0 corresponds to the origin in the d-dimensional Euclidean space.

to 2, and the remaining elements equal to 0 Recall that  is the parameter

of the -agreement condition.

Definition 2 For empty disjoint sets of processes A and B, and a

Definition 3. H(X) denotes the convex hull of a multiset of points X.

Now we state the necessary condition

Condition NC: For any partition V0, V1, · · · , Vp, C, F of set V, where 1 ≤ p ≤ d,

Vk = ∅ for 0 ≤ k ≤ p, and |F | ≤ f, there exist i, j (0 ≤ i, j ≤ p, i = j), such that

V i ∪ C −→ Vj f That is, there are f + 1 incoming links from processes in Vi ∪ C to some process

in Vj.

The proof of the necessary condition below extends the proofs of necessaryconditions in [9,12,13]

Lemma 1 If the Byzantine vector consensus problem can be solved using an

iterative algorithm in G( V, E), then G(V, E) satisfies Condition NC.

Proof The proof is by contradiction Suppose that Condition NC is not true Then there exists a certain partition V0, V1, · · · , Vp, C, F such that Vk = ∅ (1 ≤

k ≤ p), |F | ≤ f, and for 0 ≤ i, k ≤ p, Vk ∪ C  −→ Vi f

Let the initial state of each process in V i be ei (0≤ i ≤ p) Suppose that all the processes in set F are faulty For each link (j, k) such that j ∈ F and k ∈ Vi

(0≤ i ≤ p), the faulty process j sends value ei to process j in each iteration.

We now prove by induction that if the iterative algorithm satisfies the validity

condition then the state of each fault-free process j ∈ Vi at the start of iteration

t equals ei , for all t > 0 The claim is true for t = 1 by assumption on the inputs

at the fault-free processes Now suppose that the claim is true through iteration

t, and prove it for iteration t + 1 Thus, the state of each fault-free process in Vi

at the start of iteration t equals e i, 0≤ i ≤ p.

Consider any fault-free process j ∈ Vi, where 0≤ i ≤ p In iteration t, process

j will receive vg [t − 1] from each fault-free incoming neighbor g, and receive

ei from each faulty incoming neighbor These received values form the multiset

rj [t] Since the condition in the lemma is assumed to be false, for any k = i,

−→ Vi,|Ak| ≤ f; therefore, all the processes in

Ak are potentially faulty Also, by assumption, the values received from all

fault-free processes equal their input, and the values received from faulty processes

in F equal e i Thus, due to the validity condition, process j must choose as its

new state a value that is in the convex hull of the set

Sk={em | m = k, 0 ≤ m ≤ p}.

where k = i Since this observation is true for each k = i, it follows that the new

state vj [t] must be a point in the convex hull of

∩1≤k≤p, k=i H(Sk ).

It is easy to verify that the above intersection only contains the point ei

There-fore, vj [t] = e i Thus, the state of process j at the start of iteration t + 1 equals

ei This concludes the induction

The above result implies that the state of each fault-free process remainsunchanged through the iterations Thus, the state of any two fault-free processes

The above lemma demonstrates the necessity of Condition NC Necessary

con-dition NC implies a lower bound on the number of processes n = |V| in G(V, E),

as stated in the next lemma

Lemma 2 Suppose that the Byzantine vector consensus problem can be solved

using an iterative algorithm in G( V, E) Then, n ≥ (d + 2)f + 1.

Proof Since the Byzantine vector consensus problem can be solved using an iterative algorithm in G( V, E), by Lemma 1, graph G must satisfy Condition

NC Suppose that 2≤ |V| = n ≤ (d + 2)f Then there exists p, 1 ≤ p ≤ d, such

that we can partitionV into sets V0, , Vp, F such that for each Vi , 0 < |Vi| ≤ f,

and|F | ≤ f Define C = ∅ Since |C ∪ Vi| ≤ f for each i, it is clear that this

When d = 1, the input at each process is a scalar For the d = 1 case, our

prior work [13] yielded a tight necessary and sufficient condition for Byzantine

consensus to be achievable in G( V, E) using iterative algorithms For d = 1, the

necessary condition stated in Lemma 1 is equivalent to the necessary condition in

[13] We previously showed that, for d = 1, the same condition is also sufficient [13] However, in general, for d > 1, Condition NC is not proved sufficient.

Instead, we prove the sufficiency of another condition stated in the next section

We now present Condition SC that is later proved to be sufficient for

achiev-ing Byzantine vector consensus in graph G( V, E) using an iterative algorithm.

Condition SC is a generalization of the sufficient condition presented in [13] for

Later in the paper we will present a Byzantine vector consensus algorithmnamed Byz-Iter that is proved correct in all graphs that saitsfy Condition SC.The proof makes use of Lemmas 3 and 4 presented below.

of each process in V must be at least (d + 1)f + 1 That is, for each i ∈ V,

that |F| ≤ f, a graph H(V F , E F ) is said to be a reduced graph, if: (i) V F=V−F, and (ii) E F is obtained by first removing from E all the links incident on the processes in F, and then removing up to df additional incoming links at each process in V F

Note that for a given G( V, E) and a given F, multiple reduced graphs may exist

(depending on the choice of the links removed at each process)

that |F| ≤ f Then, in any reduced graph H(VF , EF ), there exists a process that has a directed path to all the remaining processes in VF

The proof of Lemma 4 is omitted for lack of space This proof, and the otheromitted proofs in the paper, are presented in [15]

We prove that, if graph G( V, E) satisfies Condition SC, then Algorithm Byz-Iter

presented below achieves Byzantine vector consensus Algorithm Byz-Iter hasthe three-step structure described in Section 3

The proposed algorithm is based on the following result by Tverberg [10]

multiset Y containing at least (d + 1)f + 1 points in R d , there exists a partition

Y1, · · · , Yf +1 of Y into f + 1 non-empty multisets such that ∩ f +1 H(Yl)= ∅.

The points in Y above need not be distinct [10]; thus, the same point may occur multiple times in Y , and also in each of its subsets (Y l’s) above The partition

in Theorem 1 is called a Tverberg partition, and the points in ∩ f +1

l=1 H(Yl) inTheorem 1 are called Tverberg points

Algorithm Byz-Iter

Each iteration consists of three steps: Transmit, Receive, and Update:

1 Transmit step: Transmit current state v i [t − 1] on all outgoing edges.

2 Receive step: Receive values on all incoming edges These values form multiset r i [t] of size |N −

i | (If a message is not received from some

in-coming neighbor, then that neighbor must be faulty In this case, the

missing message value is assumed to be e0 by default Recall that we

assume a synchronous system.)

3 Update step: Form a multiset Z i [t] using the steps below:

C ⊆ ri [t] such that |C| = (d + 1)f + 1 Since |C| = (d + 1)f + 1, by

Theorem 1, such a Tverberg point exists

Z i [t] is a multiset; thus a single point may appear in Z i [t] more than

once Note that|Zi [t] | =  |r i [t] |

vi [t] as:

vi [t] = vi [t − 1] +z∈Z i [t] z

iter-ations, where t endis a constant defined later in Equation (10) The value of

tend depends on graph G( V, E), constants U and μ defined earlier in Section

3 and parameter  of -agreement.

The proof of correctness of Algorithm Byz-Iter makes use of a matrix resentation of the algorithm’s behavior Before presenting the matrix represen-tation, we introduce some notations and definitions related to matrices

We use boldface letters to denote matrices, rows of matrices, and their elements

For instance, A denotes a matrix, Ai denotes the i-th row of matrix A, and A ij

denotes the element at the intersection of the i-th row and the j-th column of

matrix A.

Definition 5 A vector is said to be stochastic if all its elements are

non-negative, and the elements add up to 1 A matrix is said to be row stochastic if each row of the matrix is a stochastic vector.

For matrix products, we adopt the “backward” product convention below, where

a ≤ b,

For a row stochastic matrix A, coefficients of ergodicity δ(A) and λ(A) are

Lemma 6 If all the elements in any one column of matrix A are lower bounded

by a constant γ, then λ(A) ≤ 1 − γ That is, if ∃g, such that Aig ≥ γ, ∀i, then

λ(A) ≤ 1 − γ.

LetF denote the actual set of faulty processes in a given execution of Algorithm

Byz-Iter Let |F| = ψ Thus, 0 ≤ ψ ≤ f Without loss of generality, suppose that processes 1 through (n −ψ) are fault-free, and if ψ > 0, processes (n−ψ+1) through n are faulty.

In the analysis below, it is convenient to view the state of each process as a

point in the d-dimensional Euclidean space Denote by v[0] the column vector

consisting of the initial states of the (n −ψ) fault-free processes The i-th element

of v[0] is vi [0], the initial state of process i Thus, v[0] is a vector consisting of

(n − ψ) points in the d-dimensional Euclidean space Denote by v[t], for t ≥ 1,

the column vector consisting of the states of the (n − ψ) fault-free processes at

the end of the t-th iteration The i-th element of vector v[t] is state v i [t].

Lemma 7 below states the key result that helps in proving the correctness ofAlgorithm Byz-Iter In particular, Lemma 7 allows us to use results for non-homogeneous Markov chains to prove the correctness of Algorithm Byz-Iter

updates performed by the fault-free processes in the t-th iteration (t ≥ 1) of Algorithm Byz-Iter can be expressed as

where M[t] is a (n −ψ)×(n−ψ) row stochastic matrix with the following property: there exists a reduced graph H[t], and a constant β (0 < β ≤ 1) that depends only on graph G( V, E), such that

if j = i or edge (j, i) is in H[t].

The proof is presented in [15]

Matrix M[t] above is said to be a transition matrix As the lemma states, M[t]

is a row stochastic matrix The proof of Lemma 7 shows how to identify a suitable

row stochastic matrix M[t] for each iteration t The matrix M[t] depends on t,

as well as the behavior of the faulty processes Mi [t] is the i-th row of transition

matrix M[t] Thus, (4) implies that

vi [t] = M i [t] v[t − 1]

That is, the state of any fault-free process i at the end of iteration t can be

expressed as a convex combination of the state of just the fault-free processes at

the end of iteration t −1 Recall that vector v only includes the state of fault-free

processes

Theorem 2 Algorithm Byz-Iter satisfies the termination, validity and

-agreement conditions.

Proof This proof follows a structure used to prove correctness of other

con-sensus algorithms in our prior work [14,11] Sections 5.4, 5.5 and 5.6 providethe proof that Algorithm Byz-Iter satisfies the three conditions for Byzantinevector consensus, and thus prove Theorem 2

Observe that M[t + 1] (M[t]v[t − 1]) = (M[t + 1]M[t]) v[t − 1] Therefore, by

repeated application of (4), we obtain for t ≥ 1,

stochastic matrix Recall that vector v only includes the state of fault-free

pro-cesses Thus, (5) implies that the state of each fault-free process i at the end of iteration t can be expressed as a convex combination of the initial state of the

fault-free processes Therefore, the validity condition is satisfied

Algorithm Byz-Iter stops after a finite number (t end ) of iterations, where t end

is a constant that depends only on G( V, E), U, μ and  Therefore, trivially,

the algorithm satisfies the termination condition Later, using (10) we define a

suitable value for t

5.6 Algorithm Byz-Iter Satisfies the -Agreement Condition

The proof structure below is derived from our previous work [14] wherein we

proved the correctness of an iterative algorithm for scalar Byzantine consensus (i.e., the case of d = 1), and its generalization to a broader class of fault sets

r depends only on G( V, E) and f, and it is finite Note that |RF| ≤ r.

For each reduced graph H ∈ RF, define connectivity matrix H as follows,

where 1≤ i, j ≤ n − ψ:

– Hij = 1 if either j = i, or edge (j, i) exists in reduced graph H.

– Hij = 0, otherwise

Thus, the non-zero elements of row Hi correspond to the incoming links at

process i in the reduced graph H, and the self-loop at process i Observe that

H has a non-zero diagonal.

least one non-zero column (i.e., a column with all elements non-zero).

Proof Each reduced graph contains n − ψ processes because the fault set F contain ψ processes By Lemma 4, at least one process in the reduced graph, say process p, has directed paths to all the processes in the reduced graph H.

Element Hk jp of matrix product Hk is 1 if and only if process p has a directed path to process j containing at most k edges; each of these directed paths must contain less than n − ψ edges, because the number of processes in the reduced graph is n − ψ Since p has directed paths to all the processes, it follows that, when k ≥ n − ψ, all the elements in the p-th column of H k must be non-zero

For matrices A and B of identical dimensions, we say that A≤ B if and only

if Aij ≤ Bij,∀i, j Lemma 9 relates the transition matrices with the connectivity matrices Constant β used in the lemma below was introduced in Lemma 7.

βH[t] ≤ M[t], where H[t] is the connectivity matrix for H[t].

The proof is presented in [15]

non-zero.

The proof is presented in [15]