From Hierarchical Partitions to Hierarchical Covers:

From Hierarchical Partitions to Hierarchical Covers:Optimal Fault-Tolerant Spanners for Doubling Metrics

Shay SolomonWeizmann Institute of Science

Doubling Metrics Ball B(p,r) = all points within distance r from p

Definition (doubling dimension) Metric (X,δ) has doubling dimension d if every ball can be covered by 2d balls of half the radius

A metric is doubling if its doubling dimension is constant

d ≤ 3

complete graphnon-negative wt function with triangle inequality



23 boxes to coverlarger 3-dim’ box

• Euclidean space ℝd has doubling dimension Ѳ(d)




Packing lemma Point set with max pairwise distance R and min pairwise distance r contains ≤ (R/r)O(d) points.

R r

Doubling Metrics


• First used by [Assouad, ‘83], algorithmically by [Clarkson, STOC‘97] and [Gupta-Krauthgamer-Lee, FOCS‘03]

• Extensively studied since [Krauthgamer-Lee, SODA’04], [Talwar, STOC’04], [Gao-Guibas-Nguyen, SoCG’04], …

• doubling metric (complete graph)• spanning subgraph of the metric

),( X

H is a (1+ε)-spanner if: it preserves all pairwise distances up to a factor of 1+ε

there is a path in H between p and q with weight

1+ε = stretch of H

H

Spanners

Xqp ,),()1( qp

111-spanner 3-spanner(X,δ)

v3

v1 v2211

v3

v1 v2 21

v3

v1 v2

• doubling metric (complete graph)• spanning subgraph of the metric

),( X

H is a (1+ε)-spanner if: it preserves all pairwise distances up to a factor of 1+ε

there is a path in H between p and q with weight

1+ε = stretch of H

H

Spanners

Xqp ,),()1( qp

- spanner path)1(

111-spanner 3-spanner(X,δ)

v3

v1 v2211

v3

v1 v2 21

v3

v1 v2

Doubling Metrics


Why doubling metrics? bounded “volume” growth

For the uniform metric (doubling dimension Ω(log n)):(1+ε)-spanner (ε < 1) complete graph

1

11

Spanners for doubling metrics [Gao-Guibas-Nguyen,SoCG’04], [Chan-Gupta-Maggs- Zhou, SODA’05],[Har Peled-Mendel, SoCG’05], …

Euclidean spanners [Chew, SoCG’86], [Clarkson, STOC’87], …

Approximation algorithms Distance oracles and labels Network design Compact routing Metric TSP problem Machine learning Robotics …

Applications of spanners

• Small number of edges, ideally

Useful Properties of Spanners

)(nO

stretch 1+ε


• Small degree, ideally (maximum degree of a vertex) FOCUS OF TALK


)(nO

)1(O

stretch 1+ε



• Fast implementation


)(nO

)1(O

stretch 1+ε



• Fast implementation


)(nO

)1(O

stretch 1+ε

Additional properties: small weight and diameter

Fault-Tolerant Spanners

H is k-fault-tolerant (FT) (1+ε)-spanner = remains (1+ε)-spanner after k vertex faults (removals)

Incident edges become faulty

Fault-Tolerance (FT) – resilient to vertex & edge faults in the network

Essential for practical applications

Fault-Tolerant Spanners

H is k-fault-tolerant (FT) (1+ε)-spanner = remains (1+ε)-spanner after k vertex faults (removals)

Incident edges become faulty

Fault-Tolerance (FT) – resilient to vertex & edge faults in the network

Essential for practical applications

H \ F = (1+ε)-spanner for X \ F, for all |F| ≤ k

metric_dist(v1,v2) = 2, spanner_dist(v1,v2) =

Fault-Tolerant Spanners2

11 H = 1-spanner

11

faulty

2

v1 v2

v3

v1 v2

v3

v1 v2

11v3

(X,δ)

H \ F = emptyF = v3

v1 v2

metric_dist(v1,v2) = 2, spanner_dist(v1,v2) =

Fault-Tolerant Spanners2

11 H = 1-spanner

11

faulty

2

v1 v2

v3

v1 v2

v3

v1 v2

11v3

(X,δ)

H \ F = emptyF = v3

v1 v2

k-FT degree of each point ≥ k+1 Ω(kn) edges

Open Problem I: “Is there an alg. that constructs a k-FT (1+ε)-spanner with O(kn) edges in O(n log n + kn) time?”

Open Problem II: “Is there an alg. that constructs a k-FT (1+ε)-spanner with degree O(k) in O(n log n + kn) time?”

FT Spanners – Open Questions Open Questions from [Narasimhan-Smid, 2007](for low-dimensional Euclidean metrics):

Open Problem I: “Is there an alg. that constructs a k-FT (1+ε)-spanner with O(kn) edges in O(n log n + kn) time?”

Open Problem II: “Is there an alg. that constructs a k-FT (1+ε)-spanner with degree O(k) in O(n log n + kn) time?”

FT Spanners – Open Questions Open Questions from [Narasimhan-Smid, 2007](for low-dimensional Euclidean metrics):

optimal time (in algebraic comp. tree model)

running time degree #edges metric reference

O(n log n) + n2O(k) 2O(k) n2O(k) Euclidean LNS98

O(n log n + k2n) - O(k2n) Euclidean LNS98 O(kn log n) - O(kn log n) Euclidean LNS98

O(n logd-1 n + kn loglog n) - O(kn) Euclidean Luk99

O(kn logd n + nk2 log k) O(k) O(kn) Euclidean CZ03

- - O(kn) doubling CLN12

O(n log n + k2n) O(k2) O(k2n) doubling CLNS13

running time degree #edges metric reference

O(n log n) + n2O(k) 2O(k) n2O(k) Euclidean LNS98

O(n log n + k2n) - O(k2n) Euclidean LNS98 O(kn log n) - O(kn log n) Euclidean LNS98

O(n logd-1 n + kn loglog n) - O(kn) Euclidean Luk99

O(kn logd n + nk2 log k) O(k) O(kn) Euclidean CZ03

- - O(kn) doubling CLN12

O(n log n + k2n) O(k2) O(k2n) doubling CLNS13

O(n log n + kn) O(k) O(kn) Euclidean Kapoor-Li

O(n log n + kn) O(k) O(kn) doubling Our Results

Solve open questions from [NS07] for doubling metrics

Preliminaries(net-tree, net-tree spanner)

Net-Tree

net-tree - based on hierarchical partition

net-tree is for doubling metrics

Euclidean metrics analogs:• quadtree (compressed quadtree) • split tree (fair split tree) • dumbbell tree• …

Quadtree Example

• 4-ary tree• 1-1 correspondence between leaves and points• Hierarchical partition of the point set

Quadtree Example

• 4-ary tree• 1-1 correspondence between leaves and points• Hierarchical partition of the point set• Each node is represented by an arbitrary descendant leaf (edge weights increase geometrically with the level)• Net-tree is similar

Net-Tree

v1 v2 v3 v4 v5 v6 v8 v10 v12 v13

v3

v3

v5

v7

v7

v9

v8

v8

v11

v12

v12

v10v3

T

level 2

level 1

level 0 X

level 3

≥1

Internal node picks arbitrary descendant leaf pointAssume min pairwise distance = 1

Net-Tree

v1 v2 v3 v4 v5 v6 v8 v10 v12 v13

v3

v3

v5

v7

v7

v9

v8

v8

v11

v12

v12

v10v3

T

2

4

8level 2

level 1

level 0 X

level 3 ≤

8

≥1

≤4

≤2


≥4

≥2

Net-Tree

v1 v2 v3 v4 v5 v6 v8 v10 v12 v13

v3

v3

v5

v7

v7

v9

v8

v8

v11

v12

v12

v10v3

T

2

4

8level 2

level 1

level 0 X

level 3 ≤

8

≥1

≤4

≤2


dist(i-level node, descendant) ≤ 2i + … + 21 ≤ 2i+1

≥4

≥2

Net-Tree

More properties:• T may have many levels • degree < O(1)O(d) (packing lemma) for tree nodes

2

4

8level 2

level 1

level 0

level 3

v3

v3

v5 v7 v8

v8

v12

v12

v10v3

T

X v2 v4 v5 v6 v8 v10 v12 v13v7 v9 v11v1 v3

Net-Tree

More properties:• T may have many levels• degree < O(1)O(d) (packing lemma) for tree nodes• degree < #levels · O(1)O(d) for points

2

4

8level 2

level 1

level 0

level 3

v3

v3

v5 v7 v8

v8

v12

v12

v10v3

T

X v2 v4 v5 v6 v8 v10 v12 v13v7 v9 v11v1 v3

Small Degree Net-Tree

2

4

8level 2

level 1

level 0

level 3T

X v2 v4 v5 v6 v8 v10 v12 v13v7 v9 v11v1 v3

Internal node picks arbitrary descendant leaf point pick descendant carefully: leftmost leaf in rightmost subtree

Small Degree Net-Tree

2

4

8level 2

level 1

level 0

level 3T

X v2 v4 v5 v6 v8 v10 v12 v13v7 v9 v11v1 v3

Internal node picks arbitrary descendant leaf point pick descendant carefully: leftmost leaf in rightmost subtree each leaf point is in one internal node (if #children ≥ 2) degree O(1)O(d)

v4

v10

v5 v7

v8

v13

v12

v11v3v9

Net-Tree Spanner

Add cross edge between i-level nodes x,y if δ(x,y) ≤ γ·2i

γ = O(1/ε) dist between tree nodes

=dist between repr’s

Net-Tree Spanner

Net-tree spanner = tree edges & cross edges


γ = O(1/ε)

dist between tree nodes

=dist between repr’s

Net-Tree Spanner



γ = O(1/ε); edge between nodes edge between repr’s

Net-Tree Spanner


degree of nodes - ε-O(d) degree of points - ε-O(d) #edges - ε-O(d) · n stretch ??


γ = O(1/ε); edge between nodes edge between repr’s

Net-Tree Spanner


spanner pathup, cross, down

q

q' p'

p

level j

Net-Tree Spanner



q

q' p'

p

level j

wt(up-path) ≤ 2j+1 wt(down-path) ≤ 2j+1

Net-Tree Spanner



q

q' p'

p

wt(cross-edge)> γ·2j-1 - 2·2j

N0

2j 2j


level j

Net-Tree Spanner



q

q' p'

p



Net-Tree Spanner



q

q' p'

p

wt(up-path), wt(down-path) = O(ε)-slack



Net-Tree Spanner



q

q' p'

pδ(p,q) = wt(cross-edge) + ε-slack

wt(up-path), wt(down-path) = O(ε)-slack



Net-Tree Spanner Constant degree net-tree spanner:

• Use net-tree

• Choose unique representatives for internal nodes

• Add cross edges to get constant degree net-tree spanner

• This approach was used in [CGMZ05,GR08] Similar approach was used in [ADMSS95]

FT spanners

Net-Tree Spanner

k-FT spanners: use k+1 representatives instead of 1

called surrogates

Net-Tree Spanner

k-FT spanners: use k+1 representatives instead of 1

Net-Tree Spanner

k-FT spanners: use k+1 representatives instead of 1• Node x: S(x) = surrogate set D(x) ⊆ := descendant set• For small nodes (with < k+1 descendants), S(x) = D(x)

Net-Tree Spanner


T

v2 v4 v5 v6 v8 v10 v12 v13v7 v9 v11v1 v3

v10,v11 v12,v13v8,v9v6,v7v4,v5v2,v3

v12,v13v8,v9

v10,v11

v4,v5

example k=1:Each leaf point is a surrogate of ≤ 2 internal nodes

Net-Tree Spanner


T

v2 v4 v5 v6 v8 v10 v12 v13v7 v9 v11v1 v3

v10,v11 v12,v13v8,v9v6,v7v4,v5v2,v3

v12,v13v8,v9

v10,v11

v4,v5

For general k:Each leaf point is a surr’ of ≤ k+1 internal nodes

example k=1:Each leaf point is a surrogate of ≤ 2 internal nodes

k-FT spanners: use k+1 representatives instead of 1• Node x: S(x) = surrogate set D(x) ⊆ := descendant set• For small nodes (with < k+1 descendants), S(x) = D(x)• Translate each edge (x,y) in the basic net-tree spanner into bipartite clique between the sets S(x) and S(y)

x

S(x) S(y)y

k=2

k-FT spanners: use k+1 representatives instead of 1• Node x: S(x) = surrogate set ⊆ D(x) := descendant set• For small nodes (with < k+1 descendants), S(x) = D(x)• Translate each edge (x,y) in the basic net-tree spanner into bipartite clique between the sets S(x) and S(y)

x

S(x) S(y)y

k=2

Why k-FT spanner?At least one among k+1 surr’s must function


x

S(x) S(y)y

k=2

Why k-FT spanner?At least one among k+1 surr’s must functionWhat about small nodes (with < k+1 descendants) ??

Net-Tree Spanner


p and q are non-faulty.

q p

q'p‘

Net-Tree Spanner


p and q are non-faulty. At least one of them will belong to any small node on the path (with < k+1 surr’s)

INDEED: for small nodes, S(x) = D(x)

q p

q'p‘


Degree:• Each bipartite clique increases degree of surr’s by k+1• Same point is a surr’ of Ω(k) nodes degree Ω(k2)• [Chan-Li-Ning-S., ICALP’13]: This idea + rerouting ideas from [GR08] to fix single-child paths degree Ѳ(k2)

x

S(x) S(y)y

k=2


Degree:• Each bipartite clique increases degree of surr’s by k+1• Same point is a surr’ of Ω(k) nodes degree Ω(k2)• [Chan-Li-Ning-S., ICALP’13]: This idea + rerouting ideas from [GR08] to fix single-child paths degree Ѳ(k2) AND

small weight & diameter

x

S(x) S(y)y

k=2

FT Spanners with Optimal Degree

k-FT spanners: use ≈ k+1 representatives instead of 1• Node x: S(x) = surrogate set ⊆ D(x) := descendant set• Translate each edge (x,y) in the basic net-tree spanner into bipartite clique between the sets S(x) and S(y)

Same Approach ?

k-FT spanners: use ≈ k+1 representatives instead of 1• Node x: S(x) = surrogate set ⊆ D(x) := descendant set• Translate each edge (x,y) in the basic net-tree spanner into bipartite clique between the sets S(x) and S(y)

ONLY CHANGE: Take S(x) from a superset of D(x)

Same Approach ?

Sanity Check

The basic net-tree spanner has at least n edges

Each edge is translated into a bipartite clique of size O(k2)

Problem: # edges > k2 n, degree > k2

How can we get degree o(k2)?

?

Sanity Check





IDEAS:(1) many cliques are small (2) many cliques are redundant – identify & remove them

?

Sanity Check





IDEAS:(1) many cliques are small (2) many cliques are redundant – identify & remove them we’ll return to this later…

?

Sanity Check (example) #large nodes (with > k descendants ) = O(n/k) large cliques only for them #edges for large cliques = O(n/k) · k2 = O(kn)

k+1

small cliques

large cliquesn/k

nodes

Sanity Check (example)

k+1

small cliques

large cliquesn/k

nodes

#edges for small cliques ?


k+1

small cliques

large cliquesn/k

nodes

“convenient” cross edges (e.g., connect children of the same node)#edges for convenient small cliques = O(kn)

#edges for small cliques ?

k+1

large cliquesn/k

nodes


small cliques

general cross edges

#edges for small cliques ?Sanity Check (example)

k+1

large cliquesn/k

nodes


small cliques

general cross edges

#edges for small cliques ? IDEA: If there are many cross edges below the blue borderline we’ll lower the borderline somehow


k+1

large cliques

n/k nodes


small cliques

general cross edges

#edges for small cliques ? IDEA: If there are many cross edges below the blue borderline we’ll lower the borderline somehow


Reminder:

• For i-level node x and leaf descendant y Є D(x), δ(x,y) ≤ 2i+1

•

How to Choose Surrogates

• dist between tree nodes = dist between original repr’s

Reminder:

• For i-level node x and leaf descendant y Є D(x), δ(x,y) ≤ 2i+1

• dist between tree nodes = dist between original repr’s

IDEA: use arbitrary points at distance O(2i) say < 100·2i

x = i-level node, with original repr’ p(x)B(x) := ball of radius O(2i) around p(x)

S(x) D(x) ⊆ S(x) B(x)⊆

How to Choose Surrogates

Hierarchical Cover“From Hierarchical Partitions to Hierarchical Covers”:

Partition = disjoint subsets whose union covers the point set

Cover = subsets whose union covers the point set.Cover degree = max # of subsets that some point belongs to

D(x) | x is i-level node = partitionD(x) | x is 0-level node, D(x) | x is 1-level node, … = hierarchical partition

Hierarchical Cover“From Hierarchical Partitions to Hierarchical Covers”:

Partition = disjoint subsets whose union covers the point set

Cover = subsets whose union covers the point set.Cover degree = max # of subsets that some point belongs to

D(x) | x is i-level node = partitionD(x) | x is 0-level node, D(x) | x is 1-level node, … = hierarchical partition

B(x) | x is i-level node = cover, degree = O(1)O(d) (packing)B(x) | x is 0-level node, B(x) | x is 1-level node, … = hierarchical cover

x is small if |B(x)| ≤ 2k+1; otherwise it is large

• For small nodes x: S(x) = D(x);|S(x)| ≤ |B(x)| ≤ 2k+1 Claim: All points in S(x) = D(x) have degree < ε-O(d) · k

Small/Large

x'qЄS(y’)

y’pЄS(x’)

x

i - log γ

i

≤ γ·2i-log γ

p S(x)

B(x)

(p,q )=( -i log γ) - level cross edge in the FT spanner

x = i-level node; p = surrogate of x with max degree

Observation 1: All neighbors of p due to cross edges until level i - log γ are in B(x). Hence at most 2k+1 such neighbors

x'qЄS(y’)

y’pЄS(x’)

x

i - log γ

i

≤ γ·2i-log γ = 2i

p S(x)

B(x)

q


Observation 1: All neighbors of p due to cross edges until level i - log γ are in B(x). Hence at most 2k+1 such neighbors


x'qЄS(y’)

y’pЄS(x’)

x

i - log γ

i

p S(x)

B(x)

q

log γ levels

Observation 2: In each level the degree of any point increases by < ε-O(d) · k units


≤ γ·2i-log γ = 2i


x is small if |B(x)| ≤ 2k+1; otherwise it is large


Small/Large

Small/Large and Clean/Dirty x is small if |B(x)| ≤ 2k+1; otherwise it is large


• For large nodes x: choose to S(x) k+1 clean points from B(x) All points are initially clean.

1) Mark them as dirty – won’t re-use them as new surr’s of large nodes again 2) ≥ k+1 clean points are left at B(x) – use surplus later!3) Re-use them until their degree is too large, at least for

next log γ levels – increases surplus of clean points 4) For the (log γ)-level ancestor x’ of x, do this again…

Will we have at least 2k+2 clean points at B(x’) ??



• For large nodes x: choose to S(x) k+1 clean points from B(x) All points are initially clean. **BOTTOM-UP PROCESS**:






• For large nodes x: choose to S(x) k+1 clean points from B(x) All points are initially clean. **BOTTOM-UP PROCESS**:




?

x =x0

x' = xlog γ

i + log γ - 1

i

log γ levels

S(x)

x1

x2

x3

S(x’)xlog γ - 1

x = x0 assigns a new surrogate set S(x); x’s parent x1 re-uses S(x), x2 also re-uses S(x), etc.Re-use S(x) until at least xlog γ - 1

x =x0

x' = xlog γ

i + log γ - 1

i

log γ levels

S(x)

x1

x2

x3

x = x0 assigns a new surrogate set S(x); x’s parent x1 re-uses S(x), x2 also re-uses S(x), etc.Re-use S(x) until at least xlog γ - 1

S(y)y =y0

? y1

S(x) OR S(y)xlog γ - 1 = y2

S(x’)

x =x0

x' = xlog γ

i + log γ - 1

i

log γ levels

S(x)

x1

x2

x3

S(y)y =y0

y1

Abundance of surrogates – not a problem:pick surrogates whose “appointment”started most recently

xlog γ - 1 = y2

S(x’)S(x) OR S(y)

?

x =x0

x' = xlog γ

i + log γ - 1

i

log γ levels

S(x)

x1

x2

x3

S(y)y =y0

y1

Abundance of surrogates – not a problem:pick surrogates whose “appointment”started most recently

xlog γ - 1 = y2 S(y) ! S(x’)

Key Idea cross edge (x,y) bipartite clique between S(x) and S(y)x “loses” |S(y)| units, y will “compensate” it (and vice versa)

x y

S(x) S(y)

How? B+(x):= clean points from B(x) (ball surplus)


x y

S(x) S(y)B+(y)

B+(x)

Surplus Lemma: for each node x:|B+(x)| ≥ |S(x)|

Proof. use items 2 & 3 from previous slide inductively.



x y

S(x) S(y)B+(y)

B+(x)



In the paperF(x) is used

instead B+(x)



x y

S(x) S(y)B+(y)

B+(x)





x y

S(x) S(y)B+(y)

B+(x)


COMPENSATE ?? B+(x) B+(x) B∪ +(y)B+(y) B+(y) B∪ +(x)


Key Idea **First problem**:B+(x) and B+(y) are too far; at factor-γ apart rather thanat factor-O(1) apart.

Solution:Compensate a close ancestor of x instead of x itself: if x is at level i, we compensate its (i + log γ)-ancestor x’

Since the same surr’s are re-used for log γ levels, this is fine

x y

x'i + log γ

i

≤ γ·2i

B(x’)

log γ levels

B+(x) B+(y)

≤ 2i+log γ+1

x y

x'i + log γ

i

≤ γ·2i = 2i+log γ

B(x’)

log γ levels

B+(x) B+(y)

B+(y)

≤ 2i+log γ+1

Key Idea **Second problem**:B+(x) ∩ B+(y) ≠ ∅ (possibly small compensation)

Solution:Be a “leech” = before appointing new surr’s at a large node (making them dirty), try using surr’sof another large node. This large node is the “host”

A leech has a single host. A host may have many leeches – by packing lemma only a constant

This increases degree of surr’s by only constant factor

Key Idea Corollary [either equal or disjoint]:Let x,y be large nodes at the same level:either S(x) = S(y) or S(x) ∩ S(y) = ∅


if intersection is non-empty:

one would become a leech of the other, or both would become

leeches of the same host

Key Idea Corollary [either equal or disjoint]:Let x,y be large nodes at the same level:either S(x) = S(y) or S(x) ∩ S(y) = ∅(I) S(x) = S(y): Redundant Edges: An edge (x,y) is redundant if S(x) = S(y); such edges are ignored (don’t translate into a clique).Don’t compensate redundant edges!

Sanity Check (recall)






?






?

Sanity Check (recall)


(II) S(x) ∩ S(y) = ∅ (too far away to become leech-host):Disjointness: If S(x) ∩ S(y) = ∅, then |B+(x) \ B+(y)| ≥ k+1, |B+(y) \ B+(x)| ≥ k+1

• We devised optimal FT-spanners for doubling metrics: #edges + degree + running time

• Additional useful parameters: weight & diameter

We have near-optimal bounds for them: weight O(k2 + k log n) · w(MST), diameter O(log n)

There are slacks of factor < log k on weight & diameter

Kapoor-Li - optimal weight, but: unbounded diameter, don’t extend to doubling

• Slack on weight coincides with central open question (weight o(log n) · w(MST) for doubling metrics?)

Conclusions and Open Questions

THANK YOU!

From Hierarchical Partitions to Hierarchical Covers:

Documents

Transcript of From Hierarchical Partitions to Hierarchical Covers: