The Minimum-Backlog Problem

1. The Minimum-Backlog Problem Valentin PolishchukHelsinki Institute for Information Technology, Finland joint work with Michael Bender Computer Science, Stony Brook University, USA Sandor Fekete Institute of Mathematical Optimization, TU Brunswick, Germany Alexander KroellerInstitute of Mathematical Optimization, TU Brunswick, Germany Vincenzo Liberatore Electrical Engineering and Computer Science, Case Western Reserve University, USA Joseph Mitchell Applied Math and Statistics, Stony Brook University, USA Jukka Suomela Helsinki Institute for Information Technology, Finland

2. Motivation: Data Collection • Distributed sensors • points in the plane • Data generated • total over all sensors = 1 per time step • exact distribution is not known in advance • Visit a sensor = collect its data = free HDD space • Tour the sensors, collecting data • Minimize • max data stored at any sensor at any time • storage is expensive, minimize capacity of sensor’s HDD

3. Related Work Geometric TSP Data gathering wireless communication Our setting physically visit sensors enough bandwidth to report the amount of data not enough to actually transmit data cheaper to store data locally and gather than to transmit [Mathur, Desnoyers, Ganesan, Shenoy, Diao, ’06,’07]

4. Abstract Setting: A Game Online: Player doesn’t know how water will be distributed in the future • Graph G • “cups” at nodes • Adversary • pours water (data, snow, etc.) into cups • Player • empties cups • Each time step • adversary pours total of 1 • player moves by an edge • empties cup at the node she arrives • Player’s objective: • min max amount of water in any cup

5. The Game on Kn • G = Kn – complete graph on n vertices • move from any cup to any cup in 1 time step • n cups • Adversary pours 1 unit of water into cups • Player empties any cup

6. Optimal Player’s Strategy: Empty-the-Fullest! max water in any cup O(log n)[Dietz and Sleator’87] Cannot do better Proof (informal). How could one do better?! Proof (formal). Adversary: pour evenly into cups that were never emptied +1/(n-3) + … + 1/1 = Ω(log n) – nth harmonic number +1/(n-1) +1/(n-2) 1/n 1/(n-2) 1/(n-2) 1/(n-2) 1/(n-1) 1/(n-1) 1/(n-1) 1/(n-1) 1/n 1/n 1/n 1/n 1/n

7. The Game on Arbitrary G • d – diameter of G max distance between nodes • Go-for-the-Currently-Fullest max water in any cup O(d log n) • Proof. Not worse than • notice the Currently-Fullest cup C • sit for d time steps • jump to C (that was fullest d ago) . d = 3 “Scaling”: adversary pours d units instead of 1 between player’s moves )O(d log n)

8. Adversary: Lower Bounds • Adversary can do not worse than in Kn Ω(log n) • Adversary canat each step pour ½ into diameter ends Ω(d) Ω( max (d, log n) )

9. ³ ´ p p p p p p p p n n n n O + + + + ¢ ¢ ¢ n n n n = p p ( ) p p p l ­ 1 1 2 ¡ ¡ n n n n o g n = Matching Lower and Upper Bounds • Lots of diametrical ends • tree! • Adversary: each steps pour evenlyinto leaves that were never emptied nodes spokes max water = = Ω(d log n)

10. The Game on a Regular Grid • n2 cups (sensors) on n£n regular grid • (The general) Lower Bound Ω(max (d, log n2) ) = Ω(n) • (The general)Upper Bound O(d log n2) = O(n log n) Close the gap? Can player do better? Our results: O(n log log n )

11. Idea: Tour k points in o(nk) TSP tour on k pts in n£n square [Few’69] O(n√k )

12. (τ,k)-game on Kn • (τ,k)-playersits still for τ time steps • the adversary pours τ units of water into cups • (τ,k)-player empties any k cups • the adversarysits still while the player does it Player Player Player Adv Adv Player Adv Adv k τ k τ k τ k τ

13. (τ,1)-game • The original game is (1,1)-game • Empty-the-Fullest [Dietz and Sleator’87] in (1,1)-game there exists a strategy :max water = O(log n) in any cup at any time • (τ,1)-game “Scaling” adversary pours τ units instead of 1 ) max water O(τ log n) 1 τ 1 τ 1 1 1 τ 1 τ 1 1

14. (k,k)-game Player can achieve max water = O(log n + k) Key idea: “competitive” analysis run an imaginary (1,1)-game same amount of water poured at any time emptied:c1 …ck emptied:ck+1 …c2k emptied:c2k+1 …c3k O(log n) empty:ck+1 …c2k empty:c1 …ck empty:c2k+1 …c3k O(log n k k k k k k k k + k)

15. (kτ,k)-game Scale down by k O( τ log n) Can do better: O(τ log n + kτ ) k τ k τ kτ kτ k τ k τ 1 kτ 1 kτ 1 1 k

16. (kτ,k)-game Player can achieve max water =O(τ log n + kτ) run an imaginary (τ,1)-game same amount of water poured at any time k• τ k• τ τ τ τ τ τ τ τ O(τ log n +kτ) k k kτ kτ

17. (kτ,k,T)-game • (kτ,k)-game: k cups emptied at once • Be realistic! T – time to empty k cups Assume T ≤ kτ kτ -T T T kτ -T T kτ -T • Player: empties any k cups in T sits still for kτ-T time steps • Adversary: scrupulously pours water

18. (kτ,k,T)-game Player can achieve max water =O(τ log n + kτ) run an imaginary (kτ,k)-game same amount of water poured at any time empty the same cups in (kτ,k,T)-game that were emptied in (kτ,k)-game there’s time to do it, T ≤ kτ, so do it instead of sitting! kτ kτ kτ k k k O(τ log n + kτ) kτ -T T T kτ -T T kτ -T

19. kτ – T kτ – T T T The Game on a Regular Grid • n2 cups (sensors) on n£n regular grid • Turn it into (kτ,k,T)-game empty k cups in T sit still for kτ – T k = log n τ = n / √ logn ) kτ = n √ logn T = n √k = n √ logn ) T ≤ kτ) (kτ,k,T)-game is well defined max water = O(τ log n + kτ) = O(n √log n )

20. Extension of the Cup Lemma Cup Lemma: In (1,1)-game Empty-the-Fullest: max water = O(log n) Extension: If (1,1)-game is played for r ≤ n rounds Empty-the-Fullest: max water = O(log r)

21. Revisit (k,k)-game Player can achieve max water = O(log n + k) imaginary (1,1)-game max amount water poured earlier than k steps ago is O(log n) emptied:c1 …ck emptied:ck+1 …c2k emptied:c2k+1 …c3k O(log n) empty:ck+1 …c2k empty:c1 …ck empty:c2k+1 …c3k O(log n k k k k k k k k + k)

22. Revisit (kτ,k)-game Player can achieve max water =O(τ log n + kτ) run an imaginary (τ,1)-game max amount water poured earlier than kτ steps ago is O(τ log n) k• τ k• τ τ τ τ τ τ τ τ O(τ log n +kτ) k k kτ kτ

23. Revisit (kτ,k,T)-game Player can achieve max water =O(τ log n + kτ) run an imaginary (kτ,k)-game max amount water poured earlier than 2kτ steps ago is O(τ log n) O(τ log n) kτ kτ kτ k k k O(τ log n +kτ) kτ -T T T kτ -T T kτ -T

24. “Aging” of Water Max old water isO(τ log n) • Old: • more than 2kτ ago • Recent: • between 2kτ and kτ ago • New: • less than kτ ago We are here kτ -T T T kτ -T T kτ -T

25. Spread the Load (kτ,k,T)-game – empty k cups in one pass kτ -T T T kτ -T T kτ -T Empty some Rest Empty Rest kτ -T T T kτ -T T kτ -T

26. “Rest at Home” Lemma Can schedule tours to always return to the same vertex kτ -T T T kτ -T T kτ -T Empty some Rest Empty Rest kτ -T T T kτ -T T kτ -T

27. Formally • Q½ nxn grid, |Q| = k • p - vertex of the grid 9 constants a and b≥4 : 9 ≤ a√k tours visiting Q altogether each tour length ≤ bn starts/ends at p p “Rest at Home” Lemma kτ -T T T kτ -T T kτ -T

28. p b 2 ( ) k a n k b k a n p ; ; k -game Bona fide by “Rest at Home” Lemma a√k tours , length-bn each visit any k pts a√k + a√k Bonus: Splitting! bn bn bn bn Just emptying during blue(resting during rest) can achieve (kτ,k,T)-game results In particular…

29. p b 2 ( ) k a n k b k a n p ; ; k -game max old water O(τ log n) a√k + a√k bn bn bn bn clearnew Just emptying during blue(resting during rest) We are here

30. p b 2 ( ) k a n k b k a n p ; ; k -game Newwater play (2bn,1,bn)-game with it for a√k rounds a√k + a√k bn bn bn bn We are here Max newwater = O(bn log k)

31. p b 2 ( ) k a n k b k a n p ; ; k -game Max new water is O(bn log k) Max old water isO(τ log n) Recent= new kτ steps ago Recent≤new =O(bn log k) We are here Total = O(τ log n+ n log k) = O(n/√k log n + n log k) =O(n log log n) with k = log2 n

32. Data Collection: Matching Lower and Upper Bounds?

33. MERCI!

36. Empty-the-Fullest on Grid? Adversary: standard trick pick these n cups spread evenly into cups that were never emptied at stage i just a bit more into cup i lure the player to follow the path p 2 4 n-3 n-1 . . . . . . . . . . . n . . . . . . . . . . . 1 3 n-2 n n +n/(n-3) + … + n/1 = Ω(n log n) +n/(n-1) +n/(n-2) n/n

37. Standard Optimization Problem: Offline Input is fully known before alg execution Input does not change as alg is executed Problem: Given: … Find: OPT Approximation algorithm worst-case analysis compare worst-case APX to OPT min: APX ≤ F • OPT F – approximation factor

38. Online Optimization Input is revealedduring alg execution , Input is created asalg is executed Online approximation algorithm competitive worst-case analysis compare worst-case APX to OPT: min: APX ≤ F • OPT F–competitive APX alg OPT – full knowledge of input, before alg execution (offline setting) Competitive Input is created by Adversary

39. Competitive Analysis Online: like a game Offline Adversary: piece of information (after looking at actions so far) Full information APX:action OPT:actions (after looking at full information) ≤ F • OPT APX

40. sb SBP Input • Polygonal domain P • Snow distribution over P (was assumed uniform) Known before alg executionOffline(standard)

41. Online SBP: VariantI P is not known in advance Robotics: online navigation sense boundary – learn the domain Not in this talk

42. Online SBP: Variant II P is known, but… it’s snowing now as we clear constant intensity: total snow / unit time = 1 unknown:snowfall distributionexactly how much snow falls on which pixel Goal: min max snow depth on a pixel