friedhelm meyer auf der heide 1 heinz nixdorf institute university of paderborn algorithms and...

Friedhelm Meyer auf der Heide 1

HEINZ NIXDORF INSTITUTEUniversity of Paderborn

Algorithms and Complexity

Energy-Efficient Local Strategiesfor Robotic Formations

Friedhelm Meyer auf der Heide University of Paderborn

Joint work with

Bastian Degener, Barbara Kempkes,

Peter Kling, Jaroslaw Kutylowski

(Paderborn)




Gathering problem:Gather all robots in one point

Cycle formation problem: Form a cycle

Short chain problem:Minimize the length of a chain of robots between two stations

Robotic formation problems




Challenge: Consider robots with very limited capabilities

Our mobile robots: - can only see neighbors within a constant radius.

Thus, the decision on what to do next is solely based on relative positions of neighbors in the unit disk graph

Simple local rules are used for a global goal.



Algorithms and ComplexityA simple local rule: Go to the center

- In a step, a robot walks to the center of its neighbors,

i.e. to the center of their smallest enclosing ball.



Algorithms and Complexity Discrete time models, efficiency measures

A round finishes as soon as each robot was active at least once. Asynchronous sense-compute-move model

If activation proceeds in random order: Asynchronous random order sense-compute-move model

If in a round, a (suitably chosen) subset of the robots becomes active Synchronous local activation model

Energy consumption: distance travelled, number of rounds

Trade Off: More rounds give more information about the system state, thereby shorter travel distances are possible.



Algorithms and ComplexityWhat I will talk about

- Local algorithms for Gathering and Short Chains- Discussion of energy-efficiency of discrete time

models- Algorithm for Short Chains in bounded-distance

and continuous time model




Gathering



Algorithms and ComplexityGathering, simple local strategy

A simple strategy: Go-To-The-Center- In a step, a robot walks to the center of its neighbors,







- If its neighbors are connected,

it fuses with one of them






- If its neighbors are connected,

it fuses with one of them

Ando, Suzuki, Yamashita (95), Cohen, Peleg (06),

MadH, Kempkes (08)

Go-To-The-Center performs gathering

in finitely many rounds.



Algorithms and ComplexityGathering with provable time bounds

Degener, Kempkes, MadH (SPAA2010)

Gathering can be done by a local algorithm in O(n²) rounds, in the asynchronous random order sense-compute-move model and in the synchronous local activation model. Each robot travels distance O(n2).

First algorithm with proven bound for number of rounds in a local model.



Algorithms and ComplexityThe algorithm

Algorithm for a robot r :

•Sense positions of robots within distance 2.

•If all detected robots are within distance 1, gather them at r’s position.

•Else compute the convex hull of these robots.

•If r is a vertex of the convex hull:

• If the angle of the convex hull at r is smaller then ¼/3, rearrange the robots such that some of them are moved to the same position (are “fused” ) , without destroying the connectivity of the UDG

• Else: see picture

r

2

Start situation:

•n robots have positions in the plane

•Their unit disk graph is connected

•One node is active at a time




Example 2: 1848 nodes, 24 rounds, random order




Forming short chains



Algorithms and ComplexityThe short chain problem

A winding chain of robots connects a base camp to an explorer. The chain is connected, i.e., neighboring nodes have distance at most 1.

Locality assumption: robots only see predecessor and successor in the chain.

How to transform the chain in a (close to) shortest one by local rules?

base campexplorer




Strategies for the short chain problem

- Go-To-The-Middle- Hopper

These strategies use a discrete round model.

- Move-On-Bisector

This strategy continuously senses and continuously adapts speed and direction.



Algorithms and ComplexityA chain of length 300



Algorithms and ComplexityAfter 25 rounds



Algorithms and ComplexityGo-To-The-Middle

Go-To-The-Middle Strategy

In each round:• every robot moves to the middle position

between its neighbors

relay i

relay i+1

relay i+2



Algorithms and ComplexityGo-To-The-Middle

. . .

explorer base camp



Algorithms and ComplexityGo-To-The-Middle Analysis

J. Kutylowski, MadH

Go-To-The-Middle needs (n2/²) and O(n2 log(n)/²) rounds for reaching the straight line up to distance ².



Algorithms and ComplexityThe Hopper strategy

The Hopper strategy is executed in sequential runs, starting at the explorer.

The Hop operation



Algorithms and ComplexityHopper

remove: dist < 1 shorten: (angle <90)

A run ends with a remove, a shorten, or, if only hops occur, at the base camp.



Algorithms and Complexity Hopper

explorer base camp

2 runs



Algorithms and ComplexityHopper

Note:

Runs of the Hopper strategy can be pipelined,

m runs on a chain of length n need n+3m rounds.

A shortest chain is not reached in general, but a short one.

J. Kutylowski, MadH (TCS 2009)

The Hopper Strategy needs O(n) rounds, each robots travels distance O(n).

It reduce the chain length to at most 21/2 D, and the number of robots to less than 3D.



Algorithms and ComplexityTime models

We have looked at discrete round models:

In a round, robots can sense their neighborhood, compute, and move a distance of at most 1 (or 2).

But: The closer the final configuration is approached, the smaller the movements become. Rounds do not reflect distance travelled.

Alternative cost measures incorporate the travelled distance.

- Restrict a movement to distance ± per step

! ±-bounded model

- Assume continuous sensing, and continuous adaptation of speed of direction to positions of neighbors (assume speed limit 1)

! continuous model




Continuous and ±-bounded version of Go-To-The-Middle

Degener, Kempkes, Kling, MadH (2010)

±-bounded model ( ±2(0,1)):

(n2+n/±) = #rounds = O(n2log(n) + n/±)

Maximum distance travelled = £(±n2 + n)

± = 1/n : O(n2 log(n)) rounds, £(n) travel distance

Continuous model:

Maximum distance travelled = time = £(n)



Algorithms and ComplexityShort Chain: The Move-on-Bisector strategy

A robot continuously does the following:- As long as it has not reached the straight line between its neighbors, it

moves with speed 1 in direction of the bisector.

- As soon as it has reached this line, it continuously adapts speed and direction, so that it stays on the line and maintains the ratio between the distances to neighbors.



Algorithms and ComplexityShort Chain: The Move-on-Bisector strategy

Start ..\..\..\..\Program Files\Continuous Robot Simulator\bin\ContinuousRobotSimulator.exe

Degener, Kempkes, Kling, MadH (Sirocco 2010)

The Move-on-Bisector strategy needs time O(min{n,(Opt+d)log(n)}.

(d = distance between stations,

Opt = optimal time (= max. distance between robots and line.)



Algorithms and ComplexityConclusions

• Designing and analysing local algorithms that modify the network in order to fulfil global tasks is a challenging problem

• Lots of open problems: Which capabilities of robots are necessary for a given

global task, which are suffcient, which are technically feasible?

Swarms: How can certain properties be maintained under dynamics?

Many more ……………..




Thank you for your attention!Thank you for your attention!

Friedhelm Meyer auf der HeideHeinz Nixdorf Institute & Computer Science

DepartmentUniversity of Paderborn

Fürstenallee 1133102 Paderborn, Germany

Tel.: +49 (0) 52 51/60 64 80Fax: +49 (0) 52 51/60 64 82

Mailto: [email protected]://wwwhni.upb.de/en/alg

friedhelm meyer auf der heide 1 heinz nixdorf institute university of paderborn algorithms and...

Documents

local algorithms

simple local strategy

local model

simple strategy

robot walks

complexity challenge

smallest enclosing ball

continuous time model