Dynamic Time Warping in Strongly Subquadratic Time: Algorithms for the Low-Distance Regime and Approximate Evaluation

TL;DR

This paper introduces subquadratic algorithms for dynamic time warping (DTW) in the low-distance regime and for approximate evaluation, extending to edit distance and LCS, with implications for computational lower bounds.

Contribution

It presents the first strongly subquadratic algorithms for DTW in the low-distance case and for approximate evaluation, including for strings over arbitrary metric spaces, and establishes reductions linking edit distance, DTW, and LCS.

Findings

Algorithms for DTW with runtime proportional to the actual DTW value.

Approximation algorithms for DTW and edit distance with near-quadratic time.

Conditional lower bounds for DTW based on reductions from edit distance.

Abstract

Dynamic time warping distance (DTW) is a widely used distance measure between time series. The best known algorithms for computing DTW run in near quadratic time, and conditional lower bounds prohibit the existence of significantly faster algorithms. The lower bounds do not prevent a faster algorithm for the special case in which the DTW is small, however. For an arbitrary metric space $\Sigma$ with distances normalized so that the smallest non-zero distance is one, we present an algorithm which computes $\operatorname{dtw}(x, y)$ for two strings $x$ and $y$ over $\Sigma$ in time $O(n \cdot \operatorname{dtw}(x, y))$. We also present an approximation algorithm which computes $\operatorname{dtw}(x, y)$ within a factor of $O(n^\epsilon)$ in time $\tilde{O}(n^{2 - \epsilon})$ for $0 < \epsilon < 1$. The algorithm allows for the strings $x$ and $y$ to be taken over an arbitrary well-separated tree metric with logarithmic depth and at most exponential aspect ratio. Extending our techniques further, we also obtain the first approximation algorithm for edit distance to work with characters taken from an arbitrary metric space, providing an $n^\epsilon$-approximation in time $\tilde{O}(n^{2 - \epsilon})$, with high probability. Additionally, we present a simple reduction from computing edit distance to computing DTW. Applying our reduction to a conditional lower bound of Bringmann and K\"unnemann pertaining to edit distance over $\{0, 1\}$, we obtain a conditional lower bound for computing DTW over a three letter alphabet (with distances of zero and one). This improves on a previous result of Abboud, Backurs, and Williams. With a similar approach, we prove a reduction from computing edit distance to computing longest LCS length. This means that one can recover conditional lower bounds for LCS directly from those for edit distance, which was not previously thought to be the case.

Equations

$$\{\begin{array}{ll}\min \left(\mathrm{SP}(x,y,r_x,r_y,o_y-1)+d,\mathrm{SP}(x,y,r_x-1,r_y,o_y-l_x)+d\cdot l_x\right)& \text{ if }{l}_x\le o_y\\ \min \left(\mathrm{SP}(x,y,r_x,r_y,o_y-1)+d,\mathrm{SP}(y,x,r_y-1,r_x,l_x-o_y)+d\cdot o_y\right)& \text{ if }{l}_x>o_y.\end{array}$$

$$\begin{array}{r}\mathrm{Pr}[|l_1|\le r<|l_2|]\cdot |l_2|+d(l_1,l_2).\end{array}$$

$$\mathrm{dtw}(x,y)=\min \left(\mathrm{SP}(x,y,s,t,k),\mathrm{SP}(y,x,t,s,j)\right).$$

$$\mathrm{SP}(x,y,r_x,r_y,o_y)\ge \frac{|r_x-r_y|-1}{2}.$$

$$\{\begin{array}{ll}\min \left(\mathrm{SP}(x,y,r_x,r_y,o_y-1)+d,\mathrm{SP}(x,y,r_x-1,r_y,o_y-l_x)+d\cdot l_x\right)& \text{ if }{l}_x\le o_y\\ \min \left(\mathrm{SP}(x,y,r_x,r_y,o_y-1)+d,\mathrm{SP}(y,x,r_y-1,r_x,l_x-o_y)+d\cdot o_y\right)& \text{ if }{l}_x>o_y.\end{array}$$

$$\mathrm{SP}(x,y,r_x-1,r_y,o_y-l_x)+d\cdot l_x.$$

$$\mathrm{SP}(y,x,r_y-1,r_x,l_x-o_y)+d\cdot o_y.$$

$$\mathrm{SP}(x,y,r_x,r_y,o_y)=\min \left(\mathrm{SP}(x,y,r_x,r_y-1,p_y),\mathrm{SP}(y,x,r_y-1,r_x,l_x)\right).$$

$$\mathrm{dtw}(x,y)=\min \left(\mathrm{SP}(x,y,s,t,k),\mathrm{SP}(y,x,t,s,j)\right).$$

$$d_{\Sigma }(u,v)\le d_T(u,v),$$

$$\mathbb{E}[d_T(u,v)]\le O(\log n)\cdot d_{\Sigma }(u,v).$$

$$\mathrm{dtw}(x,y)\le {\mathrm{dtw}}_T(x,y).$$

$$\mathbb{E}[{\mathrm{dtw}}_T(x,y)]\le \mathrm{dtw}(x,y).$$

$$l_1^{\prime }=l_2^{\prime },$$

$$d(l_1^{\prime },l_2^{\prime })=d(l_1,l_2).$$

$$\frac{{\sup }_{x,y\in M_1}{d}_1(x,y)/d_2(\varphi (x),\varphi (y))}{{\inf }_{x,y\in M_1}{d}_1(x,y)/d_2(\varphi (x),\varphi (y))},$$

$$\mathrm{ed}(x_1\cdots x_i,y_1\cdots y_j).$$

$$\mathrm{ed}(s_{r_i}(x),s_{r_i}(y))<R{n}^{1-ϵ},$$

$$e_i=\mathrm{ed}(s_{r_i}(x),s_{r_i}(y))<nR,$$

$$\mathbb{E}[\mathrm{ed}(s_r(x),s_r(y))]\le 5\mathrm{ed}(x,y).$$

$$\begin{array}{r}\mathrm{Pr}[|l_1|\le r<|l_2|]\cdot |l_2|+d(l_1,l_2).\end{array}$$

$$\begin{array}{r}\frac{d(l_1,l_2)}{R}\cdot 4R+d(l_1,l_2)\le 5d(l_1,l_2).\end{array}$$

Full text

The lower bounds do not prevent a faster algorithm for the important special case in which the DTW is small, however. For an arbitrary metric space $\Sigma$ with distances normalized so that the smallest non-zero distance is one, we present an algorithm which computes $\operatorname{dtw}(x,y)$ for two strings $x$ and $y$ over $\Sigma$ in time $O(n\cdot\operatorname{dtw}(x,y))$. When $\operatorname{dtw}(x,y)$ is small, this represents a significant speedup over the standard quadratic-time algorithm.

Using our low-distance regime algorithm as a building block, we also present an approximation algorithm which computes $\operatorname{dtw}(x,y)$ within a factor of $O(n^{\epsilon})$ in time $\tilde{O}(n^{2-\epsilon})$ for $0<\epsilon<1$. The algorithm allows for the strings $x$ and $y$ to be taken over an arbitrary well-separated tree metric with logarithmic depth and at most exponential aspect ratio. Notably, any polynomial-size metric space can be efficiently embedded into such a tree metric with logarithmic expected distortion. Extending our techniques further, we also obtain the first approximation algorithm for edit distance to work with characters taken from an arbitrary metric space, providing an $n^{\epsilon}$-approximation in time $\tilde{O}(n^{2-\epsilon})$, with high probability.

Finally, we turn our attention to the relationship between edit distance and dynamic time warping distance. We prove a reduction from computing edit distance over an arbitrary metric space to computing DTW over the same metric space, except with an added null character (whose distance to a letter $l$ is defined to be the edit-distance insertion cost of $l$). Applying our reduction to a conditional lower bound of Bringmann and Künnemann pertaining to edit distance over $\{0,1\}$, we obtain a conditional lower bound for computing DTW over a three letter alphabet (with distances of zero and one). This improves on a previous result of Abboud, Backurs, and Williams, who gave a conditional lower bound for DTW over an alphabet of size five.

With a similar approach, we also prove a reduction from computing edit distance (over generalized Hamming Space) to computing longest-common-subsequence length (LCS) over an alphabet with an added null character. Surprisingly, this means that one can recover conditional lower bounds for LCS directly from those for edit distance, which was not previously thought to be the case.

1 Introduction

Dynamic Time Warping distance (DTW) is a widely used distance measure between time series. DTW is particularly flexible in dealing with temporal sequences that vary in speed. To measure the distance between two sequences, portions of each sequence are allowed to be warped (meaning that a character may be replaced with multiple consecutive copies of itself), and then the warped sequences are compared by summing the distances between corresponding pairs of characters. DTW’s many applications include phone authentication [20], signature verification [35], speech recognition [34], bioinformatics [1], cardiac medicine [16], and song identification [45].

The textbook dynamic-programming algorithm for DTW runs in time $O(n^{2})$, which can be prohibitively slow for large inputs. Moreover, conditional lower bounds [14, 3] prohibit the existence of a strongly subquadratic-time algorithm111An algorithm is said to run in strongly subquadratic time if it runs in time $O(n^{2-\epsilon})$ for some constant $\epsilon>0$. Although strongly subquadratic time algorithms are prohibited by conditional lower bounds, runtime improvements by subpolynomial factors are not. Such improvements have been achieved [26]., unless the Strong Exponential Time Hypothesis is false.

The difficulty of computing DTW directly has motivated the development of fast heuristics [39, 29, 30, 28, 12, 38] which typically lack provable guarantees.

On the theoretical side, researchers have considered DTW in the contexts of locality sensitive hashing [21] and nearest neighbor search [22], but very little additional progress has been made on the general problem in which one is given two strings $x$ and $y$ with characters from a metric space $\Sigma$, and one wishes to compute (or approximate) $\operatorname{dtw}(x,y)$.

To see the spectrum of results one might aim for, it is helpful to consider edit distance, another string-similarity measure, defined to be the minimum number of insertions, deletions, and substitutions needed to get between two strings. Like DTW, edit distance can be computed in time $O(n^{2})$ using dynamic programming [43, 37, 42], and conditional lower bounds suggest that no algorithm can do significantly better [7, 14]. This has led to researchers focusing on specialized versions of the problem, especially in two important directions:

• •

**Low-Distance Regime Algorithms: ** In the special case where the edit distance between two strings is small (less than $\sqrt{n}$), the algorithm of Landau, Myers and Schmidt [33] can be used to compute the exact distance in time $O(n)$. In general, the algorithm runs in time $O(n+\operatorname{ed}(x,y)^{2})$. Significant effort has also been made to design variants of the algorithm which exhibit small constant overhead in practice [18].

• •

**Approximation Algorithms: ** Andoni, Krauthgamer and Onak introduced an algorithm estimating edit distance within a factor of $(\log n)^{O(1/\varepsilon)}$ in time $O(n^{1+\varepsilon})$ [5], culminating a long line of research on approximation algorithms that run in close to linear time [6, 11, 9, 19]. Recently, Chakraborty et al. gave the first strongly subquadratic algorithm to achieve a constant approximation, running time $O(n^{12/7})$ [17].

This paper presents the first theoretical results in these directions for DTW.

A Low-Distance Regime Algorithm for DTW (Section 3)

We present the first algorithm for computing DTW in the low-distance regime. Our algorithm computes $\operatorname{dtw}(x,y)$ in time $O(n\cdot\operatorname{dtw}(x,y))$ for strings $x$ and $y$ with characters taken from an arbitrary metric space in which the minimum non-zero distance is one. The key step in our algorithm is the design of a new dynamic-programming algorithm for DTW, which lends itself especially well to the low-distance setting.

Our dynamic program relies on a recursive structure in which the two strings $x$ and $y$ are treated asymmetrically within each subproblem: One of the strings is considered as a sequence of letters, while the other string is considered as a sequence of runs (of equal letters). The subproblems build on one-another in a way so that at appropriate points in the recursion, we toggle the role that the two strings play. The asymmetric treatment of the strings limits the number of subproblems that can have return-values less than any given threshold $K$ to $O(nK)$, allowing for a fast algorithm in the low-distance setting.

We remark that the requirement of having the smallest distance between distinct characters be $1$ is necessary for the low-distance regime algorithm to be feasible, since otherwise distances can simply be scaled down to make every DTW instance be low-distance.

Approximating DTW Over Well Separated Tree Metrics (Section 4)

We design the first approximation algorithm for DTW to run in strongly subquadratic time. Our algorithm computes $\operatorname{dtw}(x,y)$ within an $n^{\epsilon}$-approximation in time $\tilde{O}(n^{2-\epsilon})$. The algorithm allows for the strings $x$ and $y$ have characters taken from an arbitrary well-separated tree metric of logarithmic depth and at most exponential aspect ratio.222The aspect ratio of a metric space is the ratio between the largest and smallest non-zero distances in the space. These metric spaces are universal in the sense that any finite metric space $M$ of polynomial size can be efficiently embedded into a well-separated tree metric with expected distortion $O(\log|M|)$ and logarithmic depth [23, 8].

An important consequence of our approximation algorithm is for the special case of DTW over the reals. Exploiting a folklore embedding from $\mathbb{R}$ to a well-separated tree metric metric, we are able to obtain with high probability an $O(n^{\epsilon})$-approximation for $\operatorname{dtw}(x,y)$ in time $\tilde{O}(n^{2-\epsilon})$, for any strings $x$ and $y$ of length at most $n$ over a subset of the reals with a polynomial aspect ratio.

In the special case of DTW over the reals, previous work has been done to find approximation algorithms under certain geometric assumptions about the inputs $x$ and $y$ [4, 44]. To the best of our knowledge, our approximation algorithm is the first to not rely on any such assumptions.

It is interesting to note that our results on low-distance regime and approximation algorithms for DTW have bounds very similar to the earliest results for edit distance in the same directions. Indeed, the first algorithm to compute edit distance in the low-distance regime [24] exploited properties of a (now standard) dynamic-programming algorithm in order to compute $\operatorname{ed}(x,y)$ in time $O(n\cdot\operatorname{ed}(x,y))$. This implicitly resulted in the first approximation algorithm for edit distance, allowing one to compute an $O(n^{\epsilon})$-approximation in time $O(n^{2-\epsilon})$. Until the work of [6] and [5], which culminated in an algorithm with a polylogarithmic approximation ratio, the best known approximation ratio for edit distance remained polynomial for roughly twenty years [33, 9, 11].

The $\tilde{O}(n^{2-\epsilon})$-time $O(n^{\epsilon})$-approximation tradeoff is also the current state-of-the-art for another related distance measurement known as Fréchet distance [15], and is achieved using an algorithm that differs significantly from its edit-distance and DTW counterparts.

Reduction from Edit Distance to DTW (Section 5)

We show that the similarity between our results for DTW and the earliest such results for edit distance is not coincidental. In particular, we prove a simple reduction from computing edit distance over an arbitrary metric space to computing DTW over the same metric space (with an added null character). Consequently, any algorithmic result for computing DTW in the low-distance regime or approximating DTW immediately implies the analogous result for edit distance. The opposite direction is true for lower bounds. For example, the conditional lower bound of Bringmann and Künnemann [14], which applies to edit distance over the alphabet $\{0,1\}$, now immediately implies a conditional lower bound for DTW over an alphabet of size three (in which characters are compared with distances zero and one). This resolves a direction of work posed by Abboud, Backurs, and Williams [3], who gave a conditional lower bound for DTW over an alphabet of size five, and noted that if one could prove the same lower bound for an alphabet of size three, then the runtime complexity of DTW over generalized Hamming space would be settled (modulo the Strong Exponential Time Hypothesis). Indeed, it is known that over an alphabet of size two, DTW can be computed in strongly subquadratic time [3].

Using a similar approach we also prove a simple reduction from computing edit distance (over generalized Hamming space) to computing the longest-common-subsequence length (LCS) between two strings. Thus conditional lower bounds for computing edit distance directly imply conditional lower bounds for computing LCS (over an alphabet with one additional character). This was not previously though to be the case. Indeed, the first known conditional lower bounds for LCS came after those for edit distance [2, 7], and it was noted by Abboud et al. [2] that “A simple observation is that the computation of the LCS is equivalent to the computation of the Edit-Distance when only deletions and insertions are allowed, but no substitutions. Thus, intuitively, LCS seems like an easier version of Edit Distance, since a solution has fewer degrees of freedom, and the lower bound for Edit-Distance does not immediately imply any hardness for LCS.” Our reduction violates this intuition by showing that edit distance without substitutions can be used to efficiently simulate edit distance without substitutions. In addition to presenting a reduction from edit distance to LCS, we show that no similar reduction can exist in the other direction.

We remark that our reduction from edit distance to LCS was also previously briefly described in Chapter 6.1 of [40], a fact of which we only became aware after the completion of this manuscript.

Approximating Edit Distance Over an Arbitrary Metric (Section 6)

The aforementioned results for approximating edit distance [24, 9, 11, 33, 6, 5, 17, 32] consider only the case in which insertion, deletion, and substitution costs are all constant. To the best of our knowledge, no approximation algorithm is known for the more general case in which characters are taken from an arbitrary metric space and edit costs are assigned based on metric distances between characters. This variant of edit distance is sometimes referred to as general edit distance [36]. The study of general edit distance dates back to the first papers on edit distance [43, 41], and allowing for nonuniform costs is important in many applications, including in computational biology [27].

We present an approximation algorithm for edit distance over an an arbitrary metric. Our algorithm runs in time $\tilde{O}(n^{2-\epsilon})$ and computes an $O(n^{\epsilon})$-approximation for $\operatorname{ed}(x,y)$ with high probability. Note that for the case where characters are taken from a well-separated tree metric with logarithmic depth and at most exponential aspect ratio, the result already follows from our approximation algorithm for DTW, and our reduction from edit distance to DTW. The approach taken in Section 6 is particularly interesting in that it places no restrictions on the underlying metric space.

Both our approximation algorithm for DTW and our approximation algorithm for edit distance exhibit relatively weak runtime/approximation tradeoffs. To the best of our knowledge, however, they are the first such algorithms to run in strongly subquadratic time.

2 Preliminaries

In this section, we present preliminary definitions and background on dynamic time warping distance (DTW) and edit distance.

Dynamic Time Warping Distance

For a metric space $\Sigma$, the dynamic time warping distance (DTW) between two strings $x,y\in\Sigma^{n}$ is a natural measure of similarity between the strings.

Before fully defining DTW, we first introduce the notion of an expansion of a string.

Definition 2.1**.**

The runs of a string $x\in\Sigma^{n}$ are the maximal subsequences of consecutive letters with the same value. One can extend a run by replacing it with a longer run of the same letter. An expansion of the string $x$ is any string which can be obtained from $x$ by extending runs.

As an example, consider $x=aaaccbbd$. Then the runs of $x$ are $aaa$, $cc$, $bb$, and $d$. The string $\overline{x}=aaacccccbbdd$ is an expansion of $x$ and extends the runs containing $c$ and $d$.

Using the terminology of expansions, we now define DTW.

Definition 2.2**.**

Consider strings $x$ and $y$ of length $n$ over a metric $(\Sigma,d)$. A correspondence $(\overline{x},\overline{y})$ between $x$ and $y$ is a pair of equal-length expansions $\overline{x}$ of $x$ and $\overline{y}$ of $y$. The cost of a correspondence is given by $\sum_{i}d(\overline{x}_{i},\overline{y}_{i}).$

The dynamic time warping distance $\operatorname{dtw}(x,y)$ is defined to be the minimum cost of a correspondence between $x$ and $y$.

When referring to a run $r$ in one of $x$ or $y$, and when talking about a correspondence $(\overline{x},\overline{y})$, we will often use $r$ to implicitly refer to the extended run corresponding with $r$ in the correspondence. Whether we are referring to the original run or the extended version of the run should be clear from context.

Note that any minimum-length optimal correspondence between strings $x,y\in\Sigma^{n}$ will be of length at most $2n$. This is because if a run $r_{1}$ in $x$ overlaps a run $r_{2}$ in $y$ in the correspondence, then we may assume without loss of generality that at most one of the two runs is extended by the correspondence. (Otherwise, we could un-extend each run by one and arrive at a shorter correspondence with no added cost.)

Edit Distance Over an Arbitrary Metric

The simple edit distance between two strings $x$ and $y$ is the minimum number of insertions, deletions, and substitutions needed to transform $x$ into $y$. In this paper we will mostly focus on a more general variant of edit distance, in which characters are taken from an arbitrary metric:

Definition 2.3**.**

Let $x$ and $y$ be strings over an alphabet $\Sigma$, where $(\Sigma\cup\{\emptyset\},d)$ is a metric space. We say that the magnitude $|l|$ of a letter $l\in\Sigma$ is $d(\emptyset,l)$. We define the edit distance between $x$ and $y$ to be the minimum cost of a sequence of edits from $x$ to $y$, where the insertion or deletion of a letter $l$ costs $d(\emptyset,l)$, and the substitution of a letter $l$ to a letter $l^{\prime}$ costs $d(l,l^{\prime})$.

3 Computing DTW in the Low-Distance Regime

In this section, we present a low-distance regime algorithm for DTW (with characters from an arbitrary metric in which all non-zero distances are at least one). Given that $\operatorname{dtw}(x,y)$ is bounded above by a parameter $K$, our algorithm can compute $\operatorname{dtw}(x,y)$ in time $O(nK)$. Moreover, if $\operatorname{dtw}(x,y)>K$, then the algorithm will conclude as much. Consequently, by doubling our guess for $K$ repeatedly, one can compute $\operatorname{dtw}(x,y)$ in time $O(n\cdot\operatorname{dtw}(x,y))$.

Consider $x$ and $y$ of length $n$ with characters taken from a metric space $\Sigma$ in which all non-zero distances are at least one. In the textbook dynamic program for DTW [31], each pair of indices $i,j\in[n]$ represents a subproblem $T(i,j)$ whose value is $\operatorname{dtw}(x[1:i],y[1:j])$. Since $T(i,j)$ can be determined using $T(i-1,j),T(i,j-1),T(i-1,j-1)$, and knowledge of $x_{i}$ and $y_{j}$, this leads to an $O(n^{2})$ algorithm for DTW. A common heuristic in practice is to construct only a small band around the main diagonal of the dynamic programming grid; by computing only entries $T(i,j)$ with $|i-j|\leq 2K$, and treating other subproblems as having infinite return values, one can obtain a correct computation for DTW as long as there is an optimal correspondence which matches only letters which are within $K$ of each other in position. This heuristic is known as the Sakoe-Chiba Band [39] and is employed, for example, in the commonly used library of Giorgino [25].

The Sakoe-Chiba Band heuristic can perform badly even when $\operatorname{dtw}(x,y)$ is very small, however. Consider $x=abbb\cdots b$ and $y=aaa\cdots ab$. Although $\operatorname{dtw}(x,y)=0$, if we restrict ourselves to matching letters within $K$ positions of each other for some small $K$, then the resulting correspondence will cost $\Omega(n)$.

In order to obtain an algorithm which performs well in the low-distance regime, we introduce a new dynamic program for DTW. The new dynamic program treats $x$ and $y$ asymmetrically within each subproblem. Loosely speaking, for indices $i$ and $j$, there are two subproblems $\operatorname{SP}(x,y,i,j)$ and $\operatorname{SP}(y,x,i,j)$. The first of these subproblems evaluates to the DTW between the first $i$ runs of $x$ and the first $j$ letters of $y$, with the added condition that the final run of $y[1:j]$ is not extended. The second of the subproblems is analogously defined as the DTW between the first $i$ runs of $y$ and the first $j$ letters of $x$ with the added condition that the final run of $x[1:j]$ is not extended.

The recursion connecting the new subproblems is somewhat more intricate than for the textbook dynamic program. By matching the $i$-th run with the $j$-th letter, however, we limit the number of subproblems which can evaluate to less than $K$. In particular, if the $j$-th letter of $y$ is in $y$’s $t$-th run, then any correspondence which matches the $i$-th run of $x$ to the $j$-th letter of $y$ must cost at least $\Omega(|i-t|)$. (This is formally shown in Appendix A.) Thus for a given $j$, there are only $O(K)$ options for $i$ such that $\operatorname{SP}(x,y,i,j)$ can possibly be at most $K$, and similarly for $\operatorname{SP}(y,x,i,j)$. Since we are interested in the case of $\operatorname{dtw}(x,y)\leq K$, we can restrict ourselves to the $O(nK)$ subproblems which have the potential to evaluate to at most $O(K)$. Notice that, in fact, our algorithm will work even when $\operatorname{dtw}(x,y)>K$ as long as there is an optimal correspondence between $x$ and $y$ which only matches letters from $x$ from the $r_{x}$-th run with letters from $y$ from the $r_{y}$-th run if $|r_{x}-r_{y}|\leq O(K)$.

Formally we define our recursive problems in a manner slightly different from that described above. Let $x$ and $y$ be strings of length at most $n$ and let $K$ be a parameter which we assume is greater than $\operatorname{dtw}(x,y)$. Our subproblems will be the form $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$, which is defined as follows. Let $x^{\prime}$ consist of the first $r_{x}$ runs of $x$ and $y^{\prime}$ consist of the first $r_{y}$ runs of $y$ until the $o_{y}$-th letter in the $r_{y}$-th run. Then $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$ is the value of the optimal correspondence between $x^{\prime}$ and $y^{\prime}$ such that the $r_{y}$-th run in $y^{\prime}$ is not extended.333If $o_{y}=0$, then the $r_{y}$-th run in $y^{\prime}$ is empty and thus trivially cannot be extended. If no such correspondence exists (which can only happen if $r_{y}\leq 1$ or $r_{x}=0$), then the value of the subproblem is $\infty$. Note that we allow $r_{x},r_{y},o_{y}$ to be zero, and if $r_{y}$ is zero, then $o_{y}$ must be zero as well. We also consider the symmetrically defined subproblems of the form $\operatorname{SP}(y,x,r_{y},r_{x},o_{x})$. We will focus on the subproblems of the first types, implicitly treating subproblems of the second type symmetrically.

Example 3.1*.*

Suppose characters are taken from generalized Hamming space, with distances of 0 and 1. The subproblem $\operatorname{SP}(efabbccccd,ffaabcccddd,5,4,2)$ takes the value of the optimal correspondence between $efabbcccc$ and $ffaabcc$ such that the final $cc$ run in the latter is not extended. The subproblem’s value turns out to be 3, due to the correspondence:

[TABLE]

The next lemma presents the key recursive relationship between subproblems. The lemma focuses on the case where $r_{x},r_{y},o_{y}\geq 1$.

Lemma 3.2**.**

Suppose that $r_{x}$ and $r_{y}$ are both between $1$ and the number of runs in $x$ and $y$ respectively; and that $o_{y}$ is between $1$ and the length of the $r_{y}$-th run in $y$. Let $l_{x}$ be the length of the $r_{x}$-th run in $x$ and $l_{y}$ be the length of the $r_{y}$-th run in $y$. Let $d$ be the distance between the letter populating the $r_{x}$-th run in $x$ and the letter populating the $r_{y}$-th run in $y$. Then $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$ is given by

[TABLE]

Proof.

Consider a minimum-cost correspondence $A$ between the first $r_{x}$ runs of $x$ and the portion of $y$ up until the $o_{y}$-th letter in the $r_{y}$-th run, such that the $r_{y}$-th run in $y$ is not extended.

If the $r_{x}$-th run in $A$ is extended, then the cost of $A$ will be $\operatorname{SP}(x,y,r_{x},r_{y},o_{y}-1)+d$. If the $r_{x}$-th run in $A$ is not extended, then we consider two cases.

In the first case, $l_{x}\leq o_{y}$. In this case, the entirety of the $r_{x}$-th run of $x$ is engulfed by the $r_{y}$-th run of $y$ in the correspondence $A$. Since the $r_{x}$-th run is not extended, the cost of the overlap is $l_{x}\cdot d$. Thus the cost of $A$ must be $\operatorname{SP}(x,y,r_{x}-1,r_{y},o_{y}-l_{x})+d\cdot l_{x}.$

Moreover, since $A$ is minimum-cost, as long as $l_{x}\leq o_{y}$, the cost of $A$ is at most the above expression, regardless of whether the $r_{x}$-th run in $x$ is extended in $A$.

In the second case, $l_{x}>o_{y}$. In this case, the first $o_{y}$ letters in the $r_{y}$-th run of $y$ all overlap the $r_{x}$-th run of $x$ in $A$. Since the $r_{y}$-th run is not extended, the cost of the overlap is $d\cdot o_{y}$. Thus, since the $r_{x}$-th run in $x$ is also not extended in $A$, the cost of $A$ must be $\operatorname{SP}(y,x,r_{y}-1,r_{x},l_{x}-o_{y})+d\cdot o_{y}.$ Moreover, since $A$ is minimal, as long as $l_{x}>o_{y}$, the cost of $A$ is at most the above expression, regardless of whether the $r_{x}$-th run in $x$ is extended. ∎

The above lemma handles cases where $r_{x},r_{y},o_{y}>0$. In the case where $r_{x}>0$, $r_{y}>0$, and $o_{y}=0$, $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$ is just the dynamic time warping distance between the first $r_{x}$ runs of $x$ and the first $r_{y}-1$ runs of $y$, given by $\min\left(\operatorname{SP}(x,y,r_{x},r_{y}-1,t_{1}),\operatorname{SP}(y,x,r_{y}-1,r_{x},t_{2})\right),$ where $t_{1}$ is the length of the $(r_{y}-1)$-th run in $y$ and $t_{2}$ is the length of the $r_{x}$-th run in $x$. The remaining cases are edge-cases with $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})\in\{0,\infty\}$. (See Appendix A.)

One can show that any correspondence $A$ in which a letter from the $r_{x}$-th run of $x$ is matched with a letter from the $r_{y}$-th run of $y$ must contain must contain at least $\frac{|r_{x}-r_{y}|-1}{2}$ instances of unequal letters being matched; we prove this in Appendix A. It follows that if $\operatorname{dtw}(x,y)\leq K$, then we can limit ourselves to subproblems in which $|r_{x}-r_{y}|\leq O(K)$. For each of the $n$ options of $(r_{y},o_{y})$, there are only $O(K)$ options of $r_{x}$ that must be considered. This limits the total number of subproblems to $O(nK)$. The resulting dynamic program yields the following theorem:

Theorem 3.3**.**

Let $x$ and $y$ be strings of length $n$ taken from a metric space $\Sigma$ with minimum non-zero distance at least one, and let $K$ be parameter such that $\operatorname{dtw}(x,y)\leq K$. Then there exists a dynamic program for computing $\operatorname{dtw}(x,y)$ in time $O(nK)$. Moreover, if $\operatorname{dtw}(x,y)>K$, then the dynamic program will return a value greater than $K$.

By repeatedly doubling one’s guess for $K$ until the computed value of $\operatorname{dtw}(x,y)$ evaluates to less than $K$, one can therefore compute $\operatorname{dtw}(x,y)$ in time $O(n\cdot\operatorname{dtw}(x,y))$.

4 Approximating DTW Over Well-Separated Tree Metrics

In this section, we present an $\tilde{O}(n^{2-\epsilon})$-time $O(n^{\epsilon})$-approximation algorithm for DTW over a well-separated tree metric with logarithmic depth. We begin by presenting a brief background on well-separated tree metrics.

Definition 4.1**.**

Consider a tree $T$ whose vertices form an alphabet $\Sigma$, and whose edges have positive weights. $T$ is said to be a well-separated tree metric if every root-to-leaf path consists of edges ordered by nonincreasing weight. The distance between two nodes $u,v\in\Sigma$ is defined as the maximum weight of any edge in the shortest path from $u$ to $v$.

Well-separated tree metrics are universal in the sense that any metric $\Sigma$ can be efficiently embedded (in time $O(|\Sigma|^{2})$) into a well-separated tree metric $T$ with expected distortion $O(\log|\Sigma|)$ [23]. Moreover, the tree metric may be made to have logarithmic depth using Theorem 8 of [8]. For strings $x,y\in\Sigma^{n}$, let $\operatorname{dtw}_{T}(x,y)$ denote the dynamic time warping distance after embedding $\Sigma$ into $T$. Then the tree-metric embedding guarantees that $\operatorname{dtw}(x,y)\leq\operatorname{dtw}_{T}(x,y)$ and that $\mathbb{E}[\operatorname{dtw}_{T}(x,y)]\leq O(\log n)\cdot\operatorname{dtw}(x,y)$. (The latter fact is slightly nontrivial and is further explained in Appendix B.)

It follows that any approximation algorithm for DTW over well-separated tree metrics will immediately yield an approximation algorithm over an arbitrary polynomial-size metric $\Sigma$, with two caveats: the new algorithm will have its multiplicative error increased by $O(\log n)$; and $O(\log n)$ instances of $\Sigma$ embedded into a well-separated tree metric must be precomputed for use by the algorithm (requiring, in general, $O(|\Sigma|^{2}\log n)$ preprocessing time). In particular, given $O(\log n)$ tree embeddings of $\Sigma$, $T_{1},\ldots,T_{O(\log n)}$, with high probability $\min_{i}\left(\operatorname{dtw}_{T_{i}}(x,y)\right)$ will be within a logarithmic factor of $\operatorname{dtw}(x,y)$.

The remainder of the section will be devoted to designing an approximation algorithm for DTW over a well-separated tree metric. We will prove the following theorem:

Theorem 4.2**.**

Consider $0<\epsilon<1$. Suppose that $\Sigma$ is a well-separated tree metric of polynomial size and at most logarithmic depth. Moreover, suppose that the aspect ratio of $\Sigma$ is at most exponential in $n$ (i.e., the ratio between the largest distance and the smallest non-zero distance). Then in time $\tilde{O}(n^{2-\epsilon})$ we can obtain an $O(n^{\epsilon})$-approximation for $\operatorname{dtw}(x,y)$ for any $x,y\in\Sigma^{n}$.

An important consequence of the theorem occurs for DTW over the reals. When $\Sigma$ is an $O(n)$-point subset of the reals with a polynomial aspect ratio, there exists an $O(n\log n)$-time embedding with $O(\log n)$ expected distortion from $\Sigma$ to a well-separated tree metric of size $O(n)$ with logarithmic depth. (See Appendix B). This gives the following corollary:

Corollary 4.3**.**

Consider $0<\epsilon<1$. Suppose that $\Sigma=[0,n^{c}]\cap\mathbb{Z}$ for some constant $c$. Then in time $\tilde{O}(n^{2-\epsilon})$ we can obtain an $O(n^{\epsilon})$-approximation for $\operatorname{dtw}(x,y)$ with high probability for any $x,y\in\Sigma^{n}$.

In proving Theorem 4.2, our approximation algorithm will take advantage of what we refer to as the $r$-simplification of a string over a well-separated tree metric.

Definition 4.4**.**

Let $T$ be a well-separated tree metric whose nodes form an alphabet $\Sigma$. For a string $x\in\Sigma^{n}$, and for any $r\geq 1$, the $r$-simplification $s_{r}(x)$ is constructed by replacing each letter $l\in x$ with its highest ancestor $l^{\prime}$ in $T$ that can be reached from $l$ using only edges of weight at most $r/4$.

Our approximation algorithm will apply the low-distance regime algorithm from the previous section to $s_{r}(x)$ and $s_{r}(y)$ for various $r$ in order to extract information about $\operatorname{dtw}(x,y)$. Notice that using our low-distance regime algorithm for DTW, we get the following useful lemma for free:

Lemma 4.5**.**

Consider $0<\epsilon<1$. Suppose that for all pairs $l_{1},l_{2}$ of distinct letters in $\Sigma$, $d(l_{1},l_{2})\geq\gamma$. Then for $x,y\in\Sigma^{n}$ there is an $O(n^{2-\epsilon})$ time algorithm which either computes $\operatorname{dtw}(x,y)$ exactly, or concludes that $\operatorname{dtw}(x,y)>\gamma n^{1-\epsilon}$.

The next lemma states three important properties of $r$-simplifications. We remark that the same lemma appears in our concurrent work on the communication complexity of DTW, in which we use the lemma in designing an efficient one-way communication protocol [13].

Lemma 4.6**.**

Let $T$ be a well-separated tree metric with distance function $d$ and whose nodes form the alphabet $\Sigma$. Consider strings $x$ and $y$ in $\Sigma^{n}$.

Then the following three properties of $s_{r}(x)$ and $s_{r}(y)$ hold:

• •

For every letter $l_{1}\in s_{r}(x)$ and every letter $l_{2}\in s_{r}(y)$, if $l_{1}\neq l_{2}$, then $d(l_{1},l_{2})>r/4$.

• •

For all $\alpha$, if $\operatorname{dtw}(x,y)\leq nr/\alpha$ then $\operatorname{dtw}(s_{r}(x),s_{r}(y))\leq nr/\alpha$.

• •

If $\operatorname{dtw}(x,y)>nr$, then $\operatorname{dtw}(s_{r}(x),s_{r}(y))>nr/2$.

The first and second parts of Lemma 4.6 are straightforward from the definitions of $s_{r}(x)$ and $s_{r}(y)$. The third part follows from the observation that a correspondence $C$ between $x$ and $y$ can cost at most $|C|\cdot\frac{r}{4}$ more than the corresponding correspondence between $s_{r}(x)$ and $s_{r}(y)$, where $|C|$ denotes the length of the correspondence. Since there exists an optimal correspondence between $s_{r}(x)$ and $s_{r}(y)$ of length no more than $2n$, it follows that $\operatorname{dtw}(x,y)\leq\operatorname{dtw}(s_{r}(x),s_{r}(y))+nr/2$, which implies the third part of the lemma.

A full proof of Lemma 4.6 appears in Appendix B. Next we prove Theorem 4.2.

Proof of Theorem 4.2.

Without loss of generality, the minimum non-zero distance in $\Sigma$ is 1 and the largest distance is some value $m$, which is at most exponential in $n$.

We begin by defining the $(r,n^{\epsilon})$-DTW gap problem for $r\geq 1$, in which for two strings $x$ and $y$ a return value of 0 indicates that $\operatorname{dtw}(x,y)<nr$ and a return value of 1 indicates that $\operatorname{dtw}(x,y)\geq n^{1-\epsilon}r$. By Lemma 4.6, in order to solve the $(r,n^{\epsilon})$-DTW gap problem for $x$ and $y$, it suffices to determine whether $\operatorname{dtw}(s_{r}(x),s_{r}(y))\leq n^{1-\epsilon}r$. Moreover, because the minimum distance between distinct letters in $s_{r}(x)$ and $s_{r}(y)$ is at least $r/4$, this can be done in time $O(n^{2-\epsilon}\log n)$ using Lemma 4.5.444The logarithmic factor comes from the fact that evaluating distances between points may take logarithmic time in our well-separated tree metric.

In order to obtain an $n^{\epsilon}$-approximation for $\operatorname{dtw}(x,y)$, we begin by using Lemma 4.5 to either determine $\operatorname{dtw}(x,y)$ or to determine that $\operatorname{dtw}(x,y)\geq n^{1-\epsilon}$. For the rest of the proof, suppose we are in the latter case, meaning that we know $\operatorname{dtw}(x,y)\geq n^{1-\epsilon}$.

We will now consider the $(2^{i},n^{\epsilon}/2)$-DTW gap problem for $i\in\{0,1,2,\ldots,\lceil\log m\rceil\}$. (Recall that $m$ is the largest distance in $\Sigma$.) If the $(2^{0},n^{\epsilon}/2)$-DTW gap problem returned 0, then we would know that $\operatorname{dtw}(x,y)\leq n$, and thus we could return $n^{1-\epsilon}$ as an $n^{\epsilon}$-approximation for $\operatorname{dtw}(x,y)$. Therefore, we need only consider the case where the $(2^{0},n^{\epsilon}/2)$-DTW gap returns $1$. Moreover we may assume without computing it that $(2^{\lceil\log m\rceil},n^{\epsilon}/2)$-DTW gap returns 0 since trivially $\operatorname{dtw}(x,y)$ cannot exceed $nm$. Because $(2^{i},n^{\epsilon}/2)$-DTW gap returns 1 for $i=0$ and returns [math] for $i=\lceil\log m\rceil$, there must be some $i$ such that $(2^{i-1},n^{\epsilon}/2)$-DTW gap returns $1$ and $(2^{i},n^{\epsilon}/2)$-DTW gap returns 0. Moreover, we can find such an $i$ by performing a binary search on $i$ in the range $R=\{0,\ldots,\lceil\log m\rceil\}$. We begin by computing $(2^{i},n^{\epsilon}/2)$-DTW gap for $i$ in the middle of the range $R$. If the result is a one, then we can recurse on the second half of the range; otherwise we recurse on the first half of the range. Continuing like this, we can find in time $\tilde{O}(n^{2-\epsilon}\log\log m)=\tilde{O}(n^{2-\epsilon})$ some value $i$ for which $(2^{i-1},n^{\epsilon}/2)$-DTW gap returns $1$ and $(2^{i},n^{\epsilon}/2)$-DTW gap returns 0. Given such an $i$, we know that $\operatorname{dtw}(x,y)\geq\frac{2^{i-1}n}{n^{\epsilon}/2}=2^{i}n^{1-\epsilon}$ and that $\operatorname{dtw}(x,y)\leq 2^{i}n$. Thus we can return $2^{i}n^{1-\epsilon}$ as an $n^{\epsilon}$ approximation of $\operatorname{dtw}(x,y)$. ∎

5 Reducing Edit Distance to DTW and LCS

In this section we present a simple reduction from edit distance over an arbitrary metric to DTW over the same metric.At the end of the section, we prove as a corollary a conditional lower bound for DTW over three-letter Hamming space, prohibiting any algorithm from running in strongly subquadratic time.

Surprisingly, the exact same reduction, although with a different analysis, can be used to reduce the computation of edit distance (over generalized Hamming space) to the computation of longest-common-subsequence length (LCS). Since computing LCS is equivalent to computing edit distance without substitutions, this reduction can be interpreted as proving that edit distance without substitutions can be used to efficiently simulate edit distance with substitutions, also known as simple edit distance.

Recall that for a metric $\Sigma\cup\{\emptyset\}$, we define the edit distance between two strings $x,y\in\Sigma^{n}$ such that the cost of a substitution from a letter $l_{1}$ to $l_{2}$ is $d(l_{1},l_{2})$, and the cost of a deletion or insertion of a letter $l$ is $d(l,\emptyset)$. Additionally, define the simple edit distance $\operatorname{ed}_{S}(x,y)$ to be the edit distance using only insertions and deletions.

For a string $x\in\Sigma^{n}$, define the padded string $p(x)$ of length $2n+1$ to be the string $\emptyset x_{1}\emptyset x_{2}\emptyset x_{3}\cdots x_{n}\emptyset$. In particular, for $i\leq 2n+1$, $p(x)_{i}=\emptyset$ when $i$ is odd, and $p(x)_{i}=x_{i/2}$ when $i$ is even. The following theorem proves that $\operatorname{dtw}(p(x),p(y))=\operatorname{ed}(x,y)$.

Theorem 5.1**.**

Let $\Sigma\cup\{\emptyset\}$ be a metric. Then for any $x,y\in\Sigma^{n}$, $\operatorname{dtw}(p(x),p(y))=\operatorname{ed}(x,y).$

Proof sketch.

A key observation is that when constructing an optimal correspondence between $p(x)$ and $p(y)$, one may w.l.o.g. extend only runs consisting of $\emptyset$ characters. In particular, suppose that one extends a non-$\emptyset$ character $a$ in $p(x)$ to match a non-$\emptyset$ character $b$ in $p(y)$. Then the extended run of $a$’s must not only overlap $b$, but also the $\emptyset$-character preceding $b$. The total cost of extending $a$ to overlap $b$ is therefore $d(a,\emptyset)+d(a,b)$, which by the triangle inequality is at least $d(\emptyset,b)$. Thus instead of extending the run containing $a$, one could have instead extend a run of $\emptyset$-characters to overlap $b$ at the same cost.

The fact that optimal correspondences arise by simply extending runs of $\emptyset$-characters can then be used to prove Theorem 5.1; in particular, given such a correspondence, one can obtain a sequence of edits from $x$ to $y$ by performing a substitution every time the correspondence matches two non-$\emptyset$ characters and a insertion or deletion every time the correspondence matches a non-$\emptyset$ character and a $\emptyset$-character. ∎

Theorem 5.2 proves an analogous reduction from edit distance to LCS.

Theorem 5.2**.**

Let $\Sigma$ be a generalized Hamming metric. Then for any $x,y\in\Sigma^{n}$, $\operatorname{ed}_{S}(p(x),p(y))=2\operatorname{ed}(x,y)$.

Proof sketch.

Each edit in $x$ can be simulated in $s(x)$ using exactly two insertions/deletions. In particular, the substitution of a character in $x$ corresponds with the deletion and insertion of the same character in $s(x)$; and the insertion/deletion of a character in $x$ corresponds with the insertion/deletion of that character and an additional $\emptyset$-character in $s(x)$.

This establishes that $\operatorname{ed}_{S}(p(x),p(y))\leq 2\operatorname{ed}(x,y)$. The other direction of inequality is somewhat more subtle, and is differed to Appendix C. ∎

Whereas Theorem 5.2 embeds edit distance into simple edit distance with no distortion, Theorem 5.3 shows that no nontrivial embedding in the other direction exists.

Theorem 5.3**.**

Consider edit distance over generalized Hamming space. Any embedding from edit distance to simple edit distance must have distortion at least $2$.

The proofs of Theorems 5.1, 5.2, 5.3 are differed to Appendix C.

An important consequence of Theorem 5.1 is a new conditional lower bound for computing DTW over a three-letter alphabet (in which character distances are zero or one). This concludes a direction of work initiated by Abboud, Backurs, and Williams [3], who proved the same result over five-letter alphabet.

Corollary 5.4**.**

Let $\Sigma=\{a,b,c\}$ with distance function $d(a,b)=d(a,c)=d(b,c)=1$. If we assume the Strong Exponential Time Hypothesis, then for all $\epsilon>1$, no algorithm can compute $\operatorname{dtw}(x,y)$ for $x,y\in\Sigma^{n}$ in time less than $O(n^{2-\epsilon})$.

Proof.

See Appendix C. ∎

6 Approximating Edit Distance Over an Arbitrary Metric

In this section we present an approximation algorithm for edit distance over an arbitrary metric space. Our algorithm achieves approximation ratio at most $n^{\epsilon}$ (with high probability) and runtime $\tilde{O}(n^{2-\epsilon})$. Note that when the metric is a well-separated tree metric, such an algorithm can be obtained by combining the approximation algorithm for DTW from Section 4 with the reduction in Section 5. Indeed the algorithm in this section is structurally quite similar to the one in Section 4, but uses a probability argument exploiting properties of edit distance in order to hold over an arbitrary metric.

Theorem 6.1**.**

Let $(\Sigma\cup\{\emptyset\},d)$ be an arbitrary metric space such that $|l|\geq 1$ for all $l\in\Sigma$. For all $0<\epsilon<1$, and for strings $x,y\in\Sigma^{n}$, there is an algorithm which computes an $O(n^{\epsilon})$-approximation for $\operatorname{ed}(x,y)$ (with high probability) in time $\tilde{O}(n^{2-\epsilon})$.

Using the standard dynamic-programming algorithm for computing $\operatorname{ed}(x,y)$ [43, 37, 42], one can easily obtain the following observation, analogous to Lemma 4.5 in Section 4:

Observation 6.2*.*

Consider $x,y\in\Sigma^{n}$, and let $R$ be the smallest magnitude of the letters in $x$ and $y$. There is an $O(n^{2-\epsilon})$-time algorithm which returns a value at least as large as $\operatorname{ed}(x,y)$; and which returns exactly $\operatorname{ed}(x,y)$ when $\operatorname{ed}(x,y)\leq R\cdot n^{1-\epsilon}$.

In order to prove Theorem 6.1, we present a new definition of the $r$-simplification of a string. The difference between this definition and the one in the preceding section allows the new definition to be useful when studying edit distance rather than dynamic time warping.

Definition 6.3**.**

For a string $x\in\Sigma^{n}$ and for $r\geq 1$, we construct the $r$-simplification $s_{r}(x)$ by removing any letter $l$ satisfying $|l|\leq r$.

In the proof of Theorem 6.1 we use randomization in the selection of $r$ in order to ensure that $s_{r}(x)$ satisfies desirable properties in expectation. The key proposition follows:

Proposition 6.4**.**

Consider strings $x$ and $y$ in $\Sigma^{n}$. Consider $0<\epsilon<1$ and $R\geq 1$. Select $r$ to be a random real between $R$ and $2R$. Then the following three properties hold:

• •

Every letter $l$ in $s_{r}(x)$ or $s_{r}(y)$ satisfies $|l|\geq R$.

• •

If $\operatorname{ed}(x,y)\leq\frac{nR}{15n^{\epsilon}}$ then $\mathbb{E}[\operatorname{ed}(s_{r}(x),s_{r}(y))]\leq\frac{nR}{3n^{\epsilon}}$.

• •

If $\operatorname{ed}(x,y)>5nR$, then $\operatorname{ed}(s_{r}(x),s_{r}(y))>nR$.

The full proofs of Proposition 6.4 and of Theorem 6.1 appear in Appendix D. Structurally, both proofs are similar to the analogous results in Section 4. The key difference appears in the proof of the second part of Proposition 6.4, which uses the random selection of $r$ in order to probabilistically upper-bound $\operatorname{ed}(s_{r}(x),s_{r}(y)$. This is presented below.

Lemma 6.5**.**

Consider strings $x$ and $y$ in $\Sigma^{n}$. Consider $R\geq 1$ and select $r$ to be a random real between $R$ and $2R$. Then $\mathbb{E}[\operatorname{ed}(s_{r}(x),s_{r}(y))]\leq 5\operatorname{ed}(x,y)$.

Proof.

Consider an optimal sequence $S$ of edits from $x$ to $y$. We will consider the cost of simulating this sequence of edits to transform $s_{r}(x)$ to $s_{r}(y)$. Insertions and deletions are easily simulated by either performing the same operation to $s_{r}(x)$ or performing no operation at all (if the operation involves a letter of magnitude less than or equal to $r$). Substitutions are slightly more complicated as they may originally be between letters $l_{1}\in x$ and $l_{2}\in y$ of different magnitudes. By symmetry, we may assume without loss of generality that $|l_{1}|<|l_{2}|$. We will show that the expected cost of simulating the substitution of $l_{1}$ to $l_{2}$ in $s_{r}(x)$ is at most $5d(l_{1},l_{2})$. Because insertions and deletions can be simulated with no overhead, it follows that $\mathbb{E}[\operatorname{ed}(s_{r}(x),s_{r}(y))]\leq 5\operatorname{ed}(x,y)$.

If $|l_{1}|\leq r<|l_{2}|$ then $l_{1}$ does not appear in $s_{r}(x)$ but $l_{2}$ remains in $s_{r}(y)$. Thus what was previously a substitution of $l_{1}$ with $l_{2}$ becomes an insertion of $l_{2}$ at cost $|l_{2}|$. On the other hand, if we do not have $|l_{1}|\leq r<|l_{2}|$, then either both $l_{1}$ and $l_{2}$ are removed from $s_{r}(x)$ and $s_{r}(y)$ respectively, in which the substitution operation no longer needs to be performed, or both $l_{1}$ and $l_{2}$ are still present, in which case the substitution operation can still be performed at cost $d(l_{1},l_{2})$. Therefore, the expected cost of simulating the substitution of $l_{1}$ to $l_{2}$ in $s_{r}(x)$ is at most

[TABLE]

Because $r$ is selected at random from the range $[R,2R]$, the probability that $|l_{1}|\leq r<|l_{2}|$ is at most $\frac{|l_{2}|-|l_{1}|}{R}$. By the triangle inequality, this is at most $\frac{d(l_{1},l_{2})}{R}.$ If we suppose that $|l_{2}|\leq 4R$, then it follows by (1) that the expected cost of simulating the substitution of $l_{1}$ to $l_{2}$ in $s_{r}(x)$ is at most $\frac{d(l_{1},l_{2})}{R}\cdot 4R+d(l_{1},l_{2})\leq 5d(l_{1},l_{2}).$

If, on the other hand, $|l_{2}|>4R$, then in order for $|l_{1}|\leq r$ to be true, we must have $|l_{1}|\leq 2R$, meaning by the triangle inequality that $d(l_{1},l_{2})\geq|l_{2}|/2$. Thus in this case $|l_{2}|\leq 2d(l_{1},l_{2})$, meaning by (1) that the expected cost of simulating the substitution of $l_{1}$ to $l_{2}$ in $s_{r}(x)$ is at most three times as expensive as the original substitution. ∎

Acknowledgments

I would like to thank Moses Charikar for his mentoring and advice throughout the project, Ofir Geri for his support and for many useful conversations, and Virginia Williams for suggesting the problem of reducing between edit distance and LCS. I would also like to thank Paweł Gawrychowski for making me aware of [40]. This research is supported by an MIT Akamai Fellowship and a Fannie & John Hertz Foundation Fellowship. This research was also supported in part by NSF Grants 1314547 and 1533644. Parts of this research were performed during the Stanford CURIS research program.

Appendix A Computing DTW in the Low-Distance Regime

In this section, we present a low-distance regime algorithm for DTW (with characters from an arbitrary metric in which all non-zero distances are at least one). Given that $\operatorname{dtw}(x,y)$ is bounded above by a parameter $K$, our algorithm can compute $\operatorname{dtw}(x,y)$ in time $O(nK)$. Moreover, if $\operatorname{dtw}(x,y)>K$, then the algorithm will conclude as much. Consequently, by doubling our guess for $K$ repeatedly, one can compute $\operatorname{dtw}(x,y)$ in time $O(n\cdot\operatorname{dtw}(x,y))$.

Consider $x$ and $y$ of length $n$ with characters taken from a metric space $\Sigma$ in which all non-zero distances are at least one. In the textbook dynamic program for DTW [31], each pair of indices $i,j\in[n]$ represents a subproblem $T(i,j)$ whose value is $\operatorname{dtw}(x[1:i],y[1:j])$. Since $T(i,j)$ can be determined using $T(i-1,j),T(i,j-1),T(i-1,j-1)$, and knowledge of $x_{i}$ and $y_{j}$, this leads to an $O(n^{2})$ algorithm for DTW. A common heuristic in practice is to construct only a small band around the main diagonal of the dynamic programming grid; by computing only entries $T(i,j)$ with $|i-j|\leq 2K$, and treating other subproblems as having infinite return values, one can obtain a correct computation for DTW as long as there is an optimal correspondence which matches only letters which are within $K$ of each other in position. This heuristic is known as the Sakoe-Chiba Band [39] and is employed, for example, in the commonly used library of Giorgino [25].

The Sakoe-Chiba Band heuristic can perform badly even when $\operatorname{dtw}(x,y)$ is very small, however. Consider $x=abbb\cdots b$ and $y=aaa\cdots ab$. Although $\operatorname{dtw}(x,y)=0$, if we restrict ourselves to matching letters within $K$ positions of each other for some small $K$, then the resulting correspondence will cost $\Omega(n)$.

In order to obtain an algorithm which performs well in the low-distance regime, we introduce a new dynamic program for DTW. The new dynamic program treats $x$ and $y$ asymmetrically within each subproblem. Loosely speaking, for indices $i$ and $j$, there are two subproblems $\operatorname{SP}(x,y,i,j)$ and $\operatorname{SP}(y,x,i,j)$. The first of these subproblems evaluates to the DTW between the first $i$ runs of $x$ and the first $j$ letters of $y$, with the added condition that the final run of $y[1:j]$ is not extended. The second of the subproblems is analogously defined as the DTW between the first $i$ runs of $y$ and the first $j$ letters of $x$ with the added condition that the final run of $x[1:j]$ is not extended.

The recursion connecting the new subproblems is somewhat more intricate than for the textbook dynamic program. By matching the $i$-th run with the $j$-th letter, however, we limit the number of subproblems which can evaluate to less than $K$. In particular, if the $j$-th letter of $y$ is in $y$’s $t$-th run, then any correspondence which matches the $i$-th run of $x$ to the $j$-th letter of $y$ must cost at least $\Omega(|i-t|)$ (Lemma A.3). Thus for a given $j$, there are only $O(K)$ options for $i$ such that $\operatorname{SP}(x,y,i,j)$ can possibly be at most $K$, and similarly for $\operatorname{SP}(y,x,i,j)$. Since we are interested in the case of $\operatorname{dtw}(x,y)\leq K$, we can restrict ourselves to the $O(nK)$ subproblems which have the potential to evaluate to at most $O(K)$. Notice that, in fact, our algorithm will work even when $\operatorname{dtw}(x,y)>K$ as long as there is an optimal correspondence between $x$ and $y$ which only matches letters from $x$ from the $r_{x}$-th run with letters from $y$ from the $r_{y}$-th run if $|r_{x}-r_{y}|\leq O(K)$.

We will now formally present our algorithm. For the rest of the section let $x$ and $y$ be strings of length at most $n$ and let $K$ be a parameter which we assume is greater than $\operatorname{dtw}(x,y)$. We will present an $O(nK)$ time algorithm for computing $\operatorname{dtw}(x,y)$.

Our subproblems will be of the form $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$, which is defined as follows. Let $x^{\prime}$ consist of the first $r_{x}$ runs of $x$ and $y^{\prime}$ consist of the first $r_{y}$ runs of $y$ until the $o_{y}$-th letter in the $r_{y}$-th run. Then $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$ is the value of the optimal correspondence between $x^{\prime}$ and $y^{\prime}$ such that the $r_{y}$-th run in $y^{\prime}$ is not extended.555If $o_{y}=0$, then the $r_{y}$-th run in $y^{\prime}$ is empty and thus trivially cannot be extended. If no such correspondence exists (which can only happen if $r_{y}\leq 1$ or $r_{x}=0$), then the value of the subproblem is $\infty$. Note that we allow $r_{x},r_{y},o_{y}$ to be zero, and if $r_{y}$ is zero, then $o_{y}$ must be zero as well.

We will also consider the symmetrically defined subproblems of the form $\operatorname{SP}(y,x,r_{y},r_{x},o_{x})$, though for simplicity we will only prove recursions for subproblems of the first type. (These recursions will involve subproblems of the second type, however.)

Example A.1*.*

Suppose characters are taken from generalized Hamming space, with distances of zero and one. The subproblem $\operatorname{SP}(efabbccccd,ffaabcccddd,5,4,2)$ takes the value of the optimal correspondence between $efabbcccc$ and $ffaabcc$ such that the final $cc$ run in the latter is not extended. The subproblem’s value turns out to be three, due to the following correspondence:

[TABLE]

Before continuing, we show how to solve for $\operatorname{dtw}(x,y)$ in terms of the subproblems described above.

Lemma A.2**.**

Let $x$ and $y$ be strings. Then there is an optimal correspondence between $x$ and $y$ such that either the final run of $x$ is not extended, or the final run of $y$ is not extended. Consequently, if $x$ has $s$ runs with the final run of length $j$ and $y$ has $t$ runs with the final run of length $k$, then

[TABLE]

Proof.

Consider an optimal correspondence between $x$ and $y$. If both the final run of $x$ and the final run of $y$ are extended in the correspondence, then we can simply un-extend each by one in order to obtain a shorter correspondence which is at least as good. Thus any minimum-length optimal correspondence between $x$ and $y$ must leave either the final run of $x$ unextended or the final run of $y$ unextended. ∎

Because we know that $\operatorname{dtw}(x,y)\leq K$, there is a large class of subproblems we can ignore. This follows from the next lemma, which provides a lower bound for $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$.

Lemma A.3**.**

[TABLE]

Proof.

Consider two strings $a$ and $b$, such that $a$ has $s$ non-empty runs and $b$ has $t$ non-empty runs, with $s<t$. We will show that $\operatorname{dtw}(a,b)\geq\frac{t-s}{2}$. Since $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$ returns a correspondence between the first $r_{x}$ runs of $x$ and a portion of $y$ containing either $r_{y}$ or $r_{y}-1$ (if $o_{y}=0$) non-empty runs, it follows that $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})\geq\frac{|r_{x}-r_{y}|-1}{2}$, as desired.

Consider a correspondence $A$ between $a$ and $b$. Notice that $b$ contains $t-1$ pairs of adjacent letters where the first letter is from a different run than the second (i.e., the two letters are distinct). The correspondence $A$ can match at most $s-1$ of these pairs with pairs of distinct adjacent letters from $a$. Therefore, there are at least $t-s$ pairs of distinct adjacent letters in $b$ which are matched by $A$ with a pair of equal letters in $a$. This means that there are at least $t-s$ pairs of adjacent letters in $b$ such that one of the two letters is mismatched by $A$. Since a mismatched letter can appear in at most two such pairs, there must be at least $\frac{t-s}{2}$ letters mismatched by $A$. ∎

Lemma A.3 restricts the number of subproblems that we are interested in to $O(nK)$. In particular, because we assume $\operatorname{dtw}(x,y)\leq K$, any dynamic program for computing $\operatorname{dtw}(x,y)$ in terms of subproblems of the form $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$ can ignore subproblems in which $|r_{x}-r_{y}|>2K+1$ (as long as the recursion makes each subproblem’s value at least as large as any of the subproblems on which it relies). Now consider how many subproblems $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$ satisfy $|r_{x}-r_{y}|>2K+1$. The options for $r_{y}$ and $o_{y}$ together correspond with the $O(n)$ positions in $y$. For each value of $r_{y}$, there are $O(K)$ values of $r_{x}$ such that $|r_{x}-r_{y}|\leq 2K+1$. Therefore, there are $O(nK)$ subproblems of the form $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$ with $|r_{x}-r_{y}|\leq 2K+1$. Similarly, there are are $O(nK)$ subproblems of the form $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$ with $|r_{x}-r_{y}|\leq 2K+1$.

In order to complete our dynamic program, it remains to present a tree of recursions connecting the subproblems. We begin with a recursion for the case where $r_{x},r_{y},o_{y}\geq 1$.

Lemma A.4**.**

Suppose that $r_{x}$ and $r_{y}$ are both between $1$ and the number of runs in $x$ and $y$ respectively; and that $o_{y}$ is between $1$ and the length of the $r_{y}$-th run in $y$. Let $l_{x}$ be the length of the $r_{x}$-th run in $x$ and $l_{y}$ be the length of the $r_{y}$-th run in $y$. Let $d$ be the distance between the letter populating the $r_{x}$-th run in $x$ and the letter populating the $r_{y}$-th run in $y$. Then $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$ is given by

[TABLE]

Proof.

Consider a minimum-cost correspondence $A$ between the first $r_{x}$ runs of $x$ and the portion of $y$ up until the $o_{y}$-th letter in the $r_{y}$-th run, such that the $r_{y}$-th run in $y$ is not extended.

If the $r_{x}$-th run in $A$ is extended, then the cost of $A$ must be $\operatorname{SP}(x,y,r_{x},r_{y},o_{y}-1)+d$ (and regardless of whether the $r_{x}$-th run in $A$ is extended, this is an upper bound for the cost of $A$).

If the $r_{x}$-th run in $A$ is not extended, then we consider two cases. In the first case, $l_{x}\leq o_{y}$. In this case, The entirety of the $r_{x}$-th run of $x$ is engulfed by the $r_{y}$-th run of $y$ in the correspondence $A$. Since the $r_{x}$-th run is not extended, the cost of the overlap is $l_{x}\cdot d$. Thus the cost of $A$ must be

[TABLE]

Moreover, since $A$ is minimal, as long as $l_{x}\leq o_{y}$, the cost of $A$ is at most the above expression, regardless of whether the $r_{x}$-th run in $x$ is extended in $A$.

In the second case, $l_{x}>o_{y}$. In this case, the first $o_{y}$ letters in the $r_{y}$-th run of $y$ all overlap the $r_{x}$-th run of $x$ in $A$. Since the $r_{y}$-th run is not extended, the cost of the overlap is $d\cdot o_{y}$. Thus, since the $r_{x}$-th run in $x$ is also not extended in $A$, the cost of $A$ must be

[TABLE]

Moreover, since $A$ is minimal, as long as $l_{x}>o_{y}$, the cost of $A$ is at most the above expression, regardless of whether the $r_{x}$-th run in $x$ is extended in $A$. ∎

The cases where at least one of $r_{x},r_{y},o_{y}$ is [math] are easily handled by the following two lemmas.

Lemma A.5**.**

Suppose that $r_{x}>0$ is at most the number of runs in $x$, and $r_{y}\geq 0$ is at most the number of runs in $y$. Further suppose that $o_{y}=0$. If $r_{y}=0$, then $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})=\infty$. Otherwise, let $p_{y}$ be the length of the $(r_{y}-1)$-th run in $y$ (and zero if no such run exists). Then

[TABLE]

Proof.

The case where $r_{y}=0$ is immediate from the fact that $r_{x}>0$ but $r_{y}=0$.

Suppose that $r_{y}\neq 0$. Then because $o_{y}=0$, $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$ is just the dynamic time warping distance between the first $r_{x}$ runs of $x$ and the first $r_{y}-1$ runs of $y$. The recursion therefore follows from Lemma A.2. ∎

Lemma A.6**.**

Suppose that $r_{x}=0$ and $r_{y}\geq 0$. If $r_{y}=0$ and $o_{y}=0$, then $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})=0$. Otherwise, $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})=\infty$.

Proof.

This is immediate from the definition of $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$. ∎

The recursions presented in Lemmas A.4, A.5, A.6 cover every case where $r_{x}$ and $r_{y}$ are between [math] and the number of runs in $x$ and $y$ respectively, and where $o_{y}$ is between [math] and the length of the $r_{y}$-th run (or zero if $r_{y}=0$). Moreover, any recursive call whose inputs satisfy the above conditions will only rely on recursive subcalls whose inputs still satisfy the above conditions.

The recursions can be seen to be acyclic as follows. For a given subproblem either of the form $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$ or $\operatorname{SP}(y,x,r_{y},r_{x},o_{x})$, associate with it a tuple $(r_{x},r_{y},t_{1},t_{2})$, where $t_{1}$ is the length of the portion of $x$ considered by the subproblem and $t_{2}$ is the length of the portion of $y$ considered by the subproblem. The recursions given allow a subproblem to rely on another subproblem only if the latter subproblem’s tuple is dominated by the first subproblem’s tuple. This induces a partial ordering on the subproblems, thereby forcing the recursion to be acyclic. Moreover, because we never recurse on a case where any of $r_{x},r_{y},t_{1},t_{2}$ are negative, the recursion must terminate.

Algorithm 1 is a recursive algorithm for computing $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$ using Lemmas A.4, A.5, A.6. The algorithm can be transformed into a dynamic program using memoization. Taking this approach, we can now prove the main result of the section:

Theorem A.7**.**

Let $x$ and $y$ be strings of length $n$ taken from a metric space $\Sigma$ with minimum non-zero distance at least one, and let $K$ be parameter such that $\operatorname{dtw}(x,y)\leq K$. Then there exists a dynamic program for computing $\operatorname{dtw}(x,y)$ in time $O(nK)$. Moreover, if $\operatorname{dtw}(x,y)>K$, then the dynamic program will return a value greater than $K$.

Proof.

By Lemma A.2, if $x$ has $s$ runs with the final run of length $j$ and $y$ has $t$ runs with the final run of length $k$, then

[TABLE]

By Lemma A.3, the only subproblems to have return value no greater than $K$ are those for which $|r_{x}-r_{y}|\leq 2K+1$. Therefore, if we relax our recursion to return $\infty$ whenever $|r_{x}-r_{y}|>2K+1$, we will still obtain the correct value for $\operatorname{dtw}(x,y)$ when $\operatorname{dtw}(x,y)\leq K$, and we will obtain a value greater than $K$ when $\operatorname{dtw}(x,y)>K$. The resulting recursive algorithm is given by Algorithm 1, and is based on the recursions given in Lemmas A.4, A.5, A.6.

To run the algorithm efficiently, we can use memoization in order to treat it as a dynamic program. Because we only recurse on cases where $|r_{x}-r_{y}|\leq 2K+1$, the total time in the spent is $O(nK)$. In particular, for subproblems of the form $\operatorname{SP}(x,y,r_{x},r_{y},o_{y})$, there are $O(n)$ options for $r_{y}$ and $o_{y}$, for each of which there are $O(K)$ options for $r_{x}$; similarly, there are $O(nK)$ options for subproblems of the form $\operatorname{SP}(y,x,r_{y},r_{x},o_{x})$. ∎

Corollary A.8**.**

Let $x$ and $y$ be strings of length $n$. Then one can compute $\operatorname{dtw}(x,y)$ in time $O(n\cdot\operatorname{dtw}(x,y))$.

Proof.

For a parameter $K$, the dynamic program from the proof of Theorem A.7 correctly computes $\operatorname{dtw}(x,y)$ when $\operatorname{dtw}(x,y)\leq K$, and otherwise returns a value greater than $K$.

By guessing $K$ to be successive powers of two, one can find the first power of two $K$ such that $\operatorname{dtw}(x,y)\leq K$ in time $O(n\cdot 1+n\cdot 2+n\cdot 4+\cdots+n\cdot K)=O(n\cdot K)$, allowing one to then compute $\operatorname{dtw}(x,y)$ in time $O(n\cdot K)=O(n\cdot\operatorname{dtw}(x,y))$. ∎

Appendix B Approximating DTW Over Well-Separated Tree Metrics

In this section, we present an $\tilde{O}(n^{2-\epsilon})$-time $O(n^{\epsilon})$-approximation algorithm for DTW over a well-separated tree metric with logarithmic depth. We begin by presenting a brief background on well-separated tree metrics.

Definition B.1**.**

Consider a tree $T$ whose vertices form an alphabet $\Sigma$, and whose edges have positive weights. $T$ is said to be a well-separated tree metric if every root-to-leaf path consists of edges ordered by nonincreasing weight. The distance between two nodes $u,v\in\Sigma$ is defined as the maximum weight of any edge in the shortest path from $u$ to $v$.

Well-separated tree metrics are universal in the sense that any metric $\Sigma$ can be efficiently embedded (in time $O(|\Sigma|^{2})$) into a well-separated tree metric $T$ with expected distortion $O(\log|\Sigma|)$ [23].666In particular, [23] shows how to embed $\Sigma$ into what is known as a 2-hierarchically well-separated tree metric. These metrics differ slightly from our definition of a well-separated tree metric in that the distance between two nodes is given by the sum of the edge weights in the shortest path, rather than the maximum. It turns out that in the case of $2$-hierarchically well-separated tree metrics, these quantities will differ from one another by at most a factor of two, however. That is, if $d_{\Sigma}(u,v)$ denotes the distance between two elements of $\Sigma$, and $d_{T}(u,v)$ denotes the distance in $T$ between the nodes corresponding with $u$ and $v$, then

[TABLE]

and

[TABLE]

Moreover, using the algorithm from Theorem 8 of [8] to modify the well-separated tree metric $T$, we may assume without loss of generality that $T$ has maximum depth $O(\log|\Sigma|)$, allowing for fast evaluation of distances.

For strings $x,y\in\Sigma^{n}$, let $\operatorname{dtw}_{T}(x,y)$ denote the dynamic time warping distance after embedding $\Sigma$ into $T$. Then by (2), every correspondence between the embedded strings must cost at least as much as the same correspondence between the original strings, meaning that

[TABLE]

Moreover, by (3), if we take the optimal correspondence between $x$ and $y$, then the same correspondence between the embedded strings will have expected cost at most $O(\log n)$ times as large, meaning that

[TABLE]

Combined, (4) and (5) tell us that any approximation algorithm for DTW over well-separated tree metrics will immediately yield an approximation algorithm over an arbitrary polynomial-size metric $\Sigma$, with two caveats: the new algorithm will have its multiplicative error increased by $O(\log n)$; and $O(\log n)$ instances of $\Sigma$ embedded into a well-separated tree metric must be precomputed for use by the algorithm (requiring, in general, $O(|\Sigma|^{2}\log n)$ preprocessing time). In particular, given $O(\log n)$ tree embeddings of $\Sigma$, $T_{1},\ldots,T_{O(\log n)}$, (4) and (5) tell us that with high probability $\min_{i}\left(\operatorname{dtw}_{T_{i}}(x,y)\right)$ will be within a logarithmic factor of $\operatorname{dtw}(x,y)$.

The remainder of the section will be devoted to designing an approximation algorithm for DTW over a well-separated tree metric. We will prove the following theorem:

Theorem B.2**.**

Consider $0<\epsilon<1$. Suppose that $\Sigma$ is a well-separated tree metric of polynomial size and at most logarithmic depth. Moreover, suppose that the aspect ratio of $\Sigma$ is at most exponential in $n$ (i.e., the ratio between the largest distance and the smallest non-zero distance). Then in time $\tilde{O}(n^{2-\epsilon})$ we can obtain an $O(n^{\epsilon})$-approximation for $\operatorname{dtw}(x,y)$ for any $x,y\in\Sigma^{n}$.

An important consequence of the theorem occurs for DTW over the reals.

Corollary B.3**.**

Consider $0<\epsilon<1$. Suppose that $\Sigma$ is an $O(n)$-point subset of the reals with polynomial aspect ratio. Then in time $\tilde{O}(n^{2-\epsilon})$ we can obtain an $O(n^{\epsilon})$-approximation for $\operatorname{dtw}(x,y)$ with high probability for any $x,y\in\Sigma^{n}$.

Proof.

Without loss of generality, $\Sigma\subset[0,n^{c}]$ for some constant $c$, and no two points in $\Sigma$ have distance less than one from each other.

The key observation is that there is an $O(n\log n)$-time embedding with $O(\log n)$ expected distortion from $\Sigma$ to a well-separated tree metric of size $O(n)$ with logarithmic depth. Such an embedding can be constructed by a random partitioning process, as follows777This construction appears to be somewhat of a folklore result. It is a natural consequence of ideas from [10].. If $m_{1}$ and $m_{2}$ are the smallest and largest elements of $\Sigma$, respectively, and $r=m_{2}-m_{1}$ is the size of the range in which $\Sigma$ lies, then first select a pivot $p$ at random from the range $[m_{1}+r/4,m_{2}-r/4]$. Next recursively constructing a subtree $L$ for the subset of $\Sigma$ less than $p$, and then recursively constructing a subtree $R$ for the subset of $\Sigma$ greater than $p$. Finally, return the tree $T$ in which $p$ is the root, $L$ is the left subtree, $R$ is the right subtree, and the edges from $p$ to its children have weight $r$. One can easily verify that $T$ is a well-separated tree metric; that distances in $T$ dominate distances in $\Sigma$; that the depth of $T$ is $O(\log n)$; and that $T$ can be recursively constructed in time $O(n\log n)$. It is slightly more subtle to show that for $a,b\in\Sigma$, the expected distance $d_{T}(a,b)$ between $a$ and $b$ in $T$ is at most $O(\log n)\cdot|a-b|$. Note that $d_{T}(a,b)$ is the length $r$ of the range for the recursive subproblem in which $a$ and $b$ are split from one-another. For each recursive subproblem containing $a$, the probability that $a$ and $b$ will be split by the pivot in that subproblem is at most $O(|a-b|/r)$, where $r$ is the range size of the subproblem. This means that the expected contribution to $d_{T}(a,b)$ by that subproblem is $O(|a-b|/r)\cdot r\leq O(|a-b|)$. Since there are at most $O(\log n)$ recursive subproblems containing $a$, the expected value of $d_{T}(a,b)$ is at most $O(\log n)\cdot|a-b|$. This completes the analysis of the embedding.

Combining the above embedding with Theorem B.2 (and taking the minimum output of the algorithm over $O(\log n)$ independent iterations in order to obtain a high probability result) yields the desired result. ∎

In proving Theorem B.2, our approximation algorithm will take advantage of what we refer to as the $r$-simplification of a string over a well-separated tree metric.

Definition B.4**.**

Let $T$ be a well-separated tree metric whose nodes form an alphabet $\Sigma$. For a string $x\in\Sigma^{n}$, and for any $r\geq 1$, the $r$-simplification $s_{r}(x)$ is constructed by replacing each letter $l\in x$ with its highest ancestor $l^{\prime}$ in $T$ that can be reached from $l$ using only edges of weight at most $r/4$.

Our approximation algorithm will apply the low-distance regime algorithm from the previous section to $s_{r}(x)$ and $s_{r}(y)$ for various $r$ in order to extract information about $\operatorname{dtw}(x,y)$. Notice that using our low-distance regime algorithm for DTW, we get the following useful lemma for free:

Lemma B.5**.**

Consider $0<\epsilon<1$. Suppose that for all pairs $l_{1},l_{2}$ of distinct letters in $\Sigma$, $d(l_{1},l_{2})\geq\gamma$. Then for $x,y\in\Sigma^{n}$ there is an $O(n^{2-\epsilon})$ time algorithm which either computes $\operatorname{dtw}(x,y)$ exactly, or concludes that $\operatorname{dtw}(x,y)>\gamma n^{1-\epsilon}$.

Proof.

This follows immediately from Theorem A.7. ∎

The next lemma states three important properties of $r$-simplifications. We remark that the same lemma appears in our concurrent work on the communication complexity of DTW, in which we use the lemma in designing an efficient one-way communication protocol [13].

Lemma B.6**.**

Let $T$ be a well-separated tree metric with distance function $d$ and whose nodes form the alphabet $\Sigma$. Consider strings $x$ and $y$ in $\Sigma^{n}$.

Then the following three properties of $s_{r}(x)$ and $s_{r}(y)$ hold:

• •

For every letter $l_{1}\in s_{r}(x)$ and every letter $l_{2}\in s_{r}(y)$, if $l_{1}\neq l_{2}$, then $d(l_{1},l_{2})>r/4$.

• •

For all $\alpha$, if $\operatorname{dtw}(x,y)\leq nr/\alpha$ then $\operatorname{dtw}(s_{r}(x),s_{r}(y))\leq nr/\alpha$.

• •

If $\operatorname{dtw}(x,y)>nr$, then $\operatorname{dtw}(s_{r}(x),s_{r}(y))>nr/2$.

Proof.

The first part of the lemma follows directly from the definitions of $s_{r}(x)$ and $s_{r}(y)$.

Let $C$ be the optimal correspondence between $x$ and $y$, and let $C^{\prime}$ be the same correspondence between $s_{r}(x)$ and $s_{r}(y)$. Suppose $C$ matches some letter $l_{1}\in x$ to a letter $l_{2}$ in $y$. Let $l_{1}^{\prime}$ and $l_{2}^{\prime}$ be the corresponding letters in $s_{r}(x)$ and $s_{r}(y)$. Notice that if $d(l_{1},l_{2})\leq r/4$, then

[TABLE]

and that if $d(l_{1},l_{2})>r/4$, then

[TABLE]

By (6) and (7), the correspondence $C^{\prime}$ costs no more than $C$, meaning that $\operatorname{dtw}(s_{r}(x),s_{r}(y))\leq\operatorname{dtw}(x,y)$. Therefore, if $\operatorname{dtw}(x,y)\leq nr/\alpha$ then $\operatorname{dtw}(s_{r}(x),s_{r}(y))\leq nr/\alpha$, completing the second part of the lemma.

Now suppose that $\operatorname{dtw}(x,y)>nr$. Consider an optimal correspondence $D$ between $s_{r}(x)$ and $s_{r}(y)$, and assume without loss of generality that $D$ is of length no more than $2n$. Equations (6) and (7) tell us that the cost of $D$ can be no more than $2n\cdot r/4$ smaller than the cost of the same correspondence between $x$ and $y$. Since $\operatorname{dtw}(x,y)>nr$, it follows that $\operatorname{dtw}(s_{r}(x),s_{r}(y))>nr-2n\cdot r/4=nr/2$, completing the third part of the lemma. ∎

We can now prove Theorem B.2.

Proof of Theorem B.2.

Without loss of generality, the minimum non-zero distance in $\Sigma$ is 1 and the largest distance is some value $m$, which is at most exponential in $n$.

We begin by defining the $(r,n^{\epsilon})$-DTW gap problem for $r\geq 1$, in which for two strings $x$ and $y$ a return value of 0 indicates that $\operatorname{dtw}(x,y)<nr$ and a return value of 1 indicates that $\operatorname{dtw}(x,y)\geq n^{1-\epsilon}r$. By Lemma B.6, in order to solve the $(r,n^{\epsilon})$-DTW gap problem for $x$ and $y$, it suffices to determine whether $\operatorname{dtw}(s_{r}(x),s_{r}(y))\leq n^{1-\epsilon}r$. Moreover, because the minimum distance between distinct letters in $s_{r}(x)$ and $s_{r}(y)$ is at least $r/4$, this can be done in time $O(n^{2-\epsilon}\log n)$ using Lemma B.5.888The logarithmic factor comes from the fact that evaluating distances between points may take logarithmic time in our well-separated tree metric.

In order to obtain an $n^{\epsilon}$-approximation for $\operatorname{dtw}(x,y)$, we begin by using Lemma B.5 to either determine $\operatorname{dtw}(x,y)$ or to determine that $\operatorname{dtw}(x,y)\geq n^{1-\epsilon}$. For the rest of the proof, suppose we are in the latter case, meaning that we know $\operatorname{dtw}(x,y)\geq n^{1-\epsilon}$.

We will now consider the $(2^{i},n^{\epsilon}/2)$-DTW gap problem for $i\in\{0,1,2,\ldots,\lceil\log m\rceil\}$. If the $(2^{0},n^{\epsilon}/2)$-DTW gap problem returned 0, then we would know that $\operatorname{dtw}(x,y)\leq n$, and thus we could return $n^{1-\epsilon}$ as an $n^{\epsilon}$-approximation for $\operatorname{dtw}(x,y)$. Therefore, we need only consider the case where the $(2^{0},n^{\epsilon}/2)$-DTW gap returns $1$. Moreover we may assume without computing it that $(2^{\lceil\log m\rceil},n^{\epsilon}/2)$-DTW gap returns 0 since trivially $\operatorname{dtw}(x,y)$ cannot exceed $nm$. Because $(2^{i},n^{\epsilon}/2)$-DTW gap returns 1 for $i=0$ and returns [math] for $i=\lceil\log m\rceil$, there must be some $i$ such that $(2^{i-1},n^{\epsilon}/2)$-DTW gap returns $1$ and $(2^{i},n^{\epsilon}/2)$-DTW gap returns 0. Moreover, we can find such an $i$ by performing a binary search on $i$ in the range $R=\{0,\ldots,\lceil\log m\rceil\}$. We begin by computing $(2^{i},n^{\epsilon}/2)$-DTW gap for $i$ in the middle of the range $R$. If the result is a one, then we can recurse on the second half of the range; otherwise we recurse on the first half of the range. Continuing like this, we can find in time $\tilde{O}(n^{2-\epsilon}\log\log m)=\tilde{O}(n^{2-\epsilon})$ some value $i$ for which $(2^{i-1},n^{\epsilon}/2)$-DTW gap returns $1$ and $(2^{i},n^{\epsilon}/2)$-DTW gap returns 0. Given such an $i$, we know that $\operatorname{dtw}(x,y)\geq\frac{2^{i-1}n}{n^{\epsilon}/2}=2^{i}n^{1-\epsilon}$ and that $\operatorname{dtw}(x,y)\leq 2^{i}n$. Thus we can return $2^{i}n^{1-\epsilon}$ as an $n^{\epsilon}$ approximation of $\operatorname{dtw}(x,y)$. ∎

Appendix C Reducing Edit Distance to DTW and LCS

In this section we present a simple reduction from edit distance over an arbitrary metric to DTW over the same metric.At the end of the section, we prove as a corollary a conditional lower bound for DTW over three-letter Hamming space, prohibiting any algorithm from running in strongly subquadratic time.

Surprisingly, the exact same reduction, although with a different analysis, can be used to reduce the computation of edit distance (over generalized Hamming space) to the computation of longest-common-subsequence length (LCS). Since computing LCS is equivalent to computing edit distance without substitutions, this reduction can be interpreted as proving that edit distance without substitutions can be used to efficiently simulate edit distance with substitutions, also known as simple edit distance.

Recall that for a metric $\Sigma\cup\{\emptyset\}$, we define the edit distance between two strings $x,y\in\Sigma^{n}$ such that the cost of a substitution from a letter $l_{1}$ to $l_{2}$ is $d(l_{1},l_{2})$, and the cost of a deletion or insertion of a letter $l$ is $d(l,\emptyset)$. Additionally, define the simple edit distance $\operatorname{ed}_{S}(x,y)$ to be the edit distance using only insertions and deletions.

For a string $x\in\Sigma^{n}$, define the padded string $p(x)$ of length $2n+1$ to be the string $\emptyset x_{1}\emptyset x_{2}\emptyset x_{3}\cdots x_{n}\emptyset$. In particular, for $i\leq 2n+1$, $p(x)_{i}=\emptyset$ when $i$ is odd, and $p(x)_{i}=x_{i/2}$ when $i$ is even. The following theorem proves that $\operatorname{dtw}(p(x),p(y))=\operatorname{ed}(x,y)$.

Theorem C.1**.**

Let $\Sigma\cup\{\emptyset\}$ be a metric. Then for any $x,y\in\Sigma^{n}$, $\operatorname{dtw}(p(x),p(y))=\operatorname{ed}(x,y).$

Proof.

We begin by showing that there is an optimal correspondence $C$ between $p(x)$ and $p(y)$ in which the only extended runs are those consisting of the letter $\emptyset$. Consider an arbitrary optimal correspondence $D$ between $p(x)$ and $p(y)$, and assume without loss of generality that no two runs which are extended in the correspondence are matched by the correspondence to overlap. Suppose a run $r$ consisting of a letter $a\neq\emptyset$ in $x$ is extended in $D$. If the first letter in the run $r$ is matched with the letter $\emptyset$ in $y$, then the correspondence $D$ could be improved by replacing the first letter in $r$ with an $\emptyset$ character, which can be achieved by un-extending the run $r$ by one, and instead further extending the preceding run of $\emptyset$’s by one. Consequently, the first letter in the run $r$ must match to some letter $l_{1}\neq\emptyset$ in $y$, and similarly the final letter in the run $r$ must match to some letter $l_{2}\neq\emptyset$ in $y$, meaning the extended run must be at least three letters long. Now consider the first two letters $l_{1},\emptyset$ to which the run $r$ is matched by $D$. By the triangle inequality, $d(l_{1},a)+d(a,\emptyset)\geq d(l_{1},\emptyset)$ (recall that $a$ is the letter which populates the run $r$). It follows that if we un-extend the run $r$ by two letters, and instead further extend the run of $\emptyset$’s preceding $r$, then we arrive at a correspondence $D^{\prime}$ no more expensive than $D$. Moreover, the sum of the lengths of runs of non-$\emptyset$ elements in $D^{\prime}$ has been reduced by two from the same sum for $D$. Repeating this process as many times as necessary, we can arrive at a correspondence $C$ in which no runs containing non-$\emptyset$ letters are extended, as desired. Because $D$ was an optimal correspondence, and $C$ costs no more than $D$, $C$ must also be optimal.

Using the correspondence $C$, we can now prove that $\operatorname{ed}(x,y)\leq\operatorname{dtw}(p(x),p(y))$. In particular, we can construct a sequence of edits between $x$ and $y$ at most as expensive as the correspondence $C$. To do this, we first delete from $x$ any letter $l$ in $x$ which is matched by $C$ to an $\emptyset$ character, and we do the same for $y$. Call the resulting strings $x^{\prime}$ and $y^{\prime}$. Notice that for each letter $x_{i}^{\prime}$ in $x^{\prime}$, $C$ must match $x_{i}^{\prime}$ to the corresponding letter $y_{i}^{\prime}$ in $y^{\prime}$. Consequently, if we perform substitutions in order to transform each $x_{i}^{\prime}$ into $y_{i}^{\prime}$, then the full sequence of edits between $x$ and $y$ will have cost no more than the cost of $C$.

Finally, to show that $\operatorname{dtw}(p(x),p(y))\leq\operatorname{ed}(x,y)$, we present a correspondence $C$ between $p(x)$ and $p(y)$ of cost $\operatorname{ed}(x,y)$. Consider an optimal sequence of edits $E$ from $x$ to $y$. One can think of $E$ as performing a series of insertions in $x$, a series of insertions in $y$, and then a series of substitutions to transform the resulting strings into one another. Now suppose that for each insertion into $x$, we instead insert an $\emptyset$ character, and similarly for each insertion into $y$. Notice that the resulting strings $x^{\prime}$ and $y^{\prime}$ will satisfy $\sum_{i}d(x^{\prime}_{i},y^{\prime}_{i})=\text{cost}(E).$ Next, insert an additional $\emptyset$ character in every other position in $x^{\prime}$ and in every other position in $y^{\prime}$ to obtain strings $x^{\prime\prime}$ and $y^{\prime\prime}$. These new strings still satisfy $\sum_{i}d(x^{\prime\prime}_{i},y^{\prime\prime}_{i})=\text{cost}(E),$ but have the additional property that they are expansions of $p(x)$ and $p(y)$. Hence $\operatorname{dtw}(p(x),p(y))\leq\operatorname{ed}(x,y)$, completing the proof.

∎

Theorem C.2 proves an analogous reduction from edit distance to LCS. As a convention, we use complex edits to refer to insertions, deletions, and substitutions, and simple edits to refer to edits consisting only of insertions and deletions.

Theorem C.2**.**

Let $\Sigma$ be a generalized Hamming metric. Then for any $x,y\in\Sigma^{n}$, $\operatorname{ed}_{S}(p(x),p(y))=2\operatorname{ed}(x,y)$.

Proof.

Given a sequence of complex edits from $x$ to $y$, those edits can be emulated at twice the cost using simple edits from $p(x)$ to $p(y)$. In particular, the insertion of a letter $l$ becomes the insertion of the letters $l,\emptyset$, the deletion of a letter $l$ becomes the deletion of the letters $l,\emptyset$, and the substitution of the letter $l$ to the letter $k$ becomes the deletion and insertion needed to transform $l,\emptyset$ to $k,\emptyset$. It follows that $\operatorname{ed}_{S}(p(x),p(y))\leq 2\operatorname{ed}(x,y)$.

It remains to prove that $2\operatorname{ed}(x,y)\leq\operatorname{ed}_{S}(p(x),p(y))$. For the sake of completeness, we will now prove it formally. Consider an optimal alignment $A$ between $p(x)$ and $p(y)$ (allowing only simple edits). That is, $A$ is a non-crossing bipartite graph between the letters of $p(x)$ and $p(y)$ with edges only between letters of the same value. The cost of $A$ is the number of singleton nodes in $A$, which is equal to $\operatorname{ed}_{S}(p(x),p(y))$. Without loss of generality, for each edge $e_{1}$ in $A$ connecting two non-null nodes $u$ and $v$, there is another edge $e_{2}$ connecting the [math]-nodes directly following $u$ and $v$. Indeed, if there is not, then since $A$ is non-crossing, at most one of the two [math]-nodes can be part of an edge in $A$. Deleting such an edge and replacing it with the desired edge does not change the cost of $A$.

Call a letter $x_{i}$ in $x$ totally unmatched by $A$ if $p(x)_{2i}$ and $p(x)_{2i+1}$ are both unmatched in $A$. Call a letter $x_{i}$ partially matched to $y_{j}$ by $A$ if $p(x)_{2i}$ is unmatched in $A$ but $p(x)_{2i+1}$ is matched to some $p(y)_{2j+1}$. Call a letter $x_{i}$ totally matched to $y_{j}$ by $A$ if both $p(x)_{2i}$ and $p(x)_{2i+1}$ are matched by $A$ to some $p(y)_{2j}$ and $p(y)_{2j+1}$ respectively. If we define the analogous terms for letters of $y$, then notice that every letter of $x$ and $y$ is either totally unmatched, partially matched to another partially matched letter, or totally matched to another totally matched letter.

We now construct an alignment between $x$ and $y$ (allowing for complex edits). That is, we construct a non-crossing bipartite graph $B$ from the letters of $x$ to the letters of $y$, such that the number of unmatched nodes in $B$ plus the number of edges between different-valued characters in $B$ is at most the number of unmatched nodes in $A$. For each letter $x_{i}$ or $y_{i}$ that is totally unmatched by $A$, leave it as a singleton node in $B$. For each letter $x_{i}$ which is partially matched to some $y_{j}$ by $A$, match $x_{i}$ to $y_{j}$ in $B$. For each letter $x_{i}$ which is totally matched to some letter $y_{j}$, match $x_{i}$ to $y_{j}$ in $B$. The resulting $B$ has cost equal to the number of totally unmatched letters in $x$ and $y$, plus the number of partially matched letters in $x$ (since they are paired with the partially matched letters in $y$ through substitutions). This is half the cost of $A$, since each totally unmatched letter in $x$ or $y$ corresponds with two adjacent singleton nodes in $A$, and each partially matched pair of letters between $x$ and $y$ corresponds with two singleton nodes in $A$. It follows that $2\operatorname{ed}(x,y)\leq\operatorname{ed}_{S}(p(x),p(y))$.

∎

Whereas Theorem C.2 embeds edit distance into simple edit distance with no distortion, the next theorem shows that no nontrivial embedding in the other direction exists.

Formally, we say that an embedding from a metric space $(M_{1},d_{1})$ to $(M_{2},d_{2})$ is an injective map $\phi$. The distortion of an embedding is defined as

[TABLE]

unless the numerator is unbounded or the denominator is zero, in which case the distortion is $\infty$.

A trivial embedding from edit distance to simple edit distance would be the identity map, which achieves distortion $2$. Theorem C.3 establishes that no other embedding can do better.

Theorem C.3**.**

Consider edit distance over generalized Hamming space. Any embedding from edit distance to simple edit distance must have distortion at least $2$.

Proof.

For an alphabet $\Sigma$ containing both [math] and $1$, suppose for contradiction that there is an embedding $\phi:\Sigma^{*}\rightarrow\Sigma^{*}$ such that $c_{1}\operatorname{ed}_{S}(x,y)\leq\operatorname{ed}(\phi(x),\phi(y))\leq c_{2}\operatorname{ed}_{S}(x,y)$ for constants $c_{1}\leq c_{2}$ within a factor of less than two of each other.

For all $n$, $\operatorname{ed}(\phi(0^{n}),\phi(1^{n}))\geq c_{1}\cdot 2n$. Since the edit distance between two strings is at most the maximum of their lengths, it follows without loss of generality that $|\phi(0^{n})|\geq c_{1}\cdot 2n$ (since the case where $|\phi(1^{n})|\geq c_{1}\cdot 2n$ is symmetric).

Now define $x$ to be the empty string, and $y=0^{n}$. By assumption, $\operatorname{ed}(\phi(x),\phi(y))\leq c_{2}n$, and thus $\phi(x)$ and $\phi(y)$ are within $c_{2}n$ of each other in length. Since $\phi(y)$ is length at least $2\cdot c_{1}n$, it follows that $\phi(x)$ must be length at least $(2c_{1}-c_{2})n$. Recall that $c_{1}$ and $c_{2}$ are within less than a factor of two of each other, meaning that $(2c_{1}-c_{2})$ is a positive constant. Therefore, we have shown that for all $n$, $|\phi(x)|\geq\Omega(n)$, a contradiction.

∎

We conclude the section by obtaining a novel conditional lower bound for computing DTW over a three-letter alphabet (in which character distances are zero or one). This concludes a direction of work initiated by Abboud, Backurs, and Williams [3], who proved the same result over five-letter alphabet.

Corollary C.4**.**

Let $\Sigma=\{a,b,c\}$ with distance function $d(a,b)=d(a,c)=d(b,c)=1$. If we assume the Strong Exponential Time Hypothesis, then for all $\epsilon>1$, no algorithm can compute $\operatorname{dtw}(x,y)$ for $x,y\in\Sigma^{n}$ in time less than $O(n^{2-\epsilon})$.

Proof.

By Theorem 1.2 of [14], edit distance between binary strings cannot be computed in strongly subquadratic time, assuming the Strong Exponential Time Hypothesis. Applying Theorem C.1, we get the same result for DTW over $\Sigma$. ∎

Appendix D Approximating Edit Distance Over an Arbitrary Metric

In this section we present an approximation algorithm for edit distance over an arbitrary metric space. Our algorithm achieves approximation ratio at most $n^{\epsilon}$ (with high probability) and runtime $\tilde{O}(n^{2-\epsilon})$. Note that when the metric is a well-separated tree metric, such an algorithm can be obtained by combining the approximation algorithm for DTW from Section 4 with the reduction in Section 5. Indeed the algorithm in this section is structurally quite similar to the one in Section 4, but uses a probability argument exploiting properties of edit distance in order to hold over an arbitrary metric.

Theorem D.1**.**

Let $(\Sigma\cup\{\emptyset\},d)$ be an arbitrary metric space such that $|l|\geq 1$ for all $l\in\Sigma$. For all $0<\epsilon<1$, and for strings $x,y\in\Sigma^{n}$, there is an algorithm which computes an $O(n^{\epsilon})$-approximation for $\operatorname{ed}(x,y)$ (with high probability) in time $\tilde{O}(n^{2-\epsilon})$.

Before continuing, we remind the reader of the standard dynamic-programming algorithm for computing $\operatorname{ed}(x,y)$ [43, 37, 42]. For $i,j\in\{0,\ldots,n\}$, the subproblem $\mathcal{A}(i,j)$ is defined to be the edit distance

[TABLE]

Notice that for $i,j>0$, the return-value for $\mathcal{A}(i,j)$ is completely determined by $\mathcal{A}(i-1,j)$, $\mathcal{A}(i,j-1)$, and $\mathcal{A}(i-1,j-1)$, as well as knowledge of $x_{i}$ and $y_{j}$. Using this, one can formulate a recursion which results in an $O(n^{2})$-time dynamic-program for computing $\operatorname{ed}(x,y)$.

Now consider the same dynamic program, except with $\mathcal{A}(i,j)$ artificially set to $\infty$ whenever $|i-j|>K$, for some parameter $K$. This new dynamic program runs in time $O(n\cdot K)$ and returns the minimum cost of any sequence of edits that transforms $x$ to $y$ without ever matching any $x_{i}$ to some $y_{j}$ for which $|i-j|>K$. Importantly, this means that if there is an optimal sequence of edits involving no more than $K$ insertions and deletions, then the new dynamic program will find the true value of $\operatorname{ed}(x,y)$; otherwise, the dynamic program may return an overestimate for $\operatorname{ed}(x,y)$. This implies in the following observation:

Observation D.2*.*

Consider $x,y\in\Sigma^{n}$, and let $R$ be the smallest magnitude of the letters in $x$ and $y$. There is an $O(n^{2-\epsilon})$-time algorithm which returns a value at least as large as $\operatorname{ed}(x,y)$; and which returns exactly $\operatorname{ed}(x,y)$ when $\operatorname{ed}(x,y)\leq R\cdot n^{1-\epsilon}$.

In order to prove Theorem D.1, we present a new definition of the $r$-simplification of a string. The difference between this definition and the one in the preceding section allows the new definition to be useful when studying edit distance rather than dynamic time warping.

Definition D.3**.**

For a string $x\in\Sigma^{n}$ and for $r\geq 1$, we construct the $r$-simplification $s_{r}(x)$ by removing any letter $l$ satisfying $|l|\leq r$.

The proof of Theorem D.1 has a similar structure to that of Theorem B.2, but interestingly avoids the use of well-separated tree metrics.

A key insight in the proof of Theorem D.1 is to use randomization in the selection of $r$ in order to ensure that $s_{r}(x)$ satisfies desirable properties in expectation. The key proposition follows:

Proposition D.4**.**

Consider strings $x$ and $y$ in $\Sigma^{n}$. Consider $0<\epsilon<1$ and $R\geq 1$. Select $r$ to be a random real between $R$ and $2R$. Then the following three properties hold:

• •

Every letter $l$ in $s_{r}(x)$ or $s_{r}(y)$ satisies $|l|\geq R$.

• •

If $\operatorname{ed}(x,y)\leq\frac{nR}{15n^{\epsilon}}$ then $\mathbb{E}[\operatorname{ed}(s_{r}(x),s_{r}(y))]\leq\frac{nR}{3n^{\epsilon}}$.

• •

If $\operatorname{ed}(x,y)>5nR$, then $\operatorname{ed}(s_{r}(x),s_{r}(y))>nR$.

Before proving Proposition D.4, we first use it to prove Theorem D.1.

Proof of Theorem D.1..

We begin by defining the $(R,n^{\epsilon})$-edit-distance gap problem for $r\geq 1$, in which for two strings $x$ and $y$ a return value of 0 indicates that $\operatorname{ed}(x,y)<5nR$ and a return value of 1 indicates that $\operatorname{ed}(x,y)\geq n^{1-\epsilon}R/15$.

One can solve the $(R,n^{1-\epsilon})$-edit-distance gap problem with high probability in time $\tilde{O}(n^{2-\epsilon})$ as follows. For a sufficiently large number of samples $t=O(\log n)$, select $r_{1},\ldots,r_{t}$ each at random from $[R,2R]$. Then apply Observation D.2 to each of the $r_{i}$’s in order to obtain an estimate $e_{i}$ for $\operatorname{ed}(s_{r_{i}}(x),s_{r_{i}}(y))$ in time $O(n^{2-\epsilon})$. Because each $e_{i}$ is either correct or an overestimate, if any of the $e_{i}$’s are less than $nR$, then we can conclude that $\operatorname{ed}(s_{r_{i}}(x),s_{r_{i}}(y))<nR$, meaning by Proposition D.4 that $\operatorname{ed}(x,y)\leq 5nR$. On the other hand, if none of the $e_{i}$’s are less than $nR$, then our algorithm for the gap problem concludes that $\operatorname{ed}(x,y)\geq n^{1-\epsilon}R/15$. In order to show that our algorithm for the gap problem is correct with high probability, it suffices to show that if $\operatorname{ed}(x,y)<n^{1-\epsilon}R/15$ then with high probability, at least one of the $e_{i}$’s will be less than $nR$. By Proposition D.4, if $\operatorname{ed}(x,y)<n^{1-\epsilon}R/15$, then $\mathbb{E}[\operatorname{ed}(s_{r_{i}}(x),s_{r_{i}}(y))]\leq\frac{nR}{3n^{\epsilon}}$. Applying Markov’s inequality to each $\operatorname{ed}(s_{r_{i}}(x),s_{r_{i}}(y))$, with high probability there is some $i$ for which

[TABLE]

which by Observation D.2 means that

[TABLE]

as desired.

Now that we have an algorithm for the $(R,n^{1-\epsilon})$-edit-distance gap problem, the proof of Theorem D.1 follows just as did the proof of Theorem B.2 using the solution to the $(r,n^{\epsilon})$-DTW gap problem. Recall, however, that the proof of Theorem D.1 required the metric space to have at most exponential aspect ratio. This was so that a binary search could efficiently find some $i$ for which $(2^{i-1},n^{\epsilon}/2)$-DTW gap returns $1$ and $(2^{i},n^{\epsilon}/2)$-DTW gap returns 0. Such a requirement is not necessary here, because we can restrict ourselves to considering only the $O(n)$ $i$’s for which there is at least one letter $l$ in $x$ or $y$ for which $2^{i-1}\leq|l|\leq 2^{i+1}$; indeed, for all other values of $i$, our algorithm for the $(R,n^{1-\epsilon})$-edit-distance gap problem will be guaranteed to return the same value for $R=2^{i-1}$ as for $R=2^{i}$. By restricting ourselves to these values of $i$, the binary search to find some $i$ for which $(2^{i-1},n^{\epsilon}/2)$-DTW gap returns $1$ and $(2^{i},n^{\epsilon}/2)$-DTW gap returns 0 can be performed efficiently regardless of the aspect ratio of the metric space. ∎

The rest of the section will be devoted to proving Proposition D.4. Because $r\geq R$, The first part of the proposition follows immediately from the definition of $s_{r}(x)$ and $s_{r}(y)$.

The second part of the proposition comes from the following lemma.

Lemma D.5**.**

Consider strings $x$ and $y$ in $\Sigma^{n}$. Consider $R\geq 1$ and select $r$ to be a random real between $R$ and $2R$. Then

[TABLE]

Proof.

Consider an optimal sequence $S$ of edits from $x$ to $y$. We will consider the cost of simulating this sequence of edits to transform $s_{r}(x)$ to $s_{r}(y)$. Insertions and deletions are easily simulated by either performing the same operation to $s_{r}(x)$ or performing no operation at all (if the operation involves a letter of magnitude less than or equal to $r$). Substitutions are slightly more complicated as they may originally be between letters $l_{1}\in x$ and $l_{2}\in y$ of different magnitudes. By symmetry, we may assume without loss of generality that $|l_{1}|<|l_{2}|$. We will show that the expected cost of simulating the substitution of $l_{1}$ to $l_{2}$ in $s_{r}(x)$ is at most $5d(l_{1},l_{2})$. Because insertions and deletions can be simulated with no overhead, it follows that $\mathbb{E}[\operatorname{ed}(s_{r}(x),s_{r}(y))]\leq 5\operatorname{ed}(x,y)$.

If $|l_{1}|\leq r<|l_{2}|$ then $l_{1}$ does not appear in $s_{r}(x)$ but $l_{2}$ remains in $s_{r}(y)$. Thus what was previously a substitution of $l_{1}$ with $l_{2}$ becomes an insertion of $l_{2}$ at cost $|l_{2}|$. On the other hand, if we do not have $|l_{1}|\leq r<|l_{2}|$, then either both $l_{1}$ and $l_{2}$ are removed from $s_{r}(x)$ and $s_{r}(y)$ respectively, in which the substitution operation no longer needs to be performed, or both $l_{1}$ and $l_{2}$ are still present, in which case the substitution operation can still be performed at cost $d(l_{1},l_{2})$. Therefore, the expected cost of simulating the substitution of $l_{1}$ to $l_{2}$ in $s_{r}(x)$ is at most

[TABLE]

Because $r$ is selected at random from the range $[R,2R]$, the probability that $|l_{1}|\leq r<|l_{2}|$ is at most $\frac{|l_{2}|-|l_{1}|}{R}$. By the triangle inequality, this is at most $\frac{d(l_{1},l_{2})}{R}.$ If we suppose that $|l_{2}|\leq 4R$, then it follows by (8) that the expected cost of simulating the substitution of $l_{1}$ to $l_{2}$ in $s_{r}(x)$ is at most

[TABLE]

If, on the other hand, $|l_{2}|>4R$, then in order for $|l_{1}|\leq r$ to be true, we must have $|l_{1}|\leq 2R$, meaning by the triangle inequality that $d(l_{1},l_{2})\geq|l_{2}|/2$. Thus in this case $|l_{2}|\leq 2d(l_{1},l_{2})$, meaning by (8) that the expected cost of simultating the substitution of $l_{1}$ to $l_{2}$ in $s_{r}(x)$ is at most three times as expensive as the original substitution. ∎

Finally the third part of Proposition D.4 is a consequence of the following lemma, which completes the proof of Proposition D.4.

Lemma D.6**.**

Consider strings $x$ and $y$ in $\Sigma^{n}$. Consider $R\geq 1$ and select $r$ to be a random real between $R$ and $2R$. Then $\operatorname{ed}(x,y)<\operatorname{ed}(s_{r}(x),s_{r}(y))+4Rn$.

Proof.

Beginning with $x$, remove all letters of magnitude at most $r$; this costs at most $2nR$. Then obtain $s_{r}(y)$ through $\operatorname{ed}(s_{r}(x),s_{r}(y))$ edits. Finally, insert all letters of magnitude at most $r$ in $y$; this costs at most $2nR$. Combining these three steps, we get from $x$ to $y$ at cost $\operatorname{ed}(s_{r}(x),s_{r}(y))+4nR$. ∎