TSP On Manifolds: David Zisselman October 5, 2021

TSP on manifolds
David Zisselman
arXiv:2110.01093v1 [cs.CG] 3 Oct 2021
October 5, 2021
Abstract
In this paper, we present a new approach of creating PTAS to the
TSP problems by defining a bounded-curvature surface embedded spaces.
Using this definition we prove:
• A bounded-curvature surface embedded spaces TSP admits to a
PTAS.
• Every bounded doubling dimension space can be embedded into a
bounded-curvature surface.
• Every uniform metric space can be embedded into a bounded-curvature
surface.
Thus, the algorithm generalizes [9] (and therefore [7] and [8] as well, w.r.t
PTAS of TSP). But, the algorithm is much broader as uniform metric
spaces aren’t bounded doubling dimension spaces. It should be mentioned
that our definition of a surface is derived from Riemannian geometry, but
doesn’t match it exactly. therefore, our definitions and basic geometry
algorithm is given here in full.
1 introduction
The Travelling Salesman Problem (TSP) is one of the most famous NP-hard op-
timization problems, it appeared as early as 1832 by W.R. Hamilton [1] (though
not mathematically formal). Following Karp’s [2] work and the understanding
of the NP-completeness of the Hamiltonian path problem it was proven that
TSP is a NP-hard problem to solve (but not to approximate). Following the
understating of Orponen and Mannila [3] and of the PCP theorem [4] and later
works, a limit to the approximability of TSP was established. Meaning there
exist a fixed a > 1 s.t no polynomial time β -approximation algorithm, where
β ≤ α, for TSP can exist, unless P = N P . Currently, the best such a known
123
is a = 122 [5]. Arora [7] and Mitchell [8] presented a polynomial time ap-
proximation scheme (PTAS) for a bounded-dimensional Euclidean spaces which
was later generalized to a PTAS on a bounded doubling dimension spaces [9].
The general unbounded case of euclidean metrics, it should be noted, is hard
to approximate within some constant factor [6]. However, Euclidean spaces
embeddings has its fair share of problems:
1
• Euclidean spaces can’t embed a arbitrarily large uniform metric space (i.e
d(i, j) = c for a fixed c > 0) in a fixed dimension. But solving such TSP
is especially easy, all paths are of the same length!
• Some metric spaces can’t be embedded into an Euclidean space (regardless
of dimension) and thus, every metric space that contains such a subspace
can’t be embedded. So, clearly, there are more spaces that needs to be
addressed.
This result is based on the understanding that Arora’s algorithm can be used
in other context. Primarily it can be used in "bent" spaces, for example, on
manifolds immersed in Euclidean space. Such spaces are much metrically richer
than Euclidean spaces. In our settings we go a bit further and use some other
version of manifolds which aren’t immersed in Euclidean space completely but
an immersion except for a few "key points" exist. Using such a technique we
create a genus to the manifolds and receive an environment which can embed
many more metric spaces.
2 Settings
The basic settings of our model will be described in this section.
Definition 2.1. Given g ∈ N, the base space of genus g is the space [0, 1]2
from which 2g squares, aligned with the axis, were removed in pairs and both
outer rims of the each pair are identified together (i.e a point on the outer rim
of one square is identical to the point on the same position on its twin). Please
view figure 1 for the case g = 2
Notation 2.2. We will denote the base space of genus g by BAS(g). The rims
of the squares in BAS(g) will be denoted be sq1 (i) and sq2 (i) where i = 1, 2..., g
and sq1 (i) and sq2 (i) are paired.
Please note that the base space is described by the quantity g and the
placement of sq1 (i) and sq2 (i) where i = 1, 2..., g and sq1 (i). We will talk in
this paper about base spaces based on [0, a]2 for a > 0. But if not mentioned
otherwise, the base space is based on [0, 1]2 .
2
Definition 2.3. Let g ∈ N and x, y ∈ BAS(g). The distance of x to y denoted
dBAS(g) (x, y) is defined as the infimum of lengths of polygonal paths connecting
x to y. Formally:
γ is a polygonal
dBAS(g) (x, y) = inf{len(γ)| }
path f rom x to y
y
Despite sq1 (i), sq2 (i) being squares (with volume
> 0) the reader may want to think about suck objects
as points. One can easily prove the following facts:
• the infimum in definition 2.3 is indeed a mini-
mum.
• the polygonal path on which the minimum is x
received is composed of straight lines to and
from x,y and points on sq1 (i) and sq2 (i) where Figure 1: base space of
i = 1, 2..., g. genus 2
Definition 2.4. Let g ∈ N . A function f :
BAS(g) → R is called continuous if for every x0 ∈ BAS(g) and every ε > 0
there exist δ > 0 s.t for every x ∈ BAS(g) if dBAS(g) (x, x0 ) < δ then
|f (x) − f (x0 )| < ε.
The reader should note that, given g ∈ N a function f : BAS(g) → R and a
point (x, y) ∈ BAS(g), one could calculate the limit lim f (x+h,y)−f
h
(x,y)
if exists,
h→0
for h s.t (x + h, y) ∈ BAS(g). Such a limit, if exists, is the partial derivative of
f in x and is denoted by ∂f∂x . By the same principle, one could define the partial
derivation of f in y and recursively define the higher order derivation (as the
derivation function, if exists, is also a function from BAS(g) to R).
Definition 2.5. Let g ∈ N . A function f : BAS(g) → R is called smooth and
denoted f ∈ C ∞ (BAS(g), R) if the following conditions hold:
• f is continuous
• f has partial derivations, of any order and in any direction, and all such
functions are continuous
• all partial derivations of f , of any order and in any direction, are 0 on
sq1 (i) and sq2 (i) where i = 1, 2..., g and on the rims of [0, 1]2
Notation 2.6. Given g ∈ N and f ∈ ‘C ∞ (BAS(g), R) we can view the surface
created by f on BAS(g), which is formally:
{(x, y, z) ∈ R3 |(x, y) ∈ BAS(g) ∧ z = f (x, y)}
Denote
S(f, g) = {(x, y, z) ∈ R3 |(x, y) ∈ BAS(g) ∧ z = f (x, y)}
to be that surface.
3
Given g ∈ N the set C ∞ (BAS(g), R) is used as the set of "all" surfaces of
genus g, in some way. And for every f in it S(f, g) is a specific surface.
Definition 2.7. We say that S(f, g) is a surface if g ∈ N and
f ∈ C ∞ (BAS(g), R)
Definition 2.8. Let S(f, g) be a surface. Given two points x, y ∈ s(f, g). The
distance of x to y on the surface denoted dS(f,g) (x, y) is defined as the infimum
of lengths of polygonal paths connecting x to y on the surface. Formally:
Z 1r
dγ1 (t) 2 dγ2 (t) 2 df (γ(t)) 2
dS(f,g) (x, y) = inf { ( ) +( ) +( ) dt}
γ 0 dt dt dt
Please note the following:
• the infimum is taken over poligonal paths
γ : [0, 1] → BAS(g)
satisfying γ(0) = x and γ(1) = y.

• the notation γ1 (t) denotes the first component of the two dimensional
vector γ(t) and likewise for γ2 (t).
• as γ is a polygonal path, its derivative is properly defined on all [0, 1]
except for finitely many points (which won’t change the value of integral)
• the formula comes from the general formula to calculate length of a curve
in Rn : Given a path δ : [0, 1] → Rn its length is:
Z 1p
len(δ) = ||δ ′ (x)||2 dx
0
p
and here the term ||δ ′ (x)||2 ,where δ(t) = (γ1 (t), γ2 (t), f (γ(t))), is
r
dγ1 (t) 2 dγ2 (t) 2 df (γ(t)) 2
( ) +( ) +( )
dt dt dt
Notation 2.9. Given a surface S(f, g) and a path γ : [0, 1] → S(f, g) on in

denote the integral of the length w.r.t γ with lenS(f,g) (γ) i.e:
Z 1r
dγ1 (t) 2 dγ2 (t) 2 df (γ(t)) 2
lenS(f,g) (γ) = ( ) +( ) +( ) dt
0 dt dt dt
3 Basic geometric definitions and theorems

In this section we will elaborate basic geometric theorems and prove their version
w.r.t our settings given in section 2. Primarily, we wish to prove how to calculate
the distances (up to a given error) defined in 2.8.
4
Theorem 3.1. Let S(f, g) be a surface, assume the following:
• all partial derivatives of f of order i are bounded by Mi
• an algorithm exist that computes for a given k ∈ N digits point on BAS(g)
the first n digits of the functions f and all its derivatives up to second order
in time T heta(n, k)
Then an algorithm exists s.t given ε > 0 and p1 , p2 ...pk ∈ BAS(g) finite
set of points which are rational in both coordinates and with denominator ≤ t
calculates the set
{d′S(f,g) (pi , pj )|1 ≤ i, j ≤ k}
of distances which differ from the real distances (as defined in 2.8) by up to ε
and the algorithm run in time:
 √ 
3· 16+8(M1 +M2 )2 3M2 12
 ⌈max( ε , ε )⌉ + 
O √ 2

 3· 16+8(M1 +M2 ) 3M2 ε ε ε
2 
⌈max( ε , ε )⌉ Θ(− log (
10 3t ), − log (
10 3t )) log (
10 3t )
where q
2
3· 16 + 8 (M1 + M2 ) 3M2
t = ⌈max( , )⌉
ε ε
The idea behind the proof is to approximate the path by divisions points
which are rational numbers and who’s denominator is not too large. Then,
run Floyd Warshall’s algorithm on the set of such points in order to find the
minimal path between each two points. Please note that the requirement of
all the points pi to be rational with denominator ≤ t is a technical one - as,
generally speaking, a point in BAS(g) can’t be represented using a computer’s
memory without some condition of this sort. In order to prove the following
theorem - let’s start with the lemma about approximating a straight line with
rational numbers with small denominator:
Lemma 3.2. Denote the set As where s ∈ N of all the points (x, y) ∈ BAS(g)
for which the numbers x, y are both rational and can be written with a denom-
inator ≤ s. Let S(f, g) be a surface, assume that all partial derivatives of f of
order i are bounded by Mi . Let (x0 , y0 ), (x1 , y1 ) ∈ BAS(g) be any two points,
assume the straight line between them exists in BAS(g) and denote the line be-
tween the two points by (x0 , y0 ) ↔ (x1 , y1 ) . Let (x̄0 , ȳ0 ), (x̄1 , ȳ1 ) ∈ At be the
closest points to (x0 , y0 ), (x1 , y1 ) respectively within At (in case of more than
one closest point - choose one arbitrarily). Assume that the straight line be-
tween (x̄0 , ȳ0 ), (x̄1 , ȳ1 ) exist on BAS(g) as well denote the line between the two
points by (x̄0 , ȳ0 ) ↔ (x̄1 , ȳ1 ). Then
q
2
16 + 8 (M1 + M2 )
|lenS(f,g) ((x̄0 , ȳ0 ) ↔ (x̄1 , ȳ1 ))−lenS(f,g) ((x0 , y0 ) ↔ (x1 , y1 ))| ≤
s
5
Proof. First write the equations of these straight lines:
Γ(t) = ((x0 , y0 ) ↔ (x1 , y1 ))(t) = (x0 , y0 )t + (x1 , y1 )(1 − t)
and
Γ̄(t) = ((x̄0 , ȳ0 ) ↔ (x̄1 , ȳ1 ))(t) = (x̄0 , ȳ0 )t + (x̄1 , ȳ1 )(1 − t)
note that
d
((x0 , y0 ) ↔ (x1 , y1 ))(t) = (x0 , y0 ) − (x1 , y1 )
dt
and
d
((x̄0 , ȳ0 ) ↔ (x̄1 , ȳ1 ))(t) = (x̄0 , ȳ0 ) − (x̄1 , ȳ1 )
dt
therefore the difference between the two function’s derivation is bounded as we
can see here:
d d
| ((x̄0 , ȳ0 ) ↔ (x̄1 , ȳ1 ))(t) − ((x0 , y0 ) ↔ (x1 , y1 ))(t)| =
dt dt
|(x̄0 , ȳ0 ) − (x̄1 , ȳ1 ) − (x0 , y0 ) + (x1 , y1 )| =
|(x̄0 − x0 , ȳ0 − y0 ) − (x̄1 − x1 , ȳ1 − y1 )| ≤
|(x̄0 − x0 , ȳ0 − y0 )| + |(x̄1 − x1 , ȳ1 − y1 )| =
q q
2 2 2 2
(x̄0 − x0 ) + (ȳ0 − y0 ) + (x̄1 − x1 ) + (ȳ1 − y1 ) ≤
s s
2 2 2 2
√ 1
1 1 1 1
+ + + = 2 2 (1)
s s s s s
Moreover the difference in absolute value is also bounded:
|((x̄0 , ȳ0 ) ↔ (x̄1 , ȳ1 ))(t) − ((x0 , y0 ) ↔ (x1 , y1 ))(t)| =

|(x̄0 , ȳ0 )t − (x̄1 , ȳ1 ) (1 − t) − (x0 , y0 )t + (x1 , y1 ) (1 − t)| =
|(x̄0 − x0 , ȳ0 − y0 )t − (x̄1 − x1 , ȳ1 − y1 ) (1 − t)| ≤
|(x̄0 − x0 , ȳ0 − y0 )| t + |(x̄1 − x1 , ȳ1 − y1 )| (1 − t) =
q q
2 2 2 2
t (x̄0 − x0 ) + (ȳ0 − y0 ) + (1 − t) (x̄1 − x1 ) + (ȳ1 − y1 ) ≤
s s
2 2 2 2
√ 1
1 1 1 1
t + + (1 − t) + = 2
s s s s s
(2)
Therefore the last element of the length as defined in 2.9 is also bounded - as
6
can be seen by this calculation:
d
f (((x̄0 , ȳ0 ) ↔ (x̄1 , ȳ1 ))(t))
dt
df ′
=| (((x̄0 , ȳ0 ) ↔ (x̄1 , ȳ1 ))(t)) (((x̄0 , ȳ0 ) ↔ (x̄1 , ȳ1 ))1 ) (t)
dx
df ′
+ (((x̄0 , ȳ0 ) ↔ (x̄1 , ȳ1 ))(t)) (((x̄0 , ȳ0 ) ↔ (x̄1 , ȳ1 ))1 ) (t) |
dy
df df
Γ̄ · Γ̄′1 (t) + Γ̄ · Γ̄′2 (t)

=
dx dy
√

1 df df df df 1
′ ′
≤ Γ̄ · Γ1 (t) + Γ̄ · Γ2 (t) + 2 max (z) + max (z)
dx dy z∈BAS(g) dx z∈BAS(g) dy s
df df √ 1
Γ̄ · Γ′1 (t) + Γ̄ · Γ′2 (t) + 2 2M1

≤
dx dy s
df d df df
≤2 | (Γ) · Γ′1 (t) + (z1 ) · |Γ′1 (t)| Γ̄ − Γ + (Γ) · Γ′2 (t)
dx dn̂ dx dy
d df √ 1
+ (z2 ) · |Γ′2 (t)| Γ̄ − Γ | + 2 2M1
dn̂ dy s
df df √ 1 √ 1
≤3 (Γ) · Γ′1 (t) + (Γ) · Γ′2 (t) + 2M2 (|Γ′1 (t)| + |Γ′2 (t)|) + 2 2M1
dx dy s s
df df √ 1 √ 1
≤4 (Γ) · Γ′1 (t) + (Γ) · Γ′2 (t) + 2 2M2 + 2 2M1
dx dy s s
d √ 1
= f (((x̄0 , ȳ0 ) ↔ (x̄1 , ȳ1 ))(t)) + 2 2 (M1 + M2 ) (3)
dt s
Where inequality 1 is simply due to inequality 1 and inequality 2 is approxi-

df df
mation of the function dx using the mean value theorem (and for dy likewise),
here z1 , z2 are points between Γ, Γ̄ and the direction n̂ is the direction between
them. Inequality 3 is due to inequality 2 we’ve just seen. Inequality 4 is simply
7
due to M2 ’s definition. Therefore, the difference in length is bounded as:
lenS(f,g) ((x̄0 , ȳ0 ) ↔ (x̄1 , ȳ1 )) =

Z 1r
dΓ̄1 (t) 2 dΓ̄2 (t) 2 df (Γ̄(t)) 2
( ) +( ) +( ) dt ≤1
0 dt dt dt
Z 1r
dΓ1 (t) 2 8 dΓ2 (t) 2 8 df (Γ̄(t)) 2
( ) + 2 +( ) + 2 +( ) dt ≤2
0 dt s dt s dt
s
Z 1 2
dΓ1 (t) 2 8 dΓ2 (t) 2 8 df (Γ(t)) 2 8 (M1 + M2 )
( ) + 2 +( ) + 2 +( ) + dt ≤3
0 dt s dt s dt s2
s
Z 1r Z 1 2
dΓ1 (t) 2 dΓ2 (t) 2 df (Γ(t)) 2 16 + 8 (M1 + M2 )
( ) +( ) +( ) dt + dt =4
0 dt dt dt 0 s2
q
Z 1r
dΓ1 (t) 2 dΓ2 (t) 2 df (Γ(t)) 2 16 + 8 (M1 + M2 )2
( ) +( ) +( ) dt + =
0 dt dt dt s
q
16 + 8 (M1 + M2 )2
lenS(f,g) ((x0 , y0 ) ↔ (x1 , y1 )) +
s
Where the first inequality is due to 1 inequality we’ve seen above. The second
inequality here is due to 3 inequality above. inequality 3 is due to the triangle
inequlity in L2 norm on R3 and equality 4 is simply solving the integral (which
doesn’t depend on t at all). Please note that in case the path Γ was from [t1 , t2 ]
instead of [0, 1] all above calculation are the same except for equality 4 which
becomes q
2
16 + 8 (M1 + M2 )
(t2 − t1 )
s
Now, as a corollary we get that if Γ : [0, 1] → BAS(g) is a polygonal path

and 0 = t0 < t1 < · · · < tn−1 < tn = 1 is a dissection of [0, 1] s.t Γ is straight
between each two points [ti , ti+1 ] and if we denote t¯i to be the closest point to
ti within As like before and if the path Γ̄ : [0, 1] → BAS(g) of straight lines
between the ti exist then the same approximation as before holds. i.e:
q
2
16 + 8 (M1 + M2 )
|lenS(f,g) ((x̄0 , ȳ0 ) ↔ (x̄1 , ȳ1 ))−lenS(f,g) ((x0 , y0 ) ↔ (x1 , y1 ))| ≤
s
(4)
Since, the inequality holds for every subsection [ti , ti+1 ] and since the error is
linear in the distance (ti+1 − ti ) - by summing over the same inequality over all
subsection [ti , ti+1 ] we get the inequality 4.
Moreover, one can see that such Γ̄ : [0, 1] → BAS(g) must exist - as, even if
the original path Γ had a straight segment that crossed BAS(g) in such a way
that any movement of the points in its end will make the new line cross one of
8
sqj (i), this segment could still be approximated by a polygonal path (and the
above statements are valid for such a case as well) .
The second lemma will tell us how to approximate the integral:
Lemma 3.3. Let S(f, g) be a surface, assume the following:
• all partial derivatives of f of order i are bounded by Mi
• an algorithm exist that computes for a given k ∈ N digits point on BAS(g)
the first n digits of the functions f and all its derivatives up to second order
in time Θ(n, k)
Denote the set At where t ∈ N of all the points (x, y) ∈ BAS(g) for which
the numbers x, y are both rational and can be written with a denominator ≤ t.
Then an algorithm exists that given two points (x1 , y1 ), (x2 , y2 ) ∈ At for which
the straight line between them exist on BAS(g) computes the distance between
them (according to 2.9) up to an error 10−k t + 3M
t
2
in time O(tΘ(k, k)k 2 )
Proof. By using the rectangle method - calculate the sum:
t−1
r
dΓ1 ( nu ) 2 dΓ2 ( nt ) 2 df (Γ( nt )) 2 n + 1 n
X
( ) +( ) +( ) − =
n=0
du dt dt t t
s
t−1
X 1 df n df n
(x1 − x2 )2 + (y1 − y2 )2 + ( (Γ( )) · (x1 − x2 ) + (Γ( )) · (y1 − y2 ))2
n=0
t dx t dy t
this sum cam be calculated using simple arithmetic (each addition and multipli-
cation takes up to k 2 operations, where k is the number of digits) and t estimates
df df
of dx , dy and therefore it can be calculated (using k digits) in time O(tΘ(k, k)k 2 ).
As with all continues functions the Riemann sum t−1 n 1
P
n=1 f t t approximates
R1
the integral 0 f (x)dx up to t−1 1
P
n=1 (Mi − mi ) t where Mi , mi are the max and
′
min of the function f on each section t , t . As |Mi − mi | ≤ maxt f by the
n+1 n
mean value (maximum of derivative times the length of the function) and sum-
Pt−1 Pt−1 ′
ming over it gives n=1 (Mi − mi ) 1t ≤ n=1 max f ′ t12 = maxt f theorem we
′
get that the above Riemann sum approximates lenS(f,g) (Γ) up to maxt f where
s
df df
f (x) = (x1 − x2 )2 + (y1 − y2 )2 + ( (Γ(x)) · (x1 − x2 ) + (Γ(x)) · (y1 − y2 ))2
dx dy
9
therefore, the bound on the derivative is;
d2 f
!
df 2
( dx (Γ(x)) · (x1 − x2 ) + ) dx2 (Γ(x)) · (x1 − x2 ) +
df d2 f d2 f 2
′ dy (Γ(x)) · (y1 − y2 ) dxdy (Γ(x)) · (x1 − x2 ) (y1 − y2 ) + dy 2 (Γ(x)) · (y1 − y2 )
|f (x)| = q
df df
(x1 − x2 )2 + (y1 − y2 )2 + ( dx (Γ(x)) · (x1 − x2 ) + dy (Γ(x)) · (y1 − y2 ))2
d2 f
!
df
dx (Γ(x)) · (x1 − x2 ) + dx2 (Γ(x)) · (x1 − x2 )2 +
( df ) d2 f d2 f 2
dy (Γ(x)) · (y1 − y2 ) dxdy (Γ(x)) · (x1 − x2 ) (y1 − y2 ) + dy 2 (Γ(x)) · (y1 − y2 )
≤ q
df df
( dx (Γ(x)) · (x1 − x2 ) + dy (Γ(x)) · (y1 − y2 ))2
d2 f 2 d2 f d2 f 2
= ( (Γ(x)) · (x1 − x2 ) + (Γ(x)) · (x1 − x2 ) (y 1 − y 2 ) + (Γ(x)) · (y1 − y2 ) )
dx2 dxdy dy 2
≤ M2 · 12 + M2 · 1 · 1 + M2 · 12 = 3M2
′
and thus the calculation approximates the integral up to an error of ft ≤
3M2
t .Since the calculation isn’t done with exact precision, rather with k dig-
its, each added term has an error of 10−k and therefore the total error of this
calculation is bounded by 10−k t + 3Mt
2
Now let’s prove theorem 3.1:

Proof. Let S(f, g) be a surface. Given ε > 0 and p1 , p2 ...pk ∈ BAS(g). Denote
the set At where t ∈ N of all the points (x, y) ∈ BAS(g) for which the numbers
x, y are both rational and can be written with a denominator ≤ t. Run the
following algorithm using fix decimal precision of k digits:
• initiate an array A of size |At |2 .
• for every two points x, y ∈ At if the straight line between them exists -
compute the distance via a straight line using lemma 3.3 above and store
it. Otherwise - sore ∞ as the distance.
• run The Floyd-Warshall algorithm [10] on the the graph who’s nodes are
the set At and with distances given in array A to find the shortest path
between each two nodes. Store the result in array B of size |At |2 .
The time it takes to compute step 2 is by previous lemma 3.3 tΘ(k, k)k 2 and
the time for step 3 is O((|At |2 )3 ) = O(t12 ) overall the algorithm runs in O(t12 +
tΘ(k, k)k 2 )
Given a ε > 0 as the distances between the points pi , pj as in 2.8 is an
infimum - there exist a path Γ(i,j) with length ≤ dS(f,g) (pi , pj )+ 2ε which connects
pi , pj . by lemma 3.2 and the corollary the proceeded it we know that the total
length of the approximated path on At is no more then lenS(f, g)(Γ(i,j) ) +
√
16+8(M1 +M2 )2
t we deduce that the length of each entry in B is up to 2ε +
10
√
16+8(M1 +M2 )2
t the original length. The computation error also adds by lemma
3.3 another 10−k t + 3Mt
2
error so the total error is
q
2
16 + 8 (M1 + M2 ) 3M2
+ 10−k t +
t t
Fix t to be
q
2
3· 16 + 8 (M1 + M2 ) 3M2
t = ⌈max( , )⌉
ε ε
ε
and k = − log10 ( 3t ). And thus we receive that the distance is up to ε - as
needed. The running time is O(t12 + tΘ(k, k)k 2 ) =
 √ 
3· 16+8(M1 +M2 )2 3M2 12
 ⌈max( ε , ε )⌉ + 
O √ 2

 3· 16+8(M1 +M2 ) 3M2 ε ε ε
2 
⌈max( ε , ε )⌉ Θ(− log (
10 3t ), − log (
10 3t )) log (
10 3t )
as needed.
Please note that this algorithm, albeit very simple to understand and analyse
isn’t very efficient. There are ways to improve the above result
4 Solving metric TSP on a surface

In this section we will define the metric TSP problem on the above defined
surface 2.6 and approximate it following the footsteps of [7]. The key observation
for this section is that the proof of the first part of [7] (i.e the construction on
R2 ) works on our settings with minor necessary changes. We give the proof
again ,in full, with those changes.
4.1 Basic definitions

Definition 4.1. Given a surface S(f, g) and a set of points on BAS(g) , i.e
{p1 , ..., pk }, the TSP problem on these settings is: find a permutation s ∈ Sn
such that the sum
n−1
X
d ps(n) , ps(1) + d ps(j) , ps(j+1)
j=1
is minimal and where d is the distance on the surface (2.8) and Sn is the sym-
metry group on n members.
• The path between the points Pi is the permutation s ∈ Sn that gets said
minimum.
11
• the set of points Pi is sometimes refereed to as "cities".
• note that by the definition of distance on a surface, given a path as above,
one could have a polygonal path on BAS(g) which goes through all points
Pi in the right order and who’s total length on the surface is the TSP
minimum up to an additive arbitrary constant.
• We may assume that w.l.o.g
n−1
X 1
dBAS(g) ps(n) , ps(1) + dBAS(g) ps(j) , ps(j+1) ≥
j=1
2
as all of these definitions are scalable (i.e can be multiplied by a fix con-
stant) and given a set of points if the optimal tour is of length < 21 then
all pi are located in a part of BAS(g) and doesn’t cover all of it.
Definition 4.2. Given g ∈ N
• a dissection of [0, 1]2 is a recursive partitioning of it into smaller squares.
• one can view the dissection as a 4-ary tree whose root is [0, 1]2 .
• a dissection of BAS(g) is a dissection of [0, 1]2 along with the squares
sq1 (i) and sq2 (i) (which are paired).
– please note that the dissection lines when viewed on BAS(G) can
cross the squares sqj (i) are therefore aren’t lines on BAS(g).
– we will later add an assumption that such a crossing won’t happen.
• a quadtree of either [0, 1]2 or BAS(g) is a dissection, except we stop the

recursive partitioning at a certain point.
• given a surface S(f, g) and a set of points on BAS(g) , i.e {p1 , ..., pk },
the quadtree w.r.t the above is a dissection for which we stop when every
square of the partitioning contains exactly one of {p1 , ..., pk }.
Definition 4.3. Given a, b ∈ [0, 1], an a, b shift of a dissection (either on [0, 1]
or on BAS(g)) is shifting all the x and y coordinates of all lines by a and b
respectively, if the coordinate come out ≥ 1 only the fractional part is taken
("modulo 1").
Note that with a shift - one may create a "wrapped-around" square (the
square may be split into two or four different squares by the shift) and we view
this as a single.
Definition 4.4. Let m, r be positive integers. An m-regular set of portals for
a shifted dissection is a set of points on the edges of the squares in it. Each
square has a portal at each of its 4 corners and m other equally-spaced portals
on each edge. On the side of each sq1 (i) and sq2 (i) one more portal is placed. A
12
salesman path is a path in BAS(g) (a continues function from [0, 1] to BAS(g))
that visits all the input nodes, and some subset of portals. It may visit a portal
more than once. The salesman path is (m, r)-light with respect to the shifted
dissection (with m portals) if it crosses each edge of each square in the dissection
at most r times and always at a portal and crosses the side of each sq1 (i) and
sq2 (i) at the portal on it and at most twice.
path may or may be a polygonal path.
Notation 4.5. Given a TSP problem on a surface denote OPT to be the dis-
tance of its optimal solution.
‘
4.2 Structure theorem

Lemma 4.6 (Patching Lemma). There is a constant ḡ > 0 s.t for every surface
S(f, g) and for every close path π on it of length lenS(f,g) (π) if S is a another
path which crosses π at least thrice and whose length is lenS(f,g) (S) then there
exist path segments on S whose total length is at most ḡ · lenS(f,g) (S) and whose
addition to π changes it into a closed path π ′ that crosses S at most twice.
Proof. Suppose π crosses S a total of t times. Let M1 , , , Mt be the points on
which p crosses S. Break π at those points, thus causing it to fall apart into t
paths p1 , ..., pt . In what follows, we will need two copies of each Mi . Let Mi′
and Mi′′ denote these copies. Let 2k be the largest even number less than t. Let
J be the multiset of path segments consisting of the following:
(i) A minimum cost salesman tour through M1 , , , Mt .
(ii) A minimum cost perfect matching among M1 , , , M2k .
Where the paths are taken from the segments of S (and not any path between
these points) therefore the line segments of J lie on S and their total length is
at most 3s. We take two copies J ′ and J ′′ of J and add them to π. Now if
′ ′′
t = 2k + 1 (i.e. , t is odd), then we add an edge between M2k+1 and M2+1 . If
′ ′′
t = 2k + 2, then we add an edge between M2k+1 and M2+1 and an edge between
′ ′′
M2k+2 and M2+2 , (Note that these edges have length 0) Together with the paths
p1 , ..., p2k . These added segments and edges define a connected 4-regular graph
on
{M1′ , , , Mt′ } ∪ {M1′′ , , , Mt′′ }
An Eulerian traversal of this graph is a closed path that contains p1 , ..., pt
and crosses S at most twice. Hence we have proved the theorem for g = 6.
Notation 4.7. Let S(f, g) be a surface, l be a path and π be a closed path within
it. Denote t (π.l) to be the number of times π crosses l.
13
Lemma 4.8. Let s(f, g) be a surface. Denote the set At where t ∈ N of all the
points (x, y) ∈ BAS(g) for which the numbers x, y are both rational and can be
written with a denominator ≤ t. Let π̃ be a polygonal path on BAS(g) s.t the
breaking points on π̃ are located only on At , if all sq1 (i) and sq2 (i) corners are
placed on At (where i = 1, 2..., g, view section 2) Then:
X X
t (π̃, l) + t (π̃, l) ≤ 2t·lenBAS(g) (π̃)+2
l horizontal line of the f orm l vertical linek of the f orm
(x, y0 ) | y0 = kt k ∈ N f ixed (x0 , y) | x0 = t k ∈ N f ixed
Proof. Set the lines of the form (x, y0 ) | y0 = kt k ∈ N f ixed on [0, 1]2 (we will

prove the vertical case first). The distance between each two consecutive lines
is 1t . The line π̃ on BAS(g) is straight between every two consecutive lines and
therefore, between every two consecutive lines, the distance (on BAS(g)) that
π̃ had passed is at least 1t . The number
1 X
( t (π̃, l) − 1)
t
l vertical linek of the f orm
(x0 , y) | x0 = t k ∈ N f ixed
is simply the number of intervals (between every two consecutive lines) the line
π̃ had passed times 1t (which is the minimal length the path must pass) and
therefore ≤ lenBAS(g) (π̃). The same argument applies to the vertical lines as
well, and so
1 X
( t (π̃, l) − 1) ≤ lenBAS(g) (π̃)
t
l horizontal line of the f orm
(x, y0 ) | y0 = kt k ∈ N f ixed
By adding the two inequalities together we get

 
 
1 X X 
t (π̃, l) + t (π̃, l) − 2 ≤ 2lenBAS(g) (π̃)
 
t


 l horizontal line of the f orm
l vertical linek of the f orm

(x, y0 ) | y0 = kt k ∈ N f ixed

(x0 , y) | x0 = t k ∈ N f ixed
And by multiplying by t > 0 and adding 2 to both sides we get:

X X
t (π̃, l) + t (π̃, l) ≤ 2t·lenBAS(g) (π̃)+2
As desired.
14
Theorem 4.9 (structure theorem). Given a TSP problem with. Let C > 1 be
a constant, Mi ≥ 0 be a bound on the derivatives of f of order i. Assume the
TSP problem holds:
1
• optimal path on dBAS(g) being larger than 2 (see 4.1 and its remarks).
1
• max1≤i≤g (len (sq1 (i))) ≤ 32g(ḡ+1)·C·M1
Let shifts 0 ≤ a, b ≤ 1 be picked randomly from At (where the value of t will

be given in the proof ). Then with probability at least 21 there is a salesman path
13
of cost at most (1 + 16·C ) · OP T that is (m, r) − light and where m = O(C 2 ·
2
(max(M1 , M2 ) + 1) · log(C · (max(M1 , M2 ) + 1))) and r = O((max(M1 , M2 ) +
1) · C 2 )
Now let’s prove the structure theorem:
Proof. Denote OP T to be the length of the optimalhsales tour.
√ Let Mi ≥ 0 be i
⌈log 8C· 16+8(M1 +M2 )2 ⌉
a bound on the derivatives of f of order i. Set t = 2 .
Let s = 120 · ḡ ·C ·t where ḡ is is the constant appearing in the Patching Lemma,
let r = s + 4. Set m = ⌈2s · (1 + M1 ) · log(t)⌉. ε = OP T
C .
Let π be a polygonal salesman tour which is of length not larger than OP T +
ε. By π’s definition it is a straight line between breaking points. Move each
breaking point of π to At (the same way as in 3.2 and its corollary) and create
new polygonal path - denote it π̃. π̃ is a polygonal path on BAS(g) s.t the
breaking points on π̃ are located only on At , and assume as before all sq1 (i)
and sq2 (i) corners are between At lines (where i = 1, 2..., g). Suppose shift (a,
b) is picked randomly. We prove the Structure Theorem by modifying π̃ over
many steps (using a deterministic procedure) into a salesman path that is (m, r)
- light with respect to the randomly-shifted dissection. This may increase the
tour cost slightly, which we upperbound (in the expectation) as follows. For
accounting purposes, we place a grid of 1t granularity on BAS(g). We "charge"
any cost increase to some (horizontal or vertical) line of the grid. We will show
that for each line l of the grid:
3ḡt (π̃, l)
Ea,b [charge to line l when shift is (a, b)] ≤
s
where ḡ is the constant appearing in the Patching Lemma. By linearity of
expectations, it then follows that the expected increase in the cost of the tour
is
X 3ḡt (π̃, l) X 3ḡt (π̃, l)
+
s s
15
Which is ≤ ( 3ḡ
s )(2t · lenBAS(g) (π̃) + 2) by theorem 4.8. It follows that
3ḡ
( )(2t · lenBAS(g) (π̃) + 2) =
s
3ḡ
( )(2t · lenBAS(g) (π̃) + 2) =
120ḡCt
1
( )(lenBAS(g) (π̃) + 2) ≤
20C
5
( )lenBAS(g) (π̃) =
20C
1
lenBAS(g) (π̃)
4C
1
Where the inequality is due to the face that as lenBAS(g) (π̃) ≥ 2 it holds that
lenBAS(g) (π̃)+2 1
lenBAS(g) (π̃) ≤ 2. Since lenBAS(g) (π̃) ≤ lenS(f,g) (π̃) and due to 3.2 we know
that q
2
16 + 8 (M1 + M2 )
lenS(f,g) (π̃) ≤ lenS(f,g) (π) +
t
due to t’s definition we get
q q
2 2
16 + 8 (M1 + M2 ) 16 + 8 (M1 + M2 ) 1
≤ q =
t 2 8C
8C 16 + 8 (M1 + M2 )
1 1 OP T
and since OP T ≥ 2 we get 8C ≤ 4C Since
OP T
lenS(f,g) (π) ≤ OP T + ε = OP T +
C
We shall receive that
1 1 OP T
lenBAS(g) (π̃) ≤ lenBAS(g) (π) + 2
≤
4C 4C
16c
1 OP T OP T
OP T + + =
4C C 16C 2
1 5 · OP T
OP T + ≤
4C 16C 2
1 5 · OP T
OP T + =
4C 16C
9
OP T
16C
Next we need to add the "charge" of the additional lines segments of sq1 (i) and
sq2 (i). The additional charge of reduction of crossings is the charge form the
patching lemma applied to the segment. That is at most 4g·ḡ·max1≤i≤g (len (sq1 (i)))·
M1 (4 sides of each square g of them). Moreover the additional charge of moving
16
the path to cross at the portal is bounded by 4g · max1≤i≤g (len (sq1 (i))) · M1
(as it takes half the length of the segment to move the path to the portal, and
1
it must be counted twice). As max1≤i≤g (len (sq1 (i))) ≤ 32g(ḡ+1)·C·M1
we know
that the additional charge is
1 1
≤ ≤ · OP T
8C 4C
9
which, together with the 16C OP T gives us an addition of no more than
13
· OP T
16 · C
Thus, to prove the theorem it suffices to describe how we modify the path
π̃ and charge resulting cost increases. As t is a power of 2 all lines used in the
dissection are grid lines. Recall how the dissection with shift (a, b) is obtained:
The middle vertical line of the dissection is moved from the x-coordinate 1/2
to the x-coordinate a + (1/2)mod1, and the middle horizontal line from the
y-coordinate 1/2 to the y-coordinate b + (1/2)mod1. Then, the rest of the
dissection is "wrapped-around" so that the left edge of the dissection comes to
rest at the x-coordinate a, and the lower edge of the dissection comes to rest at
the y-coordinate b. Note that since a, b are both multiplication of 1t , the lines
of the shifted dissection still lie on grid lines.
Recall that squares in a dissection form a hierarchy, and have a natural notion
of "level" (the bounding box is at level 0, its four children are the squares at
level 1, and so on). We say that a grid line l has level i in the shifted dissection
if it contains the edge of some level i square. Note that the edge of a level i
square gets subdivided to yield the edges of two level i + 1 squares, so a line
that is at level i is also at level j for all j > i. For each i ≥ 1 there are 2i
horizontal lines and 2i vertical lines at level i. (To simplify notation, we do not
include the boundaries of the original bounding box in this calculation, since
they do not shift and are also not crossed by the tour.) The vertical lines have
x-coordinates a + p · ( 21i ) mod 1, where p = 0, 1, . . . , 2i − 1 and the horizontal
lines have y-coordinates b + p · ( 21i ) mod 1, where p = 0, 1, . . . , 2i − 1. The
maximal level of a line is the highest level it is at. Since the horizontal shift a is
chosen randomly, we have for each vertical line l in the grid, and each i ≤ log t,
2i
P ra [ l is at level i ] =
t
Of course, a similar statement is true for horizontal lines.
First, we try to make the salesman path (m, s)-light. We will almost succeed
in this; however, at the end we will need to allow 4 more crossings on each square
edge in the quadtree and thus finish with a (m, r)-light salesman path. Recall
what it means for the path to be (m, s)-light. First, for each vertical grid line l, if
i is the maximal level of this line, then for p = 0, 1, . . . 2i − 1, the segment of this
line lying between the y-coordinates b+p·( 2ti ) mod 1 and b+(p+1)·( 2ti ) mod 1 is
crossed by the salesman path at most s times. Second, all these crossings happen
17
at portals. Of course, an analogous statement holds for all horizontal grid lines.
In order to modify the path to satisfy the first condition we call the procedure
MODIFY(l, i, b), which does the patching "bottom up" for all levels j ≥ i. (We
describe the procedure only for vertical lines; the description for horizontal lines
is identical.)
MODIFY(l, i, b)
(l is a vertical grid line, b is the vertical shift of the dissection, and i
is the maximal level of line l )
For j = log (t) down to i do:
For p = 0, 1, . . . 2j − 1, if the segment of l between the y-coordinates
b + p · ( 2ti ) mod 1 and b + (p + 1) · ( 2ti ) mod 1 is crossed by the
current path more than s times, then use the Patching Lemma to
reduce the number of crossings to 4.
Remarks on MODIFY:
• The reader might note that we assume that the number of crossings after
patching is 4, whereas the statement of the Patching Lemma seems to
ensure this number is 2. The reason for the discrepancy is that the segment
could be "wrapped-around", and the patching has to be done separately
for its two parts.
• The salesman path is updated iteratively, so the modifications made for

the j = k iteration of the loop are influenced by the modifications for
j = k + 1, . . . , logt.
• The patching on a vertical line adds to the cost of the salesman path and
could increase the number of times the path crosses a horizontal line. We
ignore this effect for now, and explain at the end of the proof that this
costs us only an additional 4 crossings.
• The structure of the loop (i.e., the fact that j decreases from logt to i) is
important and will be used in the argument that follows.
If j ≥ i, let cl,j (b) denote the number of segments to which we apply the patching
lemma in the iteration corresponding to j in the "for" loop in MODIFY(l,i, b).
Note that cl,j (b) is independent of i since the loop computation for j does not
depend on i. We claim that
t(π̃, l)
cl,j (b) ≤
s−3
The reason is that the tour π̃ crossed line l only t(π̃, l) times, and each of
the applications of the Patching Lemma counted on the left hand side replaces
at least s + 1 crossings by at most 4. Furthermore, the cost increase can be
18
estimated using the Patching Lemma as follows:
t
X q
Increase in tour cost due to MODIFY(l, i, b) ≤ cl,j (b) · ḡ · · M12 + 1
2i
j≥i
X t
≤ cl,j (b) · ḡ · · (M1 + 1)
2i
j≥i
where ḡ is the constant appearing in the Patching Lemma and M1 is the

bound on the first derivative of f . We charge this cost to l. Of course, whether
or not this charge occurs depends on whether or not i is the maximal level of
line l, which by previous argument happens with probability at most 2i /t (over
the choice of the horizontal shift a). Thus, for every vertical line l and every
0 ≤ b ≤ t − 1,
Ea [charge to l when horizontal shift is a]

X 2i
= · cost increase due to MODIFY(l, i, b)
t
i≥1
X 2i X t
= cl.j (b) · g · · (M1 + 1)
t 2i
i≥1 j≥i
X cl.j (b) X
=g· 2i · (M1 + 1)
2j
j≥1 i≤j
X
≤ g · (M1 + 1) · 2 · cl.j (b)
j≥1
2g · (M1 + 1) · t (π̃, l)
≤
s−3
The next modification to the salesman path consists in moving each crossing
to the nearest portal. If a line l has maximal level i, then each of the t(π̃, l)
1 +1)
crossings might have to be displaced by t·(M
2i+1 ·m i.e., half the interportal distance
(on dS (f, g)) to reach the nearest portal. Instead of actually deflecting the edge,
we break it at the point where it crosses l and add to it two line segments (one
1 +1)
on each side of l ) of length at most t·(M
2i ·m , so that the new edge crosses l at
a portal. Thus, the expected increase in the length of the salesman path when
we move every crossing in l to its nearest portal is at most
log(t)
X 2i t · (M1 + 1) t(π̃, l) · (M1 + 1) · log(t)
· t(π̃, l) · im
=
i=1
t 2 m
which is at most t(π̃,l)

2s when m ≥ 2s · (M1 + 1)log(t).
Thus, the expected cost (over the choice of the random shift a) of making
the final salesman path (m, r)-light at line l is
19
2 · g · t(π̃, l) t(π̃, l) 3gt(π̃, l)
+ ≤
s−3 2s s
(Where the last calculation assumes s > 15) This is what we set out to prove.
To finish our proof it only remains to explain our remark (3) on the MOD-
IFY procedure. This concerned the following situation. Whenever we apply
MODIFY on a vertical line l, we use the Patching Lemma and augment the
salesman path with some segments lying on l. These segments could cause the
path to cross some horizontal line l′ much more than the t(π̃, l′ ) times it was
crossing earlier. However, our analysis assumed that the number of crossings
remains constant at t(π̃, l′ ) throughout the modification, and this requires an
explanation. The explanation is simple: we can show that without loss of gen-
erality the increase in the number of crossings at l′ due to the patching on l is at
most 2. The reason is that if the increase were more than 2, we could just use
the Patching Lemma to reduce it to 2. Furthermore, since the Patching Lemma
is being invoked for segments lying on l, these have zero horizontal separation
(that is, they lie on top of each other) and therefore the tour cost does not in-
crease! Also, we apply the patching separately on both sides of l, so the number
of crossings on l does not change. Arguing similarly about all pairs of grid lines,
we can ensure that at the end of all our modifications, each side of each square
in the shifted dissection is crossed by the modified tour up to s 1 4 times. So, as
promised at the start of the proof, we ended up with an (m, r)-light salesman
path. A similar accounting trick explains why we assumed that the t(π̃, l′ )’s are
not affected when we move each edge crossing to its nearest portal.
4.3 Algorithm
Given the above structure theorem. The following algorithm stems out imme-
diately: Randomly select an (a, b) shift and search through all options of an
(m, r) − light path (with the proper m, r) and return the minimum among them
using dynamic programming. This is the basic idea behind the following al-
gorithm. We will describe the algorithm and analyse its running time in this
section.
The dynamic programming uses the following observation: Suppose S is a
square of the shifted quadtree and the optimal (m, r)-light salesman path crosses
the boundary of S a total of 2p < 4r times. Let a1 , a2 , ..., a2p be the sequence
of portals where these crossings occur. (The portals have been numbered in the
order they are traversed by the salesman path. Note that a crossing may occur
on sq1 (i), sq2 (i)) Then the portion of the optimal salesman path inside S is a
sequence of p paths such that
• for i = 1, ..., p , the i-th path connects a2i−1 to a2i .
• together the paths visit all nodes that lie inside S
• the collection of p paths is (m, r)-light
20
In other words, they collectively cross each edge of each square in the quadtree at
most r times, and these crossings always happen at portals. Since the salesman
path is optimal, the above sequence of p paths must be the set of paths that have
lowest cost among all paths with properties above. This observation motivates
us to define the (m, r) multi-path problem. An instance of this problem is
specified by the following inputs:
Definition 4.10. Given a TSP problem and a shift (a, b), a dissection on it
and a pair of (m, r) natural numbers. A partial multi-path problem is specified
by the following:
1. A nonempty square A in the shifted quadtree.

2. A multiset of ≤ r portals on each of the four edges of this square.
3. A multiset of ≤ r portals on each sq1 (i), sq2 (i) that exist within that square.
4. the sum of the sizes of these multisets is an even number 2p ≤ 4r.
5. A pairing (a1 , a2 ), (a3 , a4 ), ..., (a2p−1 , a2p ) between the 2p portals specified
above.
A basic multi-path problem is a multi-path problem with A which contains only
one undivisible square. In other words, a basic multi-path problem is when there
is only one city in A.
Define the following algorithm:
Definition 4.11. Given:
• a surface S(f, g)
• a set of points on BAS(g) , i.e {p1 , ..., pn }, the "cities". Note that n is
the number of "cities".
• constants M1 , M2 which bound the first and second derivatives respectively.
• an algorithm that computes for a given k ∈ N digits point on BAS(g) the

first n digits of the functions f and all its derivatives up to second order
in time Θ(n, k), where we assume Θ(n, k) ≤ O n4 k 4
• a constant C > 1
such that:
1
• optimal path on dBAS(g) being larger than 2 (see 4.1 and its remarks).
1
• max1≤i≤g (len (sq1 (i))) ≤ 32g(ḡ+1)·C·M1
Define the following algorithm to solve the TSP problem

First step -
21
1. define m, r, t as in 4.9.
2. define:
1
ε1 =
32 · (n + m)2 · C
and q
2
3· 16 + 8 (M1 + M2 ) 3M2
t1 = ⌈max( , )⌉
ε1 ε1
3. Pick the shift (a, b) at random from At .
4. calculate the quadtree w.r.t the picked shift and calculate the poratls {˜(p)1 , ..., p̃np }
note that the protals here include the ones on sq1 (i), sq2 (i) for i = 1, ..., g
5. if one or more of {p1 , ..., pn } are with denominator > t1 move it to the
closest number in At1 .
6. for every basic multi-path problem use algorithm 3.1 to compute the dis-
tances between the portals in it and between every portal and the city in
it up to ε1 . Please note that the denominator of all {˜(p)1 , ..., p̃np } is less
than t1 .
Second step -
1. initialize the dynamic programming lookup table by the previously calcu-
lated distances of every two portals within a basic multi-path problem.
2. solve each of the basic multi-path problems by the above distances (for
every two portals of the square with one city within it, the distance is the
distance from the first portal to the city and then to the other portal)
3. use dynamic programming to solve the general case, i.e the multipath prob-
lem which is the entire quadtree
The second step needs further explaining: The goal in the (m, r)-multipath
problem is to find a minimum cost collection of p paths in the square that is
(m, r)-light. The i-th path connects a2i−1 to a2i , and the p paths together visit
all the nodes in the square. (If p = 0, then the goal is to find the optimum (m, r)-
light salesman path for the nodes in the square.) 1 The dynamic programming
builds a lookup table containing the costs of the optimal solutions to all instances
of the (m, r)-multipath problem arising in the quadtree. Once this table is built
the algorithm is done, since the optimal (m, r)-light salesman path occurs as one
of the entries in this table - the one corresponding to the root of the quadtree
and p = 0. Additional explanations for the run of this step is in the proof of
the following theorem:
1 Note that the (m, r)-multipath problem may also be viewed as a multiple traveling sales-
men problem in which a team of salesmen have to visit a set of clients. Each client has to be
visited by some salesman, and each salesman has a designated starting and stopping point,
which is a portal on the boundary.
22
Theorem 4.12. The computing time of the algorithm 4.3 is bounded (the exact
bounding terms will be given in the proof ). For a fixed M1 , M2 , C the running
time is:
O(n25 + n · log(n) · g T (M1 ,M2 ,C) )
For some function T : R3 → R. As a corollary, For a fixed M1 , M2 , C, g the
running time polynomially bounded.
Proof. The idea behind this proof is to follow the steps of the algorithm and
calculate the running time. It must be stressed, all constants except ε1 , t1 are
independent of any direct influence of n which makes the calculation of the
corollary much easier. First step -
• the initialization of the constants ε1 , t1 , a, b are all done in
O( max log2 (x) + log(n))

x∈ε1 ,t1 ,a,b,M1 ,M2
time (the size of the representation).

• picking the shift (a, b) is done in time
q
2
O(log(t)) = O(log 8C · 16 + 8 (M1 + M2 ) )
• calculating the quadtree is done by repeated divisions O(log(n)) times

each division is O(log(t)) time, so O(n log(t)).
• moving the cities to At1 is O(n log(t1 )).
• The step of solving one basic multi-path problem is
 √ 
3· 16+8(M1 +M2 )2 3M2
 ⌈max( ε1 , ε1 )⌉ 12 + 
O
 √ 2 
3· 16+8(M1 +M2 )2 3M2

ε1 ε1 ε1

⌈max( ε1 , ε1 )⌉ Θ(− log10 ( 3t1
), − log 10 ( 3t1
)) log 10 ( 3t1
)
therefore the total cost of this step is

 √ 
3· 16+8(M1 +M2 )2 3M2 12
 n ⌈max( ε1 , ε1 )⌉ + 
O √ 2 
3· 16+8(M1 +M2 )2 3M2

ε1 ε1 ε1
 
n ⌈max( ε1 , ε1 )⌉ Θ(− log (
10 3t1 ), − log (
10 3t1 )) log (
10 3t1 )
The above expression is O(n25 ) when M1 , M2 , C are constants and, as all

other stages are of less running time, this is the running time of this step.
(Please recall that we assumed Θ(n, k) ≤ O n4 k 4 )

23
For the second step - Initializing the entries is O(1) as the values were calculated.
We bound the number of steps taken by the algorithm using the number of
entries in the lookup table. The number of entries in the lookup table is just
the number of different instances of the (m, r)-multi-path problem in the shifted
quadtree. In a quadtree with T nonempty squares, this number is O(T · (m +
g + 4)4r · (4r)!). since for each of the T squares, there are at most (m + g + 4)4r
ways to choose the multiset of portals and at most 4r! pairings among those
portals.
The number of leafs in T is n as every leaf corresponds to a square in the
quadtree with only one city in it. The depth of T is log(n) as every node, which
is not a leaf, corresponds to a square in the quadtree with some cities in it and
its sons to a split of these cities into two or more disjoint sets. Therefore, T is
of size O(n · log(n)).
The table is built up in a bottom-up fashion. Instances at the leaves of the
quadtree contain at most 1 node and O(r) selected portals, so they are solved
optimally in O(r) time, by trying all r ways of placing the single node in O(r)
paths (and all such distances were calculated at the previous stage). Inductively,
suppose the algorithm has solved all (m, r)-multipath problems for squares at
depth > i and let S be any other square at depth i. Let S1 , S2 , S3 , S4 be its four
children in the quadtree. For every choice of multisets and pairing for S, the
algorithm enumerates all possible ways in which an (m, r)-multipath could cross
the edges of S1 , . . . , S4 This involves enumerating all choices for the following:
• a multiset of ≤ r portals on the four inner edges of the children and of
sq1 (i), sq2 (i)s that both lie within the children (note that the outer edges
are part of the edges of S and so we already know where they are crossed
and in what order, the same goes for sq1 (i), sq2 (i) for i where only one of
them is in the square).
• an order in which the portals above are traversed
by the optimum (m, r)-multipath. The number of choices for the multiset is
at most (m + g + 4)4r and the number of choices to order them is at most
(4r)4r ·(4r)! (where the term (4r)4r upperbounds the number of ways of choosing,
for each of the portals chosen in the previous step , one of the ≤ 4r paths in
which it lies). Each choice leads to a (m, r)-multipath problem in the four
children, whose optimal solutions, by induction, already exist in the lookup
table. Adding the cost of these four optimal solutions, the algorithm determines
the cost of the pair of choices . Doing this for each pair of choices shows
the algorithm the optimal choice. Thus, the running time is O(T · (m + g +
4)4r · (4r)4r (4r!)2 ), which is O(n(logn · (m + g + 4)4r · (4r)4r (4r!)2 ).The above
expression is O(n · log(n) · g O(M1 ,M2 ,C) ) when M1 , M2 , C are constants. Thus,
O(n25 + n · log(n) · g constant(M1 ,M2 ,C) ) is the running time when M1 , M2 , C are
constants.
24
Theorem 4.13. The algorithm 4.3 yields a number which is ≤ (1 + C1 ) · OP T ,
and which is
1
≥ (1 − ) · OP T
C
where OP T is the optimal tour length. As a corollary, one may compute the
tour itself (i.e the order in which the path visit the cities) by looking a the lookup
table.
Proof. The algorithm 4.11 will not compute an (m, r)-light path on the real
metric space but an approximation of it. We therefore need to show that the
increase in length isn’t too large and, since the approximation doesn’t corre-
spond to an exact path between the original cities, that the number computed
is ≥ (1 − C1 )OP T .
Denote OP T ′ to be the optimal path length of the modified problem created
by the algorithm. In 4.9 we’ve proved that an (m, r)-light path exist which is
of length ≤ (1 + 1316 ) · OP T
′
Denote OP T to be the length of the optimal tour. In the first step 1 − 4 are
indifferent to the cost of the tour. In 5 we change the place of the cities to be
on At1 , that may change the optimal tour by up to 2n t1 (as every city is moved
up to t11 , there are n of them and one mast take into account the way to and
from each city and its new place). In 6 we use 3.1 to approximate all distances
up to (m + n)2 · ε1 (for each distance the maximum error is ε1 and there are no
more than (m + n)2 of them). So the increased optimal tour is bounded by:
2n
OP T ′ ≤ OP T + + (m + n)2 ε1 ≤(1)
t1
OP T + nε1 + (m + n)2 ε1 ≤(2)
1 1
OP T + + =
32C 32C
2
OP T + ≤(3)
32C
2
OP T + OP T =
16C

2
1+ OP T
16C
Where inequalities (1), (2) are due to t1 , ε1 definitions and the understanding
the minimum of t1 is when M1 = M2 = 0. Inequality (3) is due to the face that
OP T ≥ 12 . Since the size calculated is bounded by ≤ (1 + 16 13
) · OP T ′ we shell
25
receive:
13
(1 + ) · OP T ′ ≤
16C
2 13
1+ (1 + )OP T =
16C 16C

15 26
1+ + OP T ≤
16C 256C 2

15 26
1+ + OP T ≤
16C 256C

1
1+ OP T
C
1

So the length calculated by the algorithm is upper bounded by 1 + C OP T
as needed.
For the lower bound, by the same argument:
2n 2
OP T ′ ≥ OP T − − (m + n) ε1
t1

2
≥ 1− OP T
16C

1
≥ 1− OP T
C
And since the algorithm in step 2 calculates a length which is at least OP T ′ (as it
is a path on the modified problem) the length is lower bounded by 1 − C1 OP T .
Corollary 4.14. The algorithm described in 4.11 can be de-randomize by run-

ning it over all (a, b) pairs in At and selecting the minimum among the runs.
The running time of the de-randomized algorithm is t12 times the running time
of the regular version, which is by 4.12

O T2 (M1 , M2 , C) n25 + T2 (M1 , M2 , C) n log (n) g T (M1 ,M2 ,C)
for some functions T, T2 .
5 embeddings of metrics to surfaces

The basic definition given in 2 and 4.9 may seem a bit artificial. In this section
we will describe the ways in which the algorithm in 4.3 may be used to solve
specific types of TSP cases.
26
5.1 Basic definitions
Definition 5.1. Given f1 , f2 : R2 → R2 two functions with compact support
define the convolution between the two to be
Z Z
f1 ∗ f2 (x, y) = f1 (x − η, y − τ ) f2 (η, τ ) dηdτ
R2
Observations:
• For any f1 , f2 : R2 → R2 two functions with compact support f1 ∗ f2 =
f2 ∗ f1
• If f1 is differentiable then the convolution is too and it holds that:

d d
(f1 ∗ f2 ) (x, y) = f1 ∗ f2 (x, y)
dx dx
and
d d
(f1 ∗ f2 ) (x, y) = f1 ∗ f2 (x, y)
dy dy
Definition 5.2. Define the following function Ψr : R2 → R2 by:

 !
1


 exp − x 2 +y2
1−
r2
x2 + y 2 < r2

 ! !
Ψr (x, y) = R R
exp − 1
dxdy
B(0,r) x2 +y2
1−

r2



0 else
such a function is called a "bump function".

Observations:
• Ψr (x, y) = 0 for any (x, y) with distance from (0, 0) is grater than r (i.e
(x, y) 6∈ B (0, r)).
• It holds that:
Z Z Z Z
Ψr (x, y) dxdy = Ψr (x, y) dxdy = 1
B(0,r) R2
• Ψr is a smooth functions (has derivatives of any order).

• If f1 : R2 → R2 is qan integrable function

2 2
and f1 (x, y) = c for all (x, y) | (x − x0 ) + (y − y0 ) ≤ r
then (Ψr ∗ f1 ) (x0 , y0 ) = c.
• the term (Ψr ∗ f1 ) (x0 , y0 ) is an "averaging" of the values of f1 in the ball
B((x0 , y0 ), r) with weights given by Ψr ,
27
Definition 5.3. Given a, r ∈ R s.t a < r define the following function Φa,r :
R2 → R2 by:
  
 p
exp  √ −1

 2  a≤ x2 + y 2 < r
 x2 +y2 −a
1−
Φa,r (x, y) = r−a
p



1 x2 + y 2 < a
p
x2 + y 2 > r

0
such a function is a prolonged "bump function". This function makes a

smooth transition from 1 to 0 where it is 1 within a ball of radius a and 0
outside the ball of radius r
Definition 5.4. Given a path γ : [0, 1] → BAS(g) and β > 0 a sleeve of width
β along the path γ is the set
{x + y|x ∈ γ ([0, 1]) , ||y|| ≤ β}
5.2 embeddings
2
Theorem 5.5. Given a metric space on n points dn : {1, 2, . . . , n} → R then
a surface (f, g), a set of n points on it (p1 , . . . , pn ) and α ≥ 1 exist s.t
dn (i, j) = α · d(f,g) (pi , pj )
Moreover, one can compute the value of g and estimate f and its derivatives
(the running time analysis will be given in the proof ).
Proof. We will describe here the algorithm to create the saidpembedding. First
step, normalize dn so that all distances will be grater than (2) and this can
be done using the following linear transformation, if needed:
√ dn (i, j)
dnew
n (i, j) = 2
mini′ 6=j ′ dn (i′ , j ′ )
α is this normalization constant. Second step, create BAS(g) and (p1 , . . . , pn )

in it s.t
1
• maxi6=j dBAS(g) (pi , pj ) > 2
• for every i1 , j1 , i2 , j2 , all different from each other, the minimal paths
between pi1 , pj1 and pi2 , pj2 doesn’t intersect.
• for every i1 , i2 , j, all different from each other, the minimal paths between
pi1 , pj and pi2 , pj intersect only at pj .
this is, of course, very easy to create - take [0, 1]2 and place (p1 , . . . , pn ) s.t
3
d[0,1]2 (p1 , p2 ) >
4
28
for every two paths that intersect, add sq1 and sq2 on one the intersecting paths
(before and after the intersection) s.t the [0, 1]2 distance between them is < 8n1 2 .
Note that dBAS(g) (p1 , p2 ) can be reduced up to 2 · n2 · 8n1 2 = 41 , so:
1
dBAS(g) (p1 , p2 ) >
2
This create the desired BAS(g) with g < n2 . Note that our sqs are dots, at the
end they will need to be enlarged (as we don’t allow them to be without length)
but, as we enlarge them to our desire - the condition max1≤i≤g (len (sq1 (i))) ≤
1
32g(ḡ+1)·C·M1 will always hold. Assume that all sqs are added at once. Note
that we don’t assume that all the previously minimal paths on [0, 1]2 are also
minimal on BAS(g) (we only assume that on BAS(g) they don’t intersect).
Denote a > 0 to be the maximal number s.t:
• for every i1 , j1 , i2 , j2 , all different from each other, the sleeves of width a
along minimal paths between pi1 , pj1 and pi2 , pj2 doesn’t intersect.
• for every i1 , i2 , j, all different from each other, the sleeves of width a along
the minimal paths between pi1 , pj and pi2 , pj intersect only at B(pj , a)
(the ball around pj with diameter a).
where all distances are on BAS(g). In simple everyday terms, the above a is
the distance between the minimal paths.
Third step, Denote
a
a′ =
3
Define a function S : BAS(g) → R by S ′ (x, y) = 0 if x, y is a point in
′
BAS(g) which is also in the sleeve of width a3 along minimal path between
pi , pj for some i, j and S ′ (x, y) = maxi′ 6=j ′ dn (i′ , j ′ ) otherwise. The idea here
′
is that the "surface" (S ′ , g) forces the minimal paths in it to be within the a3
sleeve of the original paths of step two. Thus, the path can’t change too much.
We call this a "surface" since S ′ isn’t even continues, in the next step it will be
fixed.
Step four, Define
S(x, y) = (Ψ a3 ∗ S ′ )(x, y)
Please note:
• S is a smooth function, as it’s a convolution with a smooth function.
• S receives 0 in points (x, y) which are in a minimal path between different
cities, As the value is an average of the values of S ′ in B((x, y), a3 ), which
are all 0.
• S receives maxi′ 6=j ′ dn (i′ , j ′ ) in points (x, y) which are outside of a minimal
minimal path sleeve, As the value is an average of the values of S ′ in
′
B((x, y), a3 ), which are all maxi′ 6=j ′ dn (i′ , j ′ ).
29
The above S along with g of the third step creates a surface (f, g). Let i, j
be two indices since a path between pi , pj of length dn (i, j) existed on (S ′ , g)
and since the same path is of the same length in (S, g) it follows that dn (i, j) ≥
d(f,g) (pi , pj ). We should notice that a minimal path between pi , pj in (S, g) can’t
exit the sleeve of width a′ along the minimal paths between pi , pj within BAS(g)
since S(x0 , y0 ) = maxi′ 6=j ′ dn (i′ , j ′ ) outside the sleeve and 0 on pi , therefore, the
increase of the length due to this move (outside of the sleeve) is enough to make
the path non-minimal (as the increase is as least maxi′ 6=j ′ dn (i′ , j ′ )). Once we
understand that the minimal path is bounded within the sleeve we can curb it’s
length based in this fact.
Step five, For every pair (i, j)
• calculate d(S,g) (pi , pj )
• fix a point (x0 , y0 ) on the minimal path between (pi , pj ) where B((x0 , y0 ), a′ )
doesn’t intersect any other sleeve (this is very easy as all points do that
except those at the B(pi , a′ ) end of the path)
• redefine S as follows:
(dn (i, j) − d(Sold ,g) (pi , pj ))
Snew (x, y) = Sold (x, y) + · Φa′ ,a (x − x0 , y − y0 )
2
Note:
• the redefinition of one pair doesn’t affect the length of the other paths (as
the Φ function is only non-zero in the sleeve of the relevant path.
• minimal paths can’t leave the sleeves even after the addition of Φs (as it
still "costs" too much, the same way it did in step 3).
√
• it holds that dn (i, j) ≥ d(Sold ,g as dn (i, j) ≥ 2 due to step 1 and
√
d(Sold ,g) ≤ 2) due to the fact it’s a straight line within [0, 1]2 (perhaps
with missing pieces in between).
The added cost to a path within the sleeve between (pi , pj ) is dn (i, j)−d(Sold ,g) (pi , pj )
provided it goes only once (both on the increase and decrease of the bump) As
any such path must climb to half the hight and and go back down .Therefore, as
the paths are minimal (and therefore can’t go more than once) the new paths
are of length dn (i, j) as desired. The final S after this step is f .
That’s the end of the proof, now let’s analyse the running time it takes to
calculate the said S and g:
1. The first step can be done in
O(n2 · max(log dn (i, j))

i6=j
since there are not more than n2 pairs to update and maxi6=j (log dn (i, j))
is a bound on the size of the representation of number updated.
30
2. The second step can be done O(n4 ) by fixing the points (p1 , . . . , pn ) and
going over each i1 , j1 , i2 , j2 and i1 , i2 , j to make sure non are intersecting
inappropriately.
3. the value of a can be calculated O(n4 · maxi6=j (log dn (i, j)) as:
(a) it’s easy to calculate minimal distance between two straight line seg-
ments (by solving the two equations in two variables) and the solution
(and the time to calculate it) depends on the size of the representa-
tion of the numbers, which is no grater than maxi6=j (log dn (i, j))
(b) there are at most O(n4 ) pairs of straight line segments as each line
segment was created in the second step by splitting a crossing two
lines.
4. the third step can be done in O(n4 · maxi6=j (log dn (i, j)) as a is the only
part of it that need to be calculated up front.
5. moreover, the value of S ′ on a point (x, y) can be calculated in O(maxi6=j (log dn (i, j)+
log(x) + log(y)) (sizes of the representations)
6. step four is O(1) as nothing needs to be calculated up front.
7. step five is a49 ,this is the non polynomially bounded part and it will be
explained below.
8. the value of S, of step four, on a point (x, y) up to ε > 0 can be calculated
in O(( log dn (i,j)+log(x)+log(y)
ε )2 ) time by approximating the integral.
9. the value of S, of step five, on a point (x, y) up to ε > 0 can be calculated
in O(log2 (a · ε)) additional operations by approximating the Φ function
on the appropriate point.
Elaboration on step five: This step consists of calculation of d(Sold ,g) (pi , pj ))
for each pair and fixing a point on it. In 3.1, we saw how to calculate the
distances between set of points. By looking at the tables of that algorithm one
may view the (approximate) shortest path and so find a point on that path. The
above algorithm assumed M1 , M2 (bounds on the first and second derivatives
respectively) and Θ(n, k) which is a bound on the running time to compute f
(the surface function) given k digits and up to n digits. In this case,note, that
the only non-fixed variable in this system is a as Φa′ ,a depends only on that
constant. So, the above variable correspond to:
• M1 ≤ O( a12 )
• M2 ≤ O( a14 )
• Θ(k, k) ≤ O(((maxi6=j log dn (i, j) + k) · k)2 ) as seen above (this is approx-
imation of the integral on step four)
31
by using the above substitutions, and by using the running time in 3.1, we know
the running time to compute the fifth step with up to ε accuracy:
a48
O( )
ε
ε is the accuracy, which in our case needs to be O( 1a ) as well. That fives us a49
for this step.
Corollary 5.6. • The above construction 5.5 holds that
n−1
X 1
dBAS(g) ps(n) , ps(1) + dBAS(g) ps(j) , ps(j+1) >
j=1
2
as one of the distances on BAS(g) was chosen to be > 21 , and the total
TSP cost must be, by the triangle inequality, must be larger than any one
distance.
• The above construction case be done using polygonal lines instead of straight
ones.
Now we prove a simple lemma which will be useful later in this chapter.
Lemma 5.7. Given a series of metrics dk for k ∈ N s.t:
• all metrics are uniformly bounded, i,e: dk (x, y) < L1 for every k ∈ N, x, y
in the respective metric space and L1 > 0 constant.
• the number of points/cities in the metric space dk is bounded by n0 .
maxx,y∈{1,...,n} dk (x,y)
• the size minx,y∈{1,...,n} dk (x,y) is uniformly bounded by L3 > 0 constant.
If we embed dk for k ∈ N using 5.5 and receive fk , gk then fk and its fist
and second derivatives are uniformly bounded by constants which depends on
L1 , L3 , n0 . Moreover the running time of the algorithm is bounded by a function
of these constants as well.
Proof. The proof is basically going over the step of 5.5 and seeing that under
such conditions fk and its fist and second derivatives are indeed bounded:
• first, the normalization factor α is bounded as the minimum distance is
bounded by:
maxx,y∈{1,...,n} dk (x, y) maxx,y∈{1,...,n} dk (x, y) L1
< L3 ⇒ min dk (x, y) > >
minx,y∈{1,...,n} dk (x, y) x,y∈{1,...,n} L3 L3
• The second step can be done uniformly for all k ∈ N for n = n0 .

• a of the second step and a′ of the third step is, therefore, independent of
k.
32
• S ′ and S of the third step and forth step are independent of k, as they are
directly defined from the second step (which was done independent of k).
• Step five is also bounded as the metric dk has a bounded maximal distance.
Therefore, the worst case of f and it’s derivatives (first and second order)
is given by the case dk (i, j) = L1 .
About the running time, stages 1-4 of the running time analyses are all bounded
based on these constants. stage 5 is also bounded by L1 , L3 , n0 by choosing
points x, y to embed with a representation no larger than O(log(n0 )). stage 6 is
a constant time step. Stages 7-9 are all bounded by L1 , L3 , n0 simply by always
choosing paths that don’t get too close to one another. As the number of cities
are bounded and the distances are bounded as well, it can be done.
2
Lemma 5.8. Given a metric space on n points dn : {1, 2, . . . , n} → R then a
surface (f, g), a set of n points on it (p1 , . . . , pn ) exist s.t
dn (i, j) = d(f,g) (pi , pj )
Moreover, one can compute the value of g and estimate f and its derivatives,
the running time are the same as 5.5.
2
Proof. Given dn : {1, 2, . . . , n} → R the proof is divided into two possibilities
based on the normalization of 5.5: If, in step 1 of the algorithm no normalization
is done, than we already have said (f, g). Otherwise, α > 1 is the normalization
factor. One need to normalize f back by
1
fnew (z1 , z2 ) = · f (z1 · α, z2 · α)
α
As we’ve changed to domain of the function, fnew is now defined on a BAS(g)′
which is based on [0, α1 ]2 (and not [0, 1]2 ). To match our previous definitions,
place [0, α1 ]2 on [0, 1]2 . As f had fixed values on the rims of BAS(g), fnew has a
fixed value on the rims of [0, α1 ]2 and therefore can be extended to [0, 1]2 r[0, α1 ]2
with a constant extension (i.e define fnew on these points as the value it has on
the rim of [0, α1 ]2 ). Note that we received a new BAS(g) and a new f which
has the same properties as the original, up to normalization, i.e
d(f,g) (pi , pj )
d(fnew ,g′ ) (p′i , p′j ) =
α
where p′i , p′j are the equivalent cities after normalization. And as f embedded
dn with a factor of α, fnew cancels this exact factor.
2
Lemma 5.9. Given two metrics d1 , d2 : {1, 2, . . . , n} → R s.t d2 (x, y) =
γ · d1 (x, y) where 0 < γ < 1, if (f2 , g) is the embedded d2 by using 5.8 and
if f2 ’s second derivatives are bounded by M2 than the d2 embedding (without
normalization factor used) (f1 , g) second derivatives are bounded by γ1 · M2
33
Proof. The idea here is simple: by the way it was constructed the embedded f1
is a γ stretch of f2 . So,

x y
f1 (x, y) = γ · f2 ,
γ γ
and of course as we’ve changed to domain of the function, f1 is now defined on
a BAS(g)′ which is based on [0, γ]2 (and not [0, 1]2 ). As before, place [0, γ]2 on
[0, 1]2 and extend the fixed value on the rims of f1 to fill all of BAS(g). By the
chine rule
∂2 ∂2

x y
f1 (x, y) = γ · f2 , =
∂x∂y ∂x∂y γ γ
1 ∂2
· f2 (x0 , y0 ) |x0 = γx ,y0 = γy
γ ∂x∂y
1
≤ · M2
γ
and the same argument applies to all other second order derivatives. And so we
see that the bound on f1 second derivative is γ1 · M2 .
Corollary 5.10. Using the above embedding 5.5 and 4.3 one can compute the
1
C approximation of the TSP problem of any metric space on n points dn :
1, 2, . . . , n2 → R. That is due to the fact that the TSP problem and (1 +
1
C ) approximations of it are scalable. Note that since in 5.8 the derivatives of
f are not uniformly bounded, the running time of this algorithm may not be
polynomially bounded.
Theorem 5.11. Given n ∈ N the uniform metric on n can be embedded on a
surface (f, g) s.t f = 0
Proof. The proof is simply a construction of the said embedding. A uniform
metric on n cities is simply a metric d : {1, 2, . . . , n}2 → R s.t d(x, y) = c1 for a
fixed c1 > 0 (for any x, y ∈ {1, 2, . . . , n}. We will assume, as all is scalable, that
3
c1 > 0 is small enough, c1 = 4·n is one such choice. This construction will give
2
n −n
us a g = 2 embedding,but more economical exist.
• take n circles of radius c21 and place them on [0, 1]2 s.t no two circles are
touching or overlapping. We will assume, as all is scalable, that c1 > 0 is
small enough that it is possible.
• place, on the center of each circle a city pi .
• for each pair of circles place a sq1 (i) and sq2 (i) which connect the two.
sq1 (i), sq2 (i) should be placed on the outer ring of the circle, i.e within a
distance of c22 from the respective city in the middle.
• i is an index of the pair been connected and therefore
n2 − n

n
1≤i≤ =
2 2
34
• the placement of the circles within [0, 1]2 is unimportant as long as no two
circles touch or overlap.
• the placement of sq1 (i), sq2 (i) is unimportant as long as it’s done on the
outer ring of the circle.
First, the line the goes from one city x to the appropriate sq1 (i) or sq2 (i) and
from there to city y is exactly c1 in length, for any two cities x, y. Moreover,
any line that connects the two cities x, y must go,at least, from the center of x’s
circle to the outer ring of that circle and back from the outer ring of y’s circle to
the center. As this journey alone is of length c1 the above route must be minimal
and therefore all distances between two different cities is c1 as desired.
3
Corollary 5.12. The above construction when preformed with c1 = 4·n holds
that
n−1
X 3 1
dBAS(g) ps(n) , ps(1) + dBAS(g) ps(j) , ps(j+1) > >
j=1
4 2
3
as every distance in the sum is 4·n and there are n + 1 such distances summed
up.
5.2.1 embeddings of a doubling dimension metric

Definition 5.13. A metric d : {1, 2, . . . , n}2 → R is called m > 0 doubling if
every ball of radius r > 0 can be covered by, at most, m balls of radius 2r . the
minimum such m is called the doubling constant.
Definition 5.14. Given two metrics d1 , d2 on the same finite metric space
{1, 2, . . . , n} saying that the distortion between them is ≤ (1 + C) (for C > 0)
is exactly the same as saying
∀x, y ∈ {1, 2, . . . , n} d1 (x, y) ≤ (1 + C) · d2 (x, y)
and
∀x, y ∈ {1, 2, . . . , n} d2 (x, y) ≤ (1 + C) · d1 (x, y)
We say that the distortion is (1 + C) if C is minimal w.r.t to above inequalities.
Theorem 5.15. Given a doubling metric d : {1, 2, . . . , n}2 → R with m > 0
doubling constant and another constants C > 0. Another doubling metric d1 :
{1, 2, . . . , n}2 → R metric and a surface (f, g) exists along with a set of points
p1 , . . . , pn and α > 0 s.t d(x, y) = α · d1 (x, y) where x, y ∈ {1, 2, . . . , n}2 and the
metric induced from (f, g) on p1 , . . . , pn equals d1 up to distortion of 1 + C s.t
the bounds M1 , M2 of the first and second derivatives of f are independent of n
(the number of cities), they will depend on m, C. Moreover, the algorithm that
computes that embeddings does so in running time of
T1 (C,m)
2 maxx,y∈{1,...,n} d (x, y)

n · S(C, m)
minx,y∈{1,...,n} d (x, y)
35
where S, T1 are some functions of C, m. And
14(1+C) 2 maxx,y∈{1,...,n} d1 (x, y)

g < nm⌈log2 ( C )⌉ log
( 4+4C )
4+3C minx,y∈{1,...,n} d1 (x, y)
In other words, the metric d can be embedded in a surface of a bounded deriva-

tives upto a normalization factor.
The idea here is that a doubling metric can’t have too many cities with
long distances from one another. Therefore, we can divide all cities into "major
hubs" which have a long distance between each other and other cities which
have a major hub in their proximity. The idea is to create a recursive algorithm:
embed a major hub along with all of it’s cities in proximity (using this algorithm
in recursion), embed the set of major hubs using 5.8 and "stitch" the double
represented notes using sqi s. For a small enough set, that is the base case,
one can use the proof of 5.8. As all cities with small distances were embedded
in the recursive case, the only real discrepancy between the metric and the
embedded metric are the cities which are long distant from each other. Those
cities must instead go through a hub first. But as the distance between them was
large, the additional trip to the hub and back will be insignificant. The reason
f ’s derivatives bounds will be bounded by a function of m, C is that the only
dependency of the above algorithm on n is the depth to which the algorithm will
go. One could circumvent that growth by choosing a small enough normalization
factor and thus ensuring f ’s derivatives bounds to be independent of n. Now
for the full details:
Proof. This algorithm will be a recursive one. Given d a doubling metric on
n cities, we assume C < 1. In case C ≥ 1, choose a smaller C and as the
conditions are stricter for a smaller C the proof will be valid as well.
Denote
2 maxx,y∈{1,...,n} d(x,y)
−2 log 4+4C
( 4+3C )
14(1+C)
2m⌈log2 ( )⌉ minx,y∈{1,...,n} d(x,y)
C
α=
maxx,y∈{1,...,n} d (x, y)
and
d1 (x, y) = α · d(x, y)
The base case for this algorithm is when n = 1, in that case - the embedding
is simply one point. One can use a more sophisticated base case as n < n0 for
a fixed n0 , in which case the embedding given by the proof of 5.8. We will now
describe the recursive case.
Denote, L1 = maxx,y∈{1,...,n} d1 (x, y).
For each x ∈ {1, . . . , n}:
• L2 (x) = maxy∈{1,...,n} d1 (x, y).

C
• r (x) = 1 − 4(1+C) L2 (x).
36
C·(minx∈{1,...,n} L2 (x))
and denote L = 7(1+C) .
Please note that as L1 is the maximum distance between two cities, it must
be that L2 (x) ≥ L21 for every x ∈ {1, . . . , n}. And thus, L > 14(1+C)C·L1
. This
shows that L is free of a direct dependency of n.
Choose a subset KL ⊆ {1, . . . , n} such that the distance between every two
points on KL is L or more and which is maximal under containment (i.e there
is no element that could be added to it from 1, . . . , n and the condition will still
L1 14(1+C)
hold). Please note that |KL | ≤ m⌈log2 ( L )⌉ ≤ m⌈log2 ( C )⌉ where m is the
doubling dimension (as that’s the maximum disjoin circles of radius L1 available
under such doubling dimension).
Since KL was maximal, it follows that every element in y ∈ {1, . . . , n} r KL
has a element x ∈ KL s.t d1 (x, y) < L. Divide {1, . . . , n} into |KL | sets {Tx |x ∈
KL } s.t within each Tx every y ∈ Tx has distance < L to x.
As r(x) < L2 (x) (remember 0 < C < 1) it must be the case that every
B(x, r(x)) for x ∈ KL doesn’t contain all cities (as there is a city with distance
L2 (x) from x). Denote the following new metric on the cities of B(x, r(x)):
dB(x,r(x))-new (y1 , y2 ) = 2 · |KL | · d1 (y1 , y2 )
Note that the new metric is a multiplication of the old one. We can assume
that there is an embedding (with the same properties as we desire) for the set
B(x, r(x)) ⊂ {1, . . . , n} for every x ∈ KL along with new metric, as the problem
is of smaller size. Using it we’ll and show an embedding for d1 .
Take [0, 1] and divide it into 2 · |KL | equal segments. By multiplying we get
2
[0, 1]2 along with 4 · |KL | square segments. For each x ∈ KL choose a different
square segment s.t, if you index the square segments from the bottom left corner,
no square segment with even index on either coordinate will be chosen (this is
to make sure that no adjacent square segment are chosen). Choose another such
square segments for KL itself. For each x ∈ KL :
• Take the embedding of dB(x,r(x))-new
1
• Shrink it by multiplying it by 2·|KL | :
– The multiplication is applied to both the BAS(g) and f , i.e a value

of a point f (z0 , z1 ) on the original domain is mapped to
1
· f (2 · |KL | · z0 , 2 · |KL | · z1 )
2 · |KL |
– As both the domain and the function are multiplied by a number

smaller than 1, the bounds on the derivatives are the same (or re-
duced).
1
– The new embedding is placed on [0, 2·|K L|
]2 instead of [0, 1]2
1
• As the new embedding is placed on [0, 2·|K L|
]2 place the chosen square
segment for that x ∈ KL .
37
Next, denote the following new metric on the cities of KL :
dKL -new (y1 , y2 ) = 2 · |KL | · d1 (y1 , y2 )
use 5.8’s algorithm to embed dKL -new with its KL elements. Shrink the embed-
1
ding by multiplying it by 2·|K L|
(the same way we’ve done above) and place it
on the square segment for that KL that was chosen before.
So far we’ve received an embedding but some cities have multiple represen-
tation, one from each embedding that they appear on. These representations
are different. To solve this problem we add a pair of sq1 and sq2 to merge each
two representations of the same city. We will assume that the different repre-
sentations have distance 0 from one another. This assumptions is justified as
the distance between sq1 and sq2 can be as small as we’d wish and the distance
between sq1 and the city (and sq2 and the other city) can be as small as we’d
wish as well. And such a distance is independent of the bounds M1 , M2 , as f
isn’t change in value. The last thing to build is the function f on the square
segments that were not chosen. As no two adjacent segment were chosen be-
fore, it must be that any two embedded square segments are separated by an
empty one (or more). We need to "match" the ends of the two embedded square
segments so f will remain smooth and we need to make sure no path between
cities will pass these empty square segments. This is done by first defining f¯ on
the empty segments by dividing up the empty squares segments into 3 parts,
the value of f¯ will be the same as in the rim of the closest embedded square
segment up to 32 · |KL | the distance from that rim. In the middle define f¯ to be
L1 . This f¯ is obviously not continuous, so in order to make it smooth convolute
it with a bump function (see 5.2 and 5.1). Specifically define f as
f = Ψ 62 ·|KL | ∗ f¯
On (y1 , y2 ) where (y1 , y2 ) isn’t closer than 62 · |KL | to the rim. Otherwise f = f¯.
Note that 26 · |KL | is simply 16 of the square segment’s size.
Thus, we received an embedding (f, g), now let’s prove it’s properties. First,
this embedding gives a metric which is d1 up to (1 + C) distortion. The idea
here is simple, given y1 , y2 ∈ {1, . . . , n} two cities. There are 2 cases, if y1 , y2 ∈
B(x1 , r(x1 )) for some x1 ∈ KL then the (1 + C) distortion comes from the
fact that we assumed B(x1 , r(x1 )) was embedded with the same distortion.
Otherwise, y1 , y2 must be a long distance from each other, and therefore the
fact that we make the journey between them go through some hub city won’t
be as significant w.r.t the total length. Here are the details:
Take y1 , y2 ∈ {1, . . . , n} two cities. There are several cases:
• if exist one x1 ∈ KL s.t y1 , y2 ∈ B(x1 , r(x1 )) and d1 (y1 , y2 ) < d(f,g) (y1 , y2 )
then both y1 , y2 came from the same embedding of the dB(x1 ,r(x1 ))-new
metric of x1 . Since we assume the correctness of the previous steps this
38
embedding is of (1 + C) distortion of dB(x1 ,r(x1 ))-new metric. So:
1
d(f,g) (y1 , y2 ) =(1) · dembedded (y1 , y2 )
2 · |KL | B(x1 ,r(x1 ))-new
1
≤(2) · (1 + C) · 2 · |KL | · d1 (y1 , y2 )
2 · |KL |
= (1 + C) · d1 (y1 , y2 )
where
– dembedded
B(x1 ,r(x1 ))-new is the embedded metric of dB(x1 ,r(x1 ))-new .
– equality (1) comes from the of construction of d(f,g)

– inequality (2) comes from the definition of dembedded
B(x1 ,r)-new and the fact
it (1 + C) approximates dB(x1 ,r(x1 ))-new .
• if exist one x1 ∈ KL s.t y1 , y2 ∈ B(x1 , r(x1 )) and d1 (y1 , y2 ) > d(f,g) (y1 , y2 )
then by the same logic y1 , y2 came from the same embedding of the
dB(x1 ,r)-new metric of x1 . So:
1
d(f,g) (y1 , y2 ) =(1) · dembedded (y1 , y2 )
2 · |KL | B(x1 ,r)-new
1 1
≥(2) · · 2 · |KL | · d1 (y1 , y2 )
2 · |KL | (1 + C)
1
= · d1 (y1 , y2 )
(1 + C)
where the previous 3 explanatory bullets apply here as well.

The careful reader may ask what happens if exist more than one x1 ∈ KL , say
x1 , x2 ∈ KL s.t y1 , y2 ∈ B(x1 , r(x1 )) and y1 , y2 ∈ B(x2 , r(x2 )). In such a case
the inequalities above will hold to both x1 , x2 and thus the journey between the
cities (which is the minimal journey on B(x1 , r(x1 )) or B(x2 , r(x2 ))) will still
hold the (1 + C) distortion condition. The same will hold true for more than 2
such x ∈ KL .
Now for the other cases: Note that if x1 , x2 ∈ KL then
d(f,g) (x1 , x2 ) ≤ d1 (x1 , x2 )
as a path with exactly the length d1 (x1 , x2 ) exist within (f, g) so d(f,g) (x1 , x2 )
can’t be larger then d1 (x1 , x2 ).
Moreover if no x1 ∈ KL exist s.t y1 , y2 ∈ B(x1 , r(x1 )). Denote x2 ∈ KL to
be the element in KL s.t y2 ∈ Tx2 then d1 (y1 , x2 ) > r(x2 ) and thus
d1 (y1 , y2 ) + L ≥ d1 (y1 , y2 ) + d1 (y2 , x2 ) > d1 (y1 , x2 ) > r(x2 )
by subtracting L from both sides we get d1 (y1 , y2 ) > r(x2 ) − L.
39
So, if no x1 ∈ KL exist s.t y1 , y2 ∈ B(x1 , r(x1 )) and d1 (y1 , y2 ) < d(f,g) (y1 , y2 )
,denote x1 , x2 ∈ KL to be the elements s.t y1 ∈ Tx1 and y2 ∈ Tx2 as y1 6∈
B(x1 , r(x1 )) it must be that x1 6= x2 .
d(f,g) (y1 , y2 ) (1) d(f,g) (y1 , x1 ) + d(f,g) (x1 , x2 ) + d(f,g) (x2 , y2 )

≤
d1 (y1 , y2 ) d1 (y1 , y2 )
(1 + C) d (y
1 1 , x1 + d(f,g) (x1 , x2 ) + (1 + C) d1 (y1 , x1 )
)
≤(2)
d1 (y1 , y2 )
(1 + C) L + d (x
1 1 , x2 + (1 + C) L
)
≤(3)
d1 (y1 , y2 )
(1 + C) 2L + d1 (x1 , x2 )
=
d1 (y1 , y2 )
(1 + C) 2L + L2 (x1 ) (5)
≤(4) < 1+C
r (x1 ) − L
Where
• inequality (1) is due to the triangle inequality
• inequality (2) is due to the fact that y1 , x1 ∈ B(x1 , r(x1 )) and y2 , x2 ∈
B(x2 , r(x2 )) (and we’ve proven that case above)
• d(f,g) (x1 , x2 ) < d1 (x1 , x2 ) as x1 , x2 ∈ KL , that’s inequality (3)
• inequality (4) is due to the fact that d1 (y1 , y2 ) > r(x1 )−L where y1 ∈ Tx1 .
2 (x1 )
The last inequality (5) is equivalent to r (x1 ) − 3L > L(1+C) and holds due to
the way r (x1 ) , L, L2 (x1 ) defined, as follows:

C · minx∈{1,...,n} L2 (x)

C
r (x1 ) − 3L = 1 − L2 (x1 ) − 3
4 (1 + C) 7 (1 + C)

C C · (L2 (x1 ))
≥(1) 1 − L2 (x1 ) − 3
4 (1 + C) 7 (1 + C)

C C · (L2 (x1 ))
>(2) 1 − L2 (x1 ) −
4 (1 + C) 2 (1 + C)

4 + 4C − C 2C
= − L2 (x1 )
4 (1 + C) 4 (1 + C)

4 + 2C
= L2 (x1 )
4 (1 + C)

1
≥(3) L2 (x1 )
(1 + C)
where:
• inequality (1) is due to the fact that the minimum is smaller than every
element in the set.
40
• equalities here are simple algebra.
3 1
• inequality (2) is due to 7 < 2
• inequality (3) is due to C > 0.

On the other side, If no x1 ∈ KL exist s.t y1 , y2 ∈ B(x1 , r) and d1 (y1 , y2 ) >
d(f,g) (y1 , y2 ), by our construction, every path within (f, g) between y1 , y2 must
go through one or more of the dually represented cities, as the crossing be-
tween different square segments isn’t possible (the was the way they were con-
structed). Denote these cities as x′i where i = 1, . . . , k and thus d(f,g) (y1 , y2 ) =
Pk−1
d(f,g) (y1 , x′1 ) + i=1 d(f,g) (x′i , x′i+1 ) + d(f,g) (x′k , y2 ) So, if no x1 ∈ KL exist s.t
y1 , y2 ∈ B(x1 , r) and d1 (y1 , y2 ) > d(f,g) (y1 , y2 ) then:
k−1
X
d(f,g) (y1 , y2 ) = d(f,g) (y1 , x′1 ) + d(f,g) (x′i , x′i+1 ) + d(f,g) (x′k , y2 )
i=1
k−1
!
1 X
≥(1) d1 (y1 , x′1 ) + d1 (x′i , x′i+1 ) + d2 (x′k , y2 )
1+C i=1

1
≥(2) d1 (y1 , y2 )
1+C
where
• inequality (1) is due to the fact that every pair is within one of the previous
cases (i.e either in B(x1 , r(x1 )) for some x1 ∈ KL or both start and end
city are in KL ).
• inequality (2) is due to generalized triangle inequity.
And thus we’ve proved that the embedded metric is indeed (1 + C) approx-
imation of d1 . Now, let’s prove the time bound on the above algorithm: First
we’d like to prove the depth of the recursion . We’d prove that the depth is at
most check.
Denote
• L3 = minx,y∈{1,...,n} d1 (x, y)

C C
Recall that r (x) = 1 − 4(1+C) L2 (x) and thus r < 2 · 1 − 4(1+C) · L1 .
Recall that 0 < C < 1 and so

C
0< 1− <1
4 (1 + C)
The algorithm preforms a recursion step (calls itself) over a subset B(x, r(x))
of cities. Note that as normalization won’t change the number of cities, it
won’t change the depth of the recursion. One can simply view each recursion
as subset of {1, . . . , n}. At each stage a percentage of the distance is removed.
41
The minimum distance between two cities is L3 and the maximum distance is
L1 . Given a run of algorithm and a single step at depth i denote ri to be the
maximum radius from any x, at stage i without normalization (i.e the distances
on d1 of
only the relevant
cities selected in this stage). We get r0 ≤ 2 · L1 and
C
r1 ≤ 2 1 − 4(1+C) · L1 and by the same logic
i
C
ri ≤ 2 1 − · L1
4 (1 + C)
If ri < L3 the number of cities in this stage must be 1 and thus, in such case,
we got to the base case and no further recursion is possible. The inequality we
therefore receive for i is
i
C
L3 > 2 1 − · L1
4 (1 + C)
i
C L3
1− <
4 (1 + C) 2L1
i
4 + 3C L3
<
4 + 4C 2L1
i
4 + 4C 2L1
>
4 + 3C L3
2L1
i > log( 4+4C )
4+3C L3
So, the depth is no more than log( 4+4C ) 2L

L3 .
1
4+3C
Next, the fan-out. As the algorithm calls itself on, at most |KL | times at
each stage and as we recall
L1
|KL | ≤ m⌈log2 ( L )⌉
C·L1
where m is the doubling dimension. As L > 14(1+C) we get that
!
L1
⌈log2 C·L1 ⌉ 14(1+C)
m 14(1+C) = m⌈log2 ( C )⌉
is a bound for the fan out of each stage. Therefore, a bound on the total calls
of the algorithm will be the fan-out bound to the power of the depth:
2L1
⌈log2 ( 14(1+C)
C )⌉·logm 2L
L3
1
⌈log2 ( 14(1+C) )⌉·log
m
C
( 4+4C
4+3C ) L3
=m logm (
4+3C )
4+4C
14(1+C)
⌈log2 ( C )⌉
2L1 logm ( 4+4C
4+3C)
= m
L3
42
So, the bound on the total number total calls of the algorithm is
T1 (C,m)
2 maxx,y∈{1,...,n}d1 (x,y)

minx,y∈{1,...,n}d1 (x,y)
where T1 (C, m) is a function of C, m. Next, we need to analyse the number of

computational steps preformed at each call of the function:
• each step of the algorithm embeds the set KL . As this set is of a bounded
size, this is a bounded step.
• each step of the algorithm preforms multiplications and placement of func-
tions of the previous step.
The way all of the multiplications and placements can be implemented is by
using a list of cities and, list of sqi s, and a list of constants for the multiplications
which will be updated in each step of the algorithm. The list of cities is of size
2 maxx,y∈{1,...,n}d1 (x,y) T1 (C,m)

n. The list of list of sqi s is of size ≤ n minx,y∈{1,...,n}d (x,y)
(as for each
1
call of the previous steps we can make at most two sqi for each city) and the list
2 maxx,y∈{1,...,n}d1 (x,y) T1 (C,m)

of constants for the multiplications is of size ≤ minx,y∈{1,...,n}d (x,y)
.
1
As KL is of size independent of n we know this step will be done in T2 (C, m)
for some function T2 of C, m. All in all we know that the total time it takes for
the algorithm to preform one step is bounded by n · S(C, m) where S(C, m) is
some function of C, m. So, we receive that the total bound on running time is:
T1 (C,m)
2 maxx,y∈{1,...,n} d1 (x, y)

n · S(C, m)
minx,y∈{1,...,n} d1 (x, y)
which is T1 (C,m)

2 maxx,y∈{1,...,n} d (x, y)

n · S(C, m)
minx,y∈{1,...,n} d (x, y)
as needed.
Now let’s prove that the above f has bounds on its first and second deriva-
tives which are independent of n:
The value of f and its derivatives depends on the value of the functions given
from previous recursive steps and on the size of the embedding of KL alone.
14(1+C)
The size of KL is bounded by m⌈log2 ( C )⌉ , as seen before. The embedding
of KL is bounded as the size of the set is bounded and the distances are bounded
C·L̄1
(they are ≥ L > 14(1+C) and ≤ L̄1 where L̄1 is the maximal distance of the
recursive metric). Recall 5.7, under such conditions the f and its first and
second derivatives are bounded.
Next, we need to analyse the maximal distance of dB(x,r(x))-new at any stage
of the algorithm (no matter how deep in the recursion we go). As each step of the
14(1+C)
recursion adds a multiplication of 2 |K | ≤ 2m⌈log2 ( C )⌉ to the distances and
L
43
2 max
x,y∈{1,...,n} d(x,y)
since we have no more than log( 4+4C ) minx,y∈{1,...,n} d(x,y) of recursion depth.
4+3C
Had this algorithm been preformed on d (and not on d1 ) the maximal distance
of dB(x,r(x))-new at any stage of the algorithm would have been bounded by:
2 maxx,y∈{1,...,n} d(x,y)
14(1+C)
log 4+4C
max d (x, y) 2m⌈log2 ( C )⌉ ( 4+3C ) minx,y∈{1,...,n} d(x,y)
x,y∈{1,...,n}
The normalization by α in the beginning of the algorithm is, therefore, done to

ensure that the maximal distance of dB(x,r(x))-new at any stage is
2 maxx,y∈{1,...,n} d(x,y)
14(1+C)
− log 4+4C
≤ 2m⌈log2 ( C )⌉ ( 4+3C ) minx,y∈{1,...,n} d(x,y)
Next we note that if f¯ is a function of the recursive step and it’s second
derivatives is bounded by M̄2 than the portion of f on which f¯ is placed has
a second derivative bound of 2 · |KL | M̄2 . That is because if we derive the
expression
1
· f (2 · |KL | · z0 , 2 · |KL | · z1 )
2 · |KL |
twice, using the chain rule, we receive a 2 · |KL | coefficient multiplied. So, the
total bound of the second derivatives of f is (2 · |KL |)depth · A where A is a
bound on the second derivatives of the embeddings of KL or any of the other
base cases. By applying the above bound on depth we receive that the bound
on the second derivatives of f is:
2L1 2 maxx,y∈{1,...,n} d(x,y)
log log
A · (2 |KL |) ( 4+3C
4+4C
) L3
= A · (2 |KL |) ( 4+3C
4+4C
) minx,y∈{1,...,n} d(x,y)
And, using the bound on the size of KL we get that the above bound is:
2 maxx,y∈{1,...,n} d(x,y)
log 4+4C
( 4+3C )
14(1+C)
A · 2m⌈log2 ( C )⌉
minx,y∈{1,...,n} d(x,y)
Next, we need to analyse A. As said before A is the bound on the second

derivatives of the embeddings of KL or any of the other base cases. As the
bound on the maximal distance is bounded by
2 maxx,y∈{1,...,n} d(x,y)
14(1+C)
− log 4+4C
2m⌈log2 ( C )⌉ ( 4+3C ) minx,y∈{1,...,n} d(x,y)
as seen above and due to 5.9 the bound on the second derivative is bounded by
a constant (which depends on C, m).
In other words, if the bound on L1 on any recursive step was ≤ 1, the above
A was a function of C, m. We know by 5.9 that if we multiply/normalize the
distances by a factor (smaller than 1) the above A will be multiplied by the
same factor. The choice of α is such that the L1 on any recursive step is suf-
ficiently small so this normalizing creates an A which cancels the expression
44
log 4+4C 2min
maxx,y∈{1,...,n} d(x,y)
( 4+3C )
14(1+C)
2m⌈log2 ( C )⌉ x,y∈{1,...,n} d(x,y)
and leaves us with an expres-
sion not depended on n.
As for the the bounds on the first derivative: once we know that the second
derivative is bounded by a function of C, m and as the size of the base space is
fixed (independent of n) a bound of the first derivative is achieved by integration
and thus will also bound by a function of C, m.
Finally, we need to bound the size of g. In every embedding of KL , g
can increase by up to |KL |2 by the actual embedding KL and by n by em-
bedding of the previous recursive steps (and the reduction of the double rep-
14(1+C)
resented cities). As |K | < m⌈log2 ( C )⌉ and the depth is bounded by
L
2 maxx,y∈{1,...,n} d1 (x,y)
log( 4+3C ) ( minx,y∈{1,...,n} d1 (x,y) ) we recies the total bound of
4+4C
14(1+C) 2 maxx,y∈{1,...,n} d1 (x, y)

g < nm⌈log2 ( C )⌉ log
( 4+4C )
4+3C minx,y∈{1,...,n} d1 (x, y)
Please note that any other normalization by α′ = γ · α ( for γ > 0 constant)

would work equally well. Moreover any normalization of a smaller α would also
work.
The perplexed reader may ask oneself why did we go to all the above trouble
when we could simply use 5.8 and by normalizing the metric to the right constant
curb the bounds of M1 , M2 to fit our needs? The answer is that the algorithm in
5.5 leaves the method of choosing the initial lines (step 1) to arbitrary selection.
This selection of lines determines M2 so one must be a bit careful when selecting
such lines, as a smaller normalization calls for a higher density of the lines but
in turn enlarges M2 . The above algorithm shows that such a selection can be
done (along with the proper function).
The second natural question that one may ask is what happens in the case
of a choice of a too small of a normalization factor. The lemma below will show
just what to do in that case
Lemma 5.16. Given a doubling metric d : {1, 2, . . . , n}2 → R with m > 0
doubling constant and another constants C > 0 s.t
⌈log2 ( 14(1+C)
C )⌉ ·⌈log ( 14(1+C) )⌉
n > m4·m 2 C
one can create an embedding (f, g) such that

n−1
X

dBAS(g) ps′ (n) , ps′ (1) + dBAS(g) ps′ (j) , ps′ (j+1) > 1
j=1
for every s′ ∈ Sn , with the same properties as 5.15 original theorem. Note hat
the normalization factor of the proof of 5.15 may change.
45
Before the full proof let’s understand what the condition
n−1
X 3
dBAS(g) ps(n) , ps(1) + dBAS(g) ps(j) , ps(j+1) <
j=1
4
means. Look at the projection of the path created by s on the x axis of BAS(g),
this projection covers a part of [0, 1] and therefore is a subset of it. The size of
that subset isn’t larger than 34 as the total distance isn’t larger than that. The
same goes for the y axis. So, the real meaning of the above inequality is that the
embedding of the metric isn’t efficient, as it doesn’t cover a (large) portion of the
base space. Such an embedding is unacceptable in our terms and will not work
in 4.3 (though the condition there is ≥ 21 and not ≥ 43 ). But, embedding into
a smaller BAS(g) (smaller than [0, 1]2 that is) is a "more difficult" embedding
to make (as enlarging the base space reduces the bound M2 and thus reduces
M1 as well). So luckily, if the previous algorithm yield such a result it’s simple
to correct it. One only needs to calculate said projections and remove them,
while enlarging the base space. Unfortunately, as the "stripes" that are to be
removed can contain parts of tracks between cities and sqi s , one must also take
care to make sure non of the other properties are broken (the distances are still
an approximation) without enlarging the M2 and M1 too much.
Luckily, the construction of 5.15 allows us to make sure all conditions are
met held and bounds on M2 are kept. The idea of the proof is to notice that the
problem that can case the inequality not to hold is the fact that the embeddings
1
of KL is placed inside a "socket" of size 2·|K L|
but the actual embedding can be
much smaller and thus the embedding doesn’t cover the entire space allocated
1
(as in 5.8’s proof). Thus if we enlarge KL ’s to fit the 2·|K L|
"socket" the
inequality will hold.
Proof. Denote KL1 to be the first KL in the recursion, {KL2,i }i=1,...,KL1 to be the
KL s of the second step of the recursion, {KL3,i,j }i=1,...,K 1 ;j=1,...,K 2,i to be the
L L
KL s of the third step of the recursion and so on.
As shown before each KL has a city in it that doesn’t appear in any other
KL (of any level), choose for each KL in the recursive embedding a city EKL
that doesn’t appear in any other KL (in case there may be more than one).
Run 5.15’s embedding on d such that:
• in each KL embedding (in the recursion step, using 5.8) the city EKL will
be placed s.t the BAS(ḡ) distance will be at least 12 (before the normal-
1
ization with 2·|K L|
). This is the equivalent to step 2 in 5.5 only in this
case a city is chosen (and not a pair).
1
• if |KL | = 2 normalize the step in the recursion by 9 (as if |KL | = 3) and
not by 41 (as in the original proof).
46
1
We will assume that all KL fit the 2·|KL | "socket" and show the inequality
1 −1
nX
dBAS(ḡ) ps(n1 ) , ps(1) + dBAS(ḡ) ps(j) , ps(j+1) > 1 (1)
j=1
will hold. Afterwards, we will show how to achieve said assumption.

The TSP tour in equation (1) must go over all cities, and especially all cities
of shape EKL for some KL in the recursion. As each such city appears in only
one KL and as the BAS distance (bofore normaliztion) to that city is (as least)
1 1
2 together with the face that the embedding of each KL covers the 2·|KL | socket
we can bound the TSP distance (from below) on BAS. For the first step in the
recursion, the TSP tour must visit EKL1 . As such the minimal distance to travel
1
to EKL1 will be (at least) 21 · 2·|K 1
1 | (as the minimal BAS distance is 2 and
L
14(1+C)
the socket size is 1
2·|KL1|) as |KL | < m⌈log2 ( C )⌉ it holds that the minimal
1
distance to travel to EKL1 will be (at least) 14(1+C) . For the second
4·m ( C )⌉ ⌈log2
step of the recursion, the TSP tour must visit all EK 2,i for i = 1, . . . , KL1 each
L
1 1
such vist must cost is at least 2 · 1 |·|K 2,i |
2·|KL
, there are |KL1 | such cities so the
L
1 1
total cost (for cities in the second step) is at least 2 · 2,i
2·maxi=1,...,K 1 |KL |
and
L
14(1+C)
as |KL | < m⌈log2 ( C )⌉ the total cost for cities in the second step of the
1
recursion is 14(1+C) . The same hold true to the third step, the total
⌈log 2( C )⌉
4·m
1
cost for cities in the third step of the recursion is at least ⌈log2 (
14(1+C) , and
4·m C )⌉
so on. This is true to every step, of course, so the total bound on all steps, on
BAS(g) is at least
depth
⌈log2 ( 14(1+C) )⌉
4·m C
where depth is the depth of the recursion. Next we need to bound the size of
14(1+C)
depth from below as a function of n: As |KL | < m⌈log2 ( C )⌉ embedding
14(1+C)
with depth of 1 may only have at most m⌈log2 ( C )⌉ cities (that’s assuming
all cities are different and the maximum on KL size is received, if either doesn’t
hold the number of cities will be less). Embeddings of depth 2 may have have
14(1+C)
2
at most m⌈log2 ( C )⌉ cities and, embeddings of depth k have at most
14(1+C)
k
m⌈log2 ( C )⌉ cities. Therefore, if n is the number of cities it holds that
14(1+C)
depth
m⌈log2 ( C )⌉ >n
So the depth holds

depth > log ⌈log2 ( 14(1+C) )⌉ (n)
m C
and if
⌈log2 ( 14(1+C) )⌉
log ⌈log2 ( 14(1+C) )⌉ (n) > 4 · m
C
m C
47
then
depth
>1
⌈log2 ( 14(1+C) )⌉
4·m C
and thus inequality (1) holds. The solution to the above inequality is:
⌈log2 ( 14(1+C)
C )⌉ ·⌈log ( 14(1+C) )⌉
n > m4·m 2 C
and that is the condition on n.

1
Next we need to show how to construct the embedding s.t KL fits the 2·|K L|
1
"socket". The idea here is, if KL doesn’t cover the 2·|K L | "socket", to trim any
excess dead space and scale so that KL will cover the socket.
1
For the first step of the recursion assume KL1 doesn’t cover 2·|K 1 sized socket.
| L
As all sockets are interchangeable and as KL1 was embedded as if |KL1 | > 2 one
can place the KL1 embedding in such a way that no other embeddings (of other
steps of the recursion) are on the same [0, 1]2 horizontal line or [0, 1]2 vertical line
as KL1 . Such an embedding can be done by placing KL1 on the left bottom corner
among the (2 max{|KL1 |, 3})2 sockets and placing the other |KL1 | recursive steps
in the (2 max{|KL1 |, 3})2 − 2|KL1 | socket that aren’t on the same [0, 1]2 vertical
or horizontal line as KL1 . And as (2 max{|KL1 |, 3})2 − 2|KL1 | > |KL1 | this can
be done. Next mark all the lines in KL1 between cities of KL1 and look at the
projection of the marked lines on the x axis, it’s a set that doesn’t cover all
1
2 max{|K 1 |,3}
and thus ax is the renaming length between the embedding and
L
1
1 |,3} .
2 max{|KL
Do the same for the y axis and choose b = min{ax , ay }. Choose
stripes in [0, 1]2 of width b not on KL1 . As these stripes weren’t on KL1 and no
other embedding is to be found on the same horizontal or vertical lines no cities
or sqi s or parts of paths are to be found within the stripes. Remove the stripes,
now we have BAS(g) based on [0, 1 − b]2 (rather than [0, 1]2 ). Normalize the
function back to based on [0, 1 − b]2 by
1
fnew (x, y) = · f ((1 − b) · x, (1 − b) · y)
1−b
as one can clearly see the first derivative doesn’t change (as
∂ ∂
fnew (x, y) = f ((1 − b) · x, (1 − b) · y)
∂x ∂x
and the same goes for y) and the second order derivatives only decrease (as
∂2 ∂2
f new (x, y) = (1 − b) f ((1 − b) · x, (1 − b) · y)
∂x2 ∂x2
and (1 − b) < 1 and the same goes for the other second order derivative. Thus
M1 , M2 bounds remain the same. Note that the maximum of the values of f
may increase.
The embedding remained the same as both the embedding of KL1 and of the
recursive steps remains the same and were only enlarged by the same factor and
48
the value between sockets is higher than before (so no new paths between KL1
or the recursive steps can emerge). Note that the normalization factor α of 5.15
will change due to this enlargement.
For any of the subsequent recursive steps the construction remains the same,
if KL doesn’t cover the sized socket we can place it (as all sockets are inter-
changeable) in such a way that there are no other embeddings (of other steps
of the recursion) are on the same [0, 1]2 horizontal line or vertical line as KL .
Note that in the recursive case that may call for changes to the placement of
previous embedding as well. Afterwards we look at the projection of KL , slice
the dead strips and normalize to fit a BAS(g) based on [0, 1]2 .
Finally, assuming worst case scenario, if every step in the recursion needs
such a trim, we have no more than n trims (for each of KL unique city) and
every trim is of fixed time to compute (provided C, m are fixed) as f is already
known KL has a maximum number of cities bounded by a function of C, m and
multiplying by a constant (for the enlargement) is O(1). So the bound
T1 (C,m)
2 maxx,y∈{1,...,n} d (x, y)

n · S(C, m)
minx,y∈{1,...,n} d (x, y)
on the running time stays the same (The functions S(C, m), T1 (C, m) may
change).
In the practical case, as we only need equation (1) above to hold w.r.t a
fixed number (i.e 1), one can save the hassle of trimming all recursive steps
and estimate the LHS of equation (1) by using Christofides algorithm [11] to
estimate the LHS. Once that LHS Christofides’s estimation is ≥ 1 the final LHS
can’t be less than 32 and as 4.3 needs only 21 that suffice.
6 Solving TSP on metrics

In this section we will finally combine the embeddings of 5 of a given metric to
a surface along with 4 and the algorithm given in 4.3 to solve TSP on a surface
to receive an algorithm to solve TSP problem for given arbitrary metrics.
Let’s start with the obvious:
Theorem 6.1. Given a series of metric spaces dk : {1, . . . , nk } → R for k ∈ N
one can estimate the C1 approximation of the TSP problem on dk (with proba-
bility ≥ 12 ). The running time (which may be non-polynomial in nk ) depends on
the growth of nk and the metric spaces.
Proof. Given a k ∈ N use 5.5 to embed dk into a surface and then use 4.3 to
estimate the C1 approximation of the TSP problem on dk (see the corollary after
5.9).
Now for the polynomially bounded cases:
49
s.t all are uniform one can estimate the C1 approximation of the TSP problem
on dk (with probability ≥ 12 ). The running time is polynomially bounded by nk .
Proof. Given a k ∈ N use 5.11 to embed dk into a surface and then use 4.3 to
estimate the C1 approximation of the TSP problem on dk . As M1 = M2 = 0 in
this case and g = n2 the expression in the time bound 4.12 is
1+T (0,0,C)
O(n2k 5 + nk · log(nk )
where T is the function that appears in 4.12. This expression is polynomially

bounded by nk .
s.t all are m > 0 doubling (with the same doubling constant) one can estimate
the 1 + C1 approximation of the TSP problem on dk (with probability ≥ 21 ). The
running time is polynomially bounded by nk .
maxx,y∈{1,...,n}dk (x,y)
The key idea in this proof is to bound the size of minx,y∈{1,...,n}dk (x,y) by
1
changing the metric space in such a way that the approximation won’t change
C
maxx,y∈{1,...,n}dk (x,y)
(on the one hand) but minx,y∈{1,...,n}d (x,y)
won’t be too large on the other.
k
Proof. we will denote n = nk for simplicity. Assume C > 1 (otherwise enlarge

C - it will only improve the approximation). Denote C0 = 10 · C and C̄ = C10 ,
and denote
(
dk (x, y) if dk (x, y)> C̄
n (maxx0 6=y0 dk (x0 , y0 ))
dnew
k (x, y) = C̄
n+1 (max d
x0 6=y0 k (x ,
0 0y )) else
Please note that for a fixed C, C̄ and C0 are also constants (as a function of C).
Use 5.15 (along with 5.16) to embed a (1 + C̄) approximation of dnew k , receive
a surface (f, g) along with p1 , . . . , pn . Denote the optimal TSP path on dS(f,g)
by s2 ∈ S(n). Use 4.3 to calculate the (1 + C10 ) approximation TSP tour denote
the path given by the algorithm by s2 ∈ S(n).
Now for the estimation proof: For any s ∈ S(nk ) it holds that the path of s
50

on dnew
k is at most 1 + C̄ approximation of the same path in dk , as
n−1
X
dnew dnew ≤(1)

k p s(n) s(1) +
, p k ps(j) , ps(j+1)
j=1
n−1
X C̄
dk ps(n) , ps(1) + dk ps(j) , ps(j+1) + (n + 1) · max dk (x0 , y0 ) =
j=1
n+1 x0 6=y0
n−1
X
≤(2)

dk ps(n) , ps(1) + dk ps(j) , ps(j+1) + C̄ max dk (x0 , y0 )
x0 6=y0
j=1
 
n−1
X n−1
X

dk ps(n) , ps(1) + dk ps(j) , ps(j+1) + dk ps(n) , ps(1) + dk ps(j) , ps(j+1)  · C̄ =
j=1 j=1
 
n−1
X

1 + C̄ dk ps(n) , ps(1) + dk ps(j) , ps(j+1) 
j=1
where
• inequity 1 is due to the fact that the most increase between dk and dnew k is
C̄
n+1 (max x 0 =
6 y 0 dk (x0 , y 0 )) at most on each intercity travel and there are
n + 1 of them.
• inequity 2 is due to the fact that any closed tour must be of larger length
than the maximum intercity distance (generalized triangle inequality)
So, the path s is also an (1 + C̄)2 upper approximation as
n−1
X
dS(f,g) ps(n) , ps(1) + dS(f,g) ps(j) , ps(j+1) ≤
j=1
 
n−1
X
1 + C̄ dnew dnew

k ps(n) , ps(1) + k ps(j) , ps(j+1)  ≤
j=1
 
n−1
2 X
1 + C̄ dk ps(n) , ps(1) + dk ps(j) , ps(j+1) 
j=1
and a (1 − C̄) lower approximation on the other hand, as

 
n−1
X n−1
X
dS(f,g) ps(j) , ps(j+1) ≥ 1 − C̄ dnew dnew

dS(f,g) ps(n) , ps(1) + k ps(n) , ps(1) + k ps(j) , ps(j+1) 
j=1 j=1
 
n−1
X

≥ 1 − C̄ dk ps(n) , ps(1) + dk ps(j) , ps(j+1) 
j=1
51
(As S(f, g) is a C̄ approximation of dnewk and dnew k was a length increase over
dk .)
Denote s3 ∈ S(n) to be the optimal TSP path on dk , we receive
 
n−1
X
dk ps2 (j) , ps2 (j+1)  ≤(1)

1 − C̄ dk ps2 (n) , ps2 (1) +
j=1
n−1
X
dS(f,g) ps2 (j) , ps2 (j+1) ≤(2)

dS(f,g) ps2 (n) , ps2 (1) +
j=1
 
n−1

1  X
dS(f,g) ps1 (j) , ps1 (j+1)  ≤(2)

1+ dS(f,g) ps1 (n) , ps1 (1) +
C0 j=1
 
n−1
1  X
dS(f,g) ps3 (j) , ps3 (j+1)  ≤(3)

1+ dS(f,g) ps3 (n) , ps3 (1) +
C0 j=1
 
n−1

1 2 X
1+ 1 + C̄ dk ps3 (n) , ps3 (1) + dk ps3 (j) , ps3 (j+1) 
C0 j=1

1 2
= 1+ 1 + C̄ OP T (dk )
C0
where:
• inequalities 1 and 3 are the inequalities proven above applied to s2 and s3
respectively.
• inequality 2 is due to the fact that s1 is the optimal TSP tour on dS(f,g)
and therefore any other tour (such as s3 ) must be of larger or equal length.
So we receive that
2
1
n−1
X 1+ C0 1 + C̄
dk ps2 (n) , ps2 (1) + dk ps2 (j) , ps2 (j+1) ≤ OP T (dk )
j=1
1 − C̄
2
1+ C1 (1+C̄ )
0
that mean that the path we calculated is a 1−C̄
approximation of the
optimal TSP tour. And as
2
1 + C10 1 + C̄
2
¯ + 3C̄ 2 + C̄ 3

1 + C̄ 1 + C̄ 1 + 3C 1 + 7C̄ (2) 1
= = ≤(1) < 1+
1 − C̄ 1 − C̄ 1 − C̄ 1 − C̄ C
where
• inequality 1 is due to the fact that C > 1 and thus C̄ < 1
52
• inequality 2 is due to:
1 1
C̄ = <
8 + C1 C

10C
⇓

1 1
C̄ 8 + <
C C
⇓
C̄ 1
8C̄ + <
C C
⇓

1 C̄ 1
1 + 7C̄ < 1 − C̄ + − = 1 − C̄ 1 +
C C C
⇓
1 + 7C̄ 1
<1+
1 − C̄ C
Therefore, the algorithm gives a 1 + C1 approximation of the optimal TSP

travel.
Now for the time bound: As
maxx,y∈{1,...,n}dk (x,y) maxx,y∈{1,...,n}dk (x,y) n+1
≤ C̄ = = 10C (n + 1)
minx,y∈{1,...,n}dk (x,y) (maxx0 6=y0 dk (x0 , y0 )) C̄
n+1
we know that the time bound

2 maxx,y∈{1,...,n} d (x, y) 1 (
T C̄,m)
nk · S(C̄, m)
minx,y∈{1,...,n} d (x, y)
on 5.15 is simply
n · S(C̄, m) (20C (n + 1)) 1 (
T C̄,m)
which is polynomially bounded by n = nk and 4.3 is bounded by 4.12 which is

O(n25 + n · log(n) · g T (M1 ,M2 ,C0 ) )
as M1 , M2 are bounded by a function of C0 , m and as
2 maxx,y∈{1,...,n} d1 (x, y)

14(1+C0 )
⌈log2 ⌉
g < nm C0
log 4+4C0
4+3C0 minx,y∈{1,...,n} d1 (x, y)
the time bound here is polynomially bounded by n = nk as well.
Corollary 6.4. The above solutions to the TSP problem on different metric
spaces can be done with certainty, rather than with probability ≥ 21 by de-
randomizing the algorithm, as seen in 4.14. The running time will remain
polynomially bounded, as mentioned in 4.14.
-
53
References
[1] Der Handlungsreisende – wie er sein soll und was er zu tun hat, um Aufträge
zu erhalten und eines glücklichen Erfolgs in seinen Geschäften gewiß zu sein
– von einem alten Commis-Voyageur" (The traveling salesman — how he
must be and what he should do in order to get commissions and be sure of
the happy success in his business — by an old commis-voyageur)
[2] "Reducibility Among Combinatorial Problems". In R. E. Miller and J.
W. Thatcher (editors). Complexity of Computer Computations. New York:
Plenum. pp. 85–103
[3] Orponen, P.; Mannila, H. (1987), "On approximation preserving reductions:
Complete problems and robust measures’", Technical Report C-1987–28,
Department of Computer Science, University of Helsinki.
[4] S. Arora, C. Lund, R. Motwani, M. Sudan and M. Szegedy. “Proof verifica-
tion and the hardness of approximation problems” J. ACM, 45(3): 501-555,
1998.
[5] ”New inapproximability bounds for TSP” by M.Karpinski, M.Lampis,
R.Schmied. Journal of Computer and System Sciences Volume 81 Issue 8,
December 2015 Pages 1665-1677.
[6] ”When Hamming Meets Euclid: The Approximability of Geometric TSP
and Steiner Tree” by Luca Trevisan. SIAM J. Comput., 30(2), 475–485. (11
pages) 2000.
[7] Sanjeev Arora. 1998. Polynomial time approximation schemes for Euclidean
traveling salesman and other geometric problems. J. ACM 45, 5 (September
1998), 753-782. DOI=http://dx.doi.org/10.1145/290179.290180
[8] Joseph S. B. Mitchell. Guillotine subdivisions approximate polygonal subdi-
visions: A simple polynomialtime approximation scheme for geometric TSP,
k- MST, and related problems. SIAM J. Comput., 28(4):1298–1309, 1999.
[9] The travelling salesman problem: low-dimensionality implies a polyno-
mial time approximation scheme. Yair Bartal, Lee-Ad Gottlieb, Robert
Krauthgamer. STOC 2012: 663-672 (extended abstract)
[10] Thomas H. Cormen et al. Introduction to Algorithms, Second Edition.
ISBN 0-262-03293-7 subsection 25.2 The Floyd-Warshall algorithm, page
535.
[11] Christofides, Christofides (1976), Worst-case analysis of a new heuristic for
the travelling salesman problem, Report 388, Graduate School of Industrial
Administration, CMU.
54

TSP On Manifolds: David Zisselman October 5, 2021

Uploaded by

Copyright:

Available Formats

TSP On Manifolds: David Zisselman October 5, 2021

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

TSP On Manifolds: David Zisselman October 5, 2021

Uploaded by

Copyright:

Available Formats

TSP on manifolds

{(x, y, z) ∈ R3 |(x, y) ∈ BAS(g) ∧ z = f (x, y)}

satisfying γ(0) = x and γ(1) = y.

Notation 2.9. Given a surface S(f, g) and a path γ : [0, 1] → S(f, g) on in

3 Basic geometric definitions and theorems

Γ(t) = ((x0 , y0 ) ↔ (x1 , y1 ))(t) = (x0 , y0 )t + (x1 , y1 )(1 − t)

Moreover the difference in absolute value is also bounded:

|((x̄0 , ȳ0 ) ↔ (x̄1 , ȳ1 ))(t) − ((x0 , y0 ) ↔ (x1 , y1 ))(t)| =

Where inequality 1 is simply due to inequality 1 and inequality 2 is approxi-

lenS(f,g) ((x̄0 , ȳ0 ) ↔ (x̄1 , ȳ1 )) =

Now, as a corollary we get that if Γ : [0, 1] → BAS(g) is a polygonal path

Now let’s prove theorem 3.1:

4 Solving metric TSP on a surface

4.1 Basic definitions

• a quadtree of either [0, 1]2 or BAS(g) is a dissection, except we stop the

4.2 Structure theorem

By adding the two inequalities together we get

And by multiplying by t > 0 and adding 2 to both sides we get:

Let shifts 0 ≤ a, b ≤ 1 be picked randomly from At (where the value of t will

• The salesman path is updated iteratively, so the modifications made for

where ḡ is the constant appearing in the Patching Lemma and M1 is the

Ea [charge to l when horizontal shift is a]

which is at most t(π̃,l)

1. A nonempty square A in the shifted quadtree.

• an algorithm that computes for a given k ∈ N digits point on BAS(g) the

Define the following algorithm to solve the TSP problem

O( max log2 (x) + log(n))

time (the size of the representation).

• calculating the quadtree is done by repeated divisions O(log(n)) times

therefore the total cost of this step is

The above expression is O(n25 ) when M1 , M2 , C are constants and, as all

Corollary 4.14. The algorithm described in 4.11 can be de-randomize by run-

for some functions T, T2 .

5 embeddings of metrics to surfaces

Definition 5.2. Define the following function Ψr : R2 → R2 by:

such a function is called a "bump function".

• Ψr is a smooth functions (has derivatives of any order).

such a function is a prolonged "bump function". This function makes a

{x + y|x ∈ γ ([0, 1]) , ||y|| ≤ β}

dn (i, j) = α · d(f,g) (pi , pj )

α is this normalization constant. Second step, create BAS(g) and (p1 , . . . , pn )

O(n2 · max(log dn (i, j))

• The second step can be done uniformly for all k ∈ N for n = n0 .

dn (i, j) = d(f,g) (pi , pj )

5.2.1 embeddings of a doubling dimension metric

∀x, y ∈ {1, 2, . . . , n} d1 (x, y) ≤ (1 + C) · d2 (x, y)

14(1+C) 2 maxx,y∈{1,...,n} d1 (x, y)

In other words, the metric d can be embedded in a surface of a bounded deriva-

dB(x,r(x))-new (y1 , y2 ) = 2 · |KL | · d1 (y1 , y2 )

– The multiplication is applied to both the BAS(g) and f , i.e a value

– As both the domain and the function are multiplied by a number

dKL -new (y1 , y2 ) = 2 · |KL | · d1 (y1 , y2 )

– equality (1) comes from the of construction of d(f,g)

where the previous 3 explanatory bullets apply here as well.

d(f,g) (x1 , x2 ) ≤ d1 (x1 , x2 )

d1 (y1 , y2 ) + L ≥ d1 (y1 , y2 ) + d1 (y2 , x2 ) > d1 (y1 , x2 ) > r(x2 )

by subtracting L from both sides we get d1 (y1 , y2 ) > r(x2 ) − L.

d(f,g) (y1 , y2 ) (1) d(f,g) (y1 , x1 ) + d(f,g) (x1 , x2 ) + d(f,g) (x2 , y2 )

• inequality (3) is due to C > 0.

which is T1 (C,m)