Constant-factor approximation of near-linear edit distance in near-linear time
Joshua Brakensiek, Aviad Rubinstein
TL;DR
This paper presents a near-linear time algorithm that approximates the edit distance between two strings within a constant factor, especially effective when the edit distance is relatively large.
Contribution
It introduces a near-linear time approximation algorithm for edit distance that works efficiently when the distance is above a certain threshold.
Findings
Approximate edit distance within a constant factor in near-linear time
Effective for strings with large edit distance
Bridges gap between exact computation and efficiency
Abstract
We show that the edit distance between two strings of length can be computed within a factor of in time as long as the edit distance is at least for some .
| Term | Definition | Note |
| Alphabet | ||
| Input length | ||
| Input strings | ||
| Edit distance | ||
| is target running time | ||
| Max level of MAIN | ||
| Current level of MAIN | ||
| Max level of Query. | ||
| Current level of Query. | ||
| is bound on additive error in Lemma 6 | ||
| is bound on additive error in Lemma 7 | ||
| lower bound on | ||
| lower bound on | ||
| Edit distance additive error | ||
| Window width | ||
| Window spacing, | ||
| windows of | ||
| Windows of | ||
| Number of windows, . | ||
| APX factor of MAIN recursion level | ||
| metric ball expansion rate | ||
| upper bound on APX factor of QUERY | ||
| Round to power of | ||
| intervals of and of length | for each length, the intervals are | |
| disjoint and cover . | ||
| upper bound on distance threshold | ||
| distance thresholds | ||
| random threshold for distance | ||
| relative density threshold | ||
| set of interval multipliers | ||
| interval multiplier |
| Term | Definition | Note |
|---|---|---|
| The set of live windows | ||
| which satisfy the decreasing densities (Definition 3) | ||
| current set of “good” windows (see Definition 4) | ||
| for which | ||
| typical window in | Want to show | |
| Window color of | See Definition 7 | |
| Matching color of | See Definition 8 | |
| Set of maximal intervals such that is -dense on | ||
| Unique with ( if none exists) | ||
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
\NewEnviron
problem \BODY
Input:
Output:
Constant-factor approximation of near-linear edit distance in near-linear time††thanks: We thank Clément Canonne, Ray Li, Seri Khoury, Barna Saha, and anonymous reviewers for valuable suggestions for the manuscript.
Joshua Brakensiek Stanford University, supported by the NSF GRFP
Aviad Rubinstein Stanford University
Abstract
We show that the edit distance between two strings of length can be computed within a factor of in time as long as the edit distance is at least for some .
1 Introduction
We study the problem of computing the edit distance between two strings of length each. A classical dynamic programming algorithm solves the problem exactly in quadratic time, and assuming fine-grained complexity such as the Strong Exponential Time Hypothesis (SETH), this is essentially the best running time possible for exact algorithms [BI15, AHWW16].
There is a long sequence of approximation algorithms that run in linear or near-linear time [BJKK04, BES06, OR07, AKO10, AO12], but the state of the art is a super-constant (in particular polylogarithmic) approximation factor. Obtaining constant-factor approximation in truly sub-quadratic time was an outstanding open problem for a long time until the recent breakthroughs of [BEG*+*18] who did it in quantum sub-quadratic time, and [CDG*+*18] who finally achieved constant-factor approximation in (classical, randomized) truly sub-quadratic time.
Here, we build on (and significantly extend) the aforementioned sub-quadratic time approximation algorithms of [BEG*+*18, CDG*+*18] to obtain an approximation algorithm that runs in near-linear time. However, there is a caveat: our algorithm also incurs an additive error of , and hence only gives constant-factor approximation when the distance is relatively large. Interestingly, in most settings small edit distance is actually a significantly easier problem. For example, if the distance is bounded by , it can be computed exactly in time [LMS98].
Theorem 1** (Main result).**
For any constant there exist constants that depend on (but not on ) such that there is a randomized algorithm that runs in time , and given two strings the algorithm returns a transformation of to of cost .
Implication for Longest Common Subsequence
For exact computation, the longest common subsequence (LCS) problem is equivalent to edit distance.111More precisely, LCS is equivalent to edit distance computation without substitutions since . For our purposes the question of whether we allow substitutions in the definition of edit distance is irrelevant since the two definitions are equivalent up to a multiplicative factor of . But their multiplicative approximability is quite different, much in the same way that multiplicative approximation algorithms for Vertex Cover do not imply multiplicative approximations for Independent Set. For binary strings, LCS admits a trivial linear-time -approximation algorithm: use only the more common symbol. Obtaining better-than- approximations is a long standing open problem. Concurrent work by Rubinstein and Song [RS20], gives a fine-grained reduction from a constant-factor approximation of Edit Distance to better-than- approximation for binary LCS. This reduction is compatible with our algorithm since it allows for a sub-linear additive error. Combining the main result in [RS20] with our main theorem, we obtain:
Corollary 2**.**
For any constant , there exists a constant and an algorithm that obtains a -approximation for longest common subsequence with binary strings in time.
Concurrent work by Koucký and Saks
In concurrent and independent work, Koucký and Saks [KS19] obtain a result comparable to our main theorem. Interestingly, while they also build on [CDG*+*18], their techniques are quite different.
High-level technical overview
We now give a high level informal outline of our algorithm, including comparisons to recent works of [BEG*+*18, CDG*+*18].
Step 0: Window-compatible matching
The first step in our algorithm is to partition strings into windows of roughly characters each. By [BEG*+*18], there is a near-optimal matching of the strings that is window-compatible; i.e. all the characters from a window of string are matched to the same window of string . Here “near-optimal” hides a small constant multiplicative factor, but also a (sub-linear) additive factor, which is the main reason that we incur this error term in our main result.
Our goal is to approximate enough of the pairwise distances between windows to reconstruct a near-optimal matching. Once we know all the pairwise distances, we can reconstruct a near-optimal window-compatible matching in time using the classical dynamic programming algorithm.
To approximate the distance between any given pair, we implement a “query” by recursing on our main theorem. This runs in time , so as long as the number of queries is , the total running time is .
Let denote the respective sets of windows in strings . For the rest of the analysis, we consider the graph , where we have an edge between two windows if and only if their edit distance is . Below, we drop the subscripts when clear from context. Notice also that , so our goal is to “approximate” by finding a set (inclusion is with respect to edges) such that is small while making only queries.
Step 1: Dense graphs
If the graph is dense, we can query the edit distance from one window to all other windows. By the triangle inequality, any pair of neighbors of are also close, so the number of edges we discover is quadratic in the degree of . In total, in this approach we expect to pay roughly queries to discover edges. In order to discover all edges in the graph, we can hope to make roughly queries. (Actually doing it requires some care so that we are not repetitively discovering the same edges.) See Figure 1(a) for an illustration.
In previous work, Steps 0 and 1 were the core of [BEG*+*18] (which resorts to a quantum algorithm for sparse graphs).
Step 2: Sparse graphs
The key idea to deal with sparse graphs is the following simple structural observation about near-optimal matchings: we can assume without loss of generality that any pair of -windows that are -close (in terms of their position in ) are matched to -windows that are -close. This is indeed without loss of generality since even if an optimal matching were to match to a pair that is -far, most of the windows between cannot be matched to any -windows and must be deleted. Hence the cost of matching to the wrong windows (or deleting them) is negligible compared to the cost of deleting the spurious windows between . For the rest of the analysis, we fix such a near-optimal matching that satisfies the above condition.
The above structural observation leads to the following “seed-and-expand” algorithmic approach for sparse graphs: first, query the edit distance of some -window to every window; if the graph is sparse, those queries should generate a short list of candidate matches . Now consider the windows in an interval222By interval we refer to a contiguous substring of length varying from one window to the entire string. around : we expect them to be matched to an interval of length around one of the candidates . For those windows in , we reduced the number of queries we need to make to roughly , which is much less than the naive when . (Formalizing this argument requires some care since it is possible that the original is actually deleted in an optimal matching.) See Figure 1(b) for an illustration. Steps 0,1,2 are the core of [CDG*+*18].
Careful optimization of this step, including recursively decreasing the length of the interval , can reduce the total query complexity to approximately . It is not clear how could one obtain better query complexity from this seed-and-expand approach: even the window immediately adjacent to , has candidate neighbors.
Step 3: Cliques
As outlined above, optimizing Steps 0,1,2 can give query approximately . There is a tight example where the graph has cliques of size , hence using either the sparse or dense graph approaches is stuck at queries. When recursively applying the queries algorithm, one can obtain an approximation algorithm for edit distance with run-time .
Our key novel idea for this case is to combine both approaches: we query the edit distance from one window to all other windows using queries. Thus, as in Step 1, we discover one clique of windows. We now mimic the algorithm from Step 2, but using an interval around each one of the windows in the clique (instead of just one interval on the A-side). This insight allows us to make roughly seed-and-expands for the price of one; this is exactly the factor that we need to reduce the complexity from Step 2 to . See Figure 1(c) for an illustration.
Deeper technical overview
Below we highlight in greater detail some of the ideas that go into actually implementing and analyzing the above blueprint.
Graphs that are not disjoint unions of cliques
One obvious obstacle is that in general the graph may actually not partition into disjoint cliques. In more detail, suppose that we query the distance between a window and all other windows, and find -neighbors , and -neighbors . Now, we want to say that since is close (in edit distance) to all , windows at an interval around are likely to be matched to windows at an interval around some . But it is entirely possible that has other neighbors that are not neighbors of the original . If we only look to match the windows in with windows in , we might miss their optimal neighbors.
To force our graphs to “behave like” disjoint unions of cliques, we consider a ball around window of edit distance radius , for a randomly chosen . Now if it is optimal to match to such that , then we have that for every and almost any , either both are in the edit distance ball of radius around , or neither is in the ball. More generally, in multiple parts of the proof, we use the fact that by triangle inequality, the edit-distance ball of radius around is contained in the edit-distance ball of radius around .
We henceforth continue to loosely refer to the ball around as a “clique”; even though it may not be fully connected, it approximates a clique in the sense that every pair is -close in edit distance.
Query algorithm tree
We analyze our query algorithm by considering a tree of recursive calls. At the root, all windows are alive. Each edge of the algorithm tree corresponds (roughly) to the following subroutine: choose a clique (aka edit distance ball around a random live window) and keep the intervals around the clique-windows. We want to show that:
- •
On each edge of the algorithm tree (a.k.a. each run of our subroutine), we decrease the number of live windows by a polynomial () factor. Thus after a constant depth recursion we are left with a small number of live windows on which we can brute force query all the pairs.
- •
In each node, a non-negligible fraction of live windows have their match also live; we call these windows good. It is important that the fraction of good windows is non-negligible among live windows — otherwise the algorithm has no hope finding their matches by considering the edges of nearby bad (not good) windows.
- •
In each node of the algorithm tree, most good windows have probability of surviving (as live and good) to a child of that node. By sampling children for each internal node, we can argue that most good windows are likely to survive to a leaf. Furthermore, notice that the total number of live windows in each layer remains roughly linear.
- •
The query complexity at each node is roughly proportional to the number of live windows. Thus in total the query complexity in each level of the algorithm tree is approximately linear.
Cliques of different sizes
Another obvious gap between the ideal example described in Step 3 and worst case instances is that even if the graph can be partitioned into disjoint cliques, they may have very different sizes. And even if the cliques have the same size, they may be denser in some areas of the string and sparser in others. Above we informally describe taking an interval around each clique window and keeping the windows in this interval alive for the next level.
[TABLE]
We need to carefully balance between (i) reducing the number of live windows; (ii) making sure that good windows continue (with-not-too-small probability) to be alive in the next level; and (iii) making sure that they also continue to be good in the next level (specifically, we want the survival of to be highly correlated with the survival of ). Instead of picking a uniform interval length, we take, for each clique-window , the maximal interval such that the clique is -factor denser on than on the entire string. This ensures that the right proportion (-fraction) of live windows are covered by dense intervals and survive to the next child of the algorithm tree.
Colors
Suppose, that a window is part of a small clique (i.e. there are few other windows that are close to in edit distance), but most windows in an interval around belong to large cliques. On one hand, it is unlikely that the algorithm ever samples ’s small clique (because it is small). On the other hand, even if it did sample a clique with a window that is relatively close (on the string) to , that clique is large, and hence we can only take a very small interval around — too small to contain . In this case, we may actually lose . This is another source of our additive approximation error (in addition to the loss from the window-compatible matching in Step 0).
In order to bound this error term, we partition the windows into a constant number of colors, or equivalence classes based on the statistics of their cliques. By a simple Markov argument, we show that most windows have a not-too-small fraction of same-color windows in any interval around them. Whenever this is the case, the probability of sampling any clique in that interval is proportional to the length of the interval that the algorithm would use if it sampled ’s clique. Thus such a is likely to be discovered by the algorithm and survive to the next level.
On additive error
Our algorithm incurs an additive error of to achieve a runtime of . The reason is that the our algorithm makes levels of recursion. In each layer of the recursion, the size of the string is square-rooted. At the bottom-most level, when our string is of size we incur a additive error for some . When the subtrees are combined, this gives an additve error of .
1.1 Succinct Roadmap
In Section 2, we precisely formulate the edit distance problem and the parameters needed in the proof. In Section 3, we formulate how to compute window edit distance and reduce approximating edit distance to only needing to consider low-skew mappings. In Section 4, we describe the reduction from edit distance to a query algorithm. In Section 5, we describe the query algorithm as well as analyze it.
As the algorithm and analysis both have many moving parts, we have provided flow charts of the algorithms (Figure 2) and key lemmas and theorems (Figure 3) in this paper.
2 Preliminaries
2.1 Problem Definition
We let denote the index set of our strings. We denote the alphabet of our strings by . We let denote an additional character.
In this paper, strings are -indexed. If is a string, then we let , denote the substring of characters with index between and , inclusive, where .
We define the edit distance between two strings to be the minimum number of insertions, deletions, and substitutions needed to transform into . We note this quantity as .
Simplifying assumptions. As our goal is to find an algorithm when is a constant (but not any particular constant), it suffices to consider the case where the strings have the same length. Otherwise, since , we can delete the last characters of the longer of and to reduce to the case the two strings have the same length without precluding a constant-approximation.
We also assume without loss of generality that all necessary expressions are integral. Rounding has negligible impact on the approximations.
Main theorem
We now restate our Theorem 1 more formally:
Theorem**.**
For all , there exists constants and an randomized algorithm which takes as input two strings and of length and outputs such that with probability at least ,
[TABLE]
where and .
Remark*.*
By standard amplification arguments, the probability of failure can be made subexponential in .
Remark*.*
Our algorithm can also efficiently output with probability at least a sequence of edits between and of length at most . This follows from [CGKK18].
2.2 Table of parameters
As the proof involves many terms and parameters, we list them in Table 1 for reference. Each definition is restated when defined in the proof.
3 Mappings, Windows and Skew
In this section, we define important concepts for studying the edit distance between strings.
3.1 Mappings
A mapping is a partial function . This mapping is monotone if all for all such that and , then . We abuse notation and say that is . Observe that the insertion-deletion distance between and is equal to , for the maximal choice of .
3.2 Windows
Let be the target additive error in our edit distance computation. We seek to divide the strings and into windows, or contiguous substrings, of length . For string , we also include windows that correspond to shifts of integer multiples of .
Let .
Definition 1** (Windows).**
We partition strings into total overlapping windows, or contiguous substrings of width . Concretely,
[TABLE]
Notice that has a spacing of and has a spacing of .
For window , let denote the starting index of (e.g., ).
Mappings between window sets
Generalizing how we defined a mapping between characters in a string, we say that a mapping between windows is monotone if for all such that and then . Setting represents deleting from the string. As such, we define for all windows .
As a minor abuse of notation, we let denote the set of -windows such that .
For , let denote the immediately after (note that depends on the mapping ). If is the last window in , we define . We define in the analogous way.
We say that the edit distance of mapping is:
[TABLE]
The first term is just sum of the edit distances, and the second term is a penalty for either overlap (requiring deletions) or excessive spacing (requiring insertions).
We now show that the minimal value of over all monotone is a good approximation of , up to certain additive and multiplicative factors. First, we show that cannot underestimate .
Proposition 3** (implicit in [BEG*+*18]).**
For all monotone mappings , we have that
Proof.
Using we construct an explicit mapping from to . For each window , transform the characters of in into . If , then delete all the characters of . For any remaining window (now ) which is not last, if , then delete that many characters from the end of .
Let be the currently transformed string. By construction,
[TABLE]
Furthermore, since we deleted any overlaps between ’s, we have that is a subsequence of . Thus,
[TABLE]
Thus,
[TABLE]
∎
Next, we show that a “good” mapping with exists.
Lemma 4** (variant of Lemma 4.3 of [BEG*+*18]).**
For all , there exists a monotone mapping such that .
Proof.
Consider the optimal sequence of edits from to . This can be viewed as substitutions of characters of , deletions of characters, and then insertions, where . Let be the subsequence of untouched characters of . Let be the corresponding subsequence of . Let be the monotone correspondence between the characters of these substrings.
We construct as follows ( for brevity). For each , if , then let . Otherwise, consider the first . Set to be the rightmost intervals of which contains . Since is a monotone map, we have that is also monotone.
For each window which nontrivially intersects , let be the first index of . Likewise, let be the last index of . Note that for all with
Further define to be the number of characters in window which are deleted, to be the number of characters which are substituted, and the number of characters of which fails to map to . Note that for all
[TABLE]
as one can delete the unmatched characters and then insert the correct ones. If , and is not the block of , we have that This in particular means that
[TABLE]
as long as . If and , then we can bound . Finally, if , then .
Putting all these together, we can bound
[TABLE]
We now bound each of these terms. Clearly .
Note that if or then . Otherwise, . Note that there must be at least insertions between and in , so
[TABLE]
For , note that at least is upper bounded by the number of deletions in block . Likewise, is upper bounded by the number of insertions between and in . Thus, adding the absolute values, we can bound this entire sum by .
Finally, as characters map correspond to at most characters in the optimal proticol .
In total, we have that , as desired. ∎
Reduction to low-skew mappings
For , we say that a monotone map has skew at most if for all we have that
[TABLE]
We let be the minimum such that has skew at most . See Figure 4 for a depiction of large and small skew.
Although a minimal choice of with respect to may have arbitrarily large skew, we show that there exists whose skew is at most two and is within a constant factor of .
Claim 5**.**
For all monotone mappings , there exists such that and .
Proof.
Assume that for the remainder of this proof. Let be the set of all pairs which violate (1) and . We put a partial ordering on such that if . Let be the set of pairs which are maximal with respect to .
We also say that two pairs and are disjoint if or .
Consider the following procedure to build a set of pairwise disjoint elements of . First, take any maximal element of and insert it into . Then, delete from any pairs which are not disjoint from . Continue these two steps until is empty.
Label the elements of , such that . For all windows such that for some , set , Otherwise, set . Note that has skew at most because for every pair , must be not disjoint from for some . Because was chosen maximally, cannot be contained in . In particular, one of or is in the interval from . (If it were the case that , then must be between and and so is deleted.) Thus, at least one element of the pair maps to in . This means that has skew at most .
Now we show that . Let be the total number of windows deleted in the previous step. First, we show that , and then we show that .
To show the first inequality, it suffices to show that for any monotone, , where is the number of windows mapped to something other than . In particular, by a simple inductive argument, it suffices to consider the case . That is, there is exactly one such that but . If is either the first of the last window, then
[TABLE]
Otherwise, if and both exist (with respect to ), then
[TABLE]
This proves the base case, and thus , as desired.
Now we see to show that . Let be the number of windows deleted between and (inclusive). Thus, . Because violates (1), we have that either
[TABLE]
or
[TABLE]
In the first case,
[TABLE]
In the second case, let be the number of windows between and for which . Note that
Observe that
[TABLE]
Note in particular this means that
[TABLE]
as desired. Thus, ∎
Remark*.*
Essentially the same proof works for any , replacing the constant factor of with a suitable function of .
4 Reduction to the Query Problem
In Section 3, we have reduced approximating , to finding a low-skew matching between the windows and windows which (approximately) minimizes . Note that we incur an additive error in our approximation due to the discretization of and into windows and .
In Section 4.1, we demonstrate how to compute given estimates of the edit distance between windows of and windows of (Algorithm 1). In Section 4.2, we reduce (Algorithm 2) computing these pairwise window edit-distances to an algorithm Query which is stated an analyzed in Section 5. In Section 4.3, we state and analyze MAIN (Algorithm 3), which takes the original strings as input, partitions them into windows and calls the other algorithms. See Figure 2 to see how these algorithms interconnect.
4.1 Reduction to Estimating Window Distances
In order to optimize , we compute for every pair an estimate (the quality of the approximation will be discussed soon). For a given monotone mapping , we define the edit distance of this mapping with respect to this estimate to be
[TABLE]
where by definition. Further define
[TABLE]
Note that the space needed to store is . In the regime we are working , we will have that and , so the total storage is .
Given such an estimate , we can efficiently compute an optimal monotone matching for this objective. Our notion of window edit distance is slightly different from that of [BEG*+*18] (see Lemma 4.1 of their paper), but both are consistent within a constant factor (and sublinear additive term). For completeness, we include the pseudocode below which runs in time.
A key property of is that it is monotonic in . That is, if for all and , we have that , then for all . In particular, this implies that is within a constant factor of . Sadly, we are not aware of an algorithm which can guarantee that for all and . In the next subsection, we show a more subtle guarantee which suffices, when the edit distance is large.
4.2 Obtaining an estimate: Algorithmic reduction to query model
We claim that Algorithm 2 allows us to reduce to working with estimates.
The AggregateEstimates procedure works by splitting the task into easier questions. Given a threshold , which pairs in have edit distance at most ? To determine this, ObtainEstimate makes calls to (see Algorithm 4). We assume that Query has the following guarantees.
Lemma 6** (Main query algorithm).**
For all , let and . Assume , .
* (Algorithm 4) makes at most queries to and outside of those queries runs in time.*
Assume that for every for which is called, the Algorithm Main correctly returns
[TABLE]
For all monotone such that with probability at least , over the remaining randomness, Query returns an edge set such that
- •
For all .
- •
**
The algorithm and analysis of Query, including proving Lemma 6, are described in Section 5.
Using Lemma 6, we can prove the following guarantee for Algorithm AggregateEstimates.
Lemma 7**.**
For all , let and .
For all and , makes at most queries to and otherwise runs in time Assuming that all of these calls to Main succeed (see Eq. (2)), then AggregateEstimates with probability returns an estimate such that
[TABLE]
Proof.
Apply Lemma 6. Note that , , and Since , the procedure Query makes queries and runs in time (outside of queries). Since there are at most queries, the total number of queries is at most and the total other running time is at most .
This shows that AggregateEstimates is efficient. Now we show correctness, assuming all recursive calls to Main succeed and that Query succeeds as well. Let be the edge set returned by . Let be the set of for which
Then, by the first guarantee of Lemma 6, for all ,
[TABLE]
This immediately guarantees that . To show the upper bound on , by Lemma 4 and Claim 5, we have that there exists with and
[TABLE]
Define and for notational convenience. We have that
[TABLE]
by definition of . Observe
[TABLE]
Combingin Eq. (3) and Eq. (4),
[TABLE]
Each of these satisfies the needed guarantee with probability , so by a union bound they all succeed with probability at least . ∎
4.3 Main algorithm
We can now succinctly describe the main algorithm.
As a Corollary of Lemma 7, we have that MAIN runs efficiently, without accounting for the recursion.
Corollary 8**.**
If , then exactly computes in time.
For all , there exists and with the following property.
For all and , makes at most queries to and otherwise runs in time With probability at least all these recursive calls succeed (and run efficiently) and the algorithm returns an estimate such that
[TABLE]
Proof.
We induct on . The base case the is obvious. Assume this holds for the case of . Then, note that for all calls to satisfy the conditions of the inductive hypothesis. Thus, by Lemma 7, has the prescribed properties and run-time with probability , assuming all the recursive calls succeed. Since there are at most recursive calls, each succeeding with probability at least , the total success probability is at least
[TABLE]
Finally, by Algorithm 1, can be computed in time, as desired. ∎
Now that we understand the recursive structure of Main, we can prove our main result.
Theorem 9** (correctness and efficiency of Main).**
For all and , there exists such that for all and any , with probability , returns an estimate such that
[TABLE]
Further, with high probability, this algorithm runs in time.
Proof.
We induct on . The base case of is obvious.
For , consider the from Corollary 8. We then have by the inductive hypothesis that with high-probability that the algorithm succeeds and the run-time is at most
[TABLE]
as desired. ∎
Setting and so that proves Theorem 1.
Notice then that
[TABLE]
5 Query Model and Analysis
5.1 Roadmap
The goal of this section is to prove Lemma 6, which says that, with respect to any matching , Algorithm Query returns a set of edges which satisfies:
[TABLE]
We first describe an implementation of Query in Section 5.2.
It is helpful to consider the algorithm tree of recursive calls made by Query. At each -th level internal node (or call to Query) we keep track of a set of live windows , and the goal is to find a smaller set of live windows for the next round. To do this, we pick a uniformly random live window , and recursively call , to compute the (approximate) edit distance from to every other window in . The set of windows which are distance from is called a clique, which we denote by . If the clique is extremely big (see Figure 1(a)), that is , then we terminate the recursion, adding to the output . Otherwise, if is relatively small, we define to be the set of windows that are close (in terms of their respective locations on the strings) to the windows in (see Figure 1(c)). Here “close” is chosen so that . If we haven’t terminated earlier due to a big clique, by level the set of live windows is sufficiently small so that we can brute force query all the pairs to compute their (approximate) edit distance.
At each node, we don’t just do the refinement of live windows once, but rather we pick many candidate ’s (approximately many) and branch on all of these. We show that with high probability, most edges of the matching will survive to the next level of the recursion tree (see Lemma 25). By induction this will imply that nearly every edge of is ultimately included in ; (Section 5.4.4).
In Section 5.3 we introduce some key definitions and propositions that we later use in the proof of our main inductive step. One important concept is that of good windows; intuitively a window is good if it is live and its match is also live. Our analysis only holds for active nodes of the algorithm tree, which are those where the fraction of good live windows is not too small. The third key concept we introduce in this section is a partition of all the edges in the matching into a constant number of colors; roughly we say that two edges and are of the same color if the respective cliques (or edit distance balls) around and have identical statistics (to within a multiplicative factor of ). In particular, Proposition 16 asserts that in every interval around a typical good window , the fraction of live windows of the same color is non-negligible. Note that good windows, active nodes, and colors depend on and hence are only used in the analysis of the algorithm.333There are actually two notions of color, a window color which only considers local statistics of the window itself and is independent of and matching color which is a combination of the windows colors of a window and its match according to . The latter notion crucially depends on .
We complete the proof of the main inductive step in Section 5.4. The key step, which we call the Color Lemma (Lemma 26) due to the heavy use of colors, asserts that most -level-good windows have a not-too-small probability of staying alive in level . To prove the Color Lemma (Section 5.4.2), we consider an interval around , of length chosen with respect to the clique around . We then consider the , such that and are of the same color, take the cliques around each such , and finally let denote the union of cliques. We argue that (i) is large (Claim 28), and (ii) whenever the algorithm uses a clique around some , the good window remains live for the next level (Claim 27). To analyze , it is useful that the clique around each is similar to the clique around (since and are close in edit distance), and the clique around is similar to the clique around (since they have the same color).
Section 5.5 concludes with a short proof that the Query is efficient both in run-time and in the number of recursive calls it makes to Main.
5.2 Query algorithm
In this section, we assume that , , and (representing the from Algorithm 3). Let be the bipartite graph on such that iff .
For any edge set and monotone mapping , we abuse notation and say that if for every , either , or .
Recall that our main goal (Lemma 6) is to construct a set such that and misses few () edges of the optimal matching .
Algorithm Tree
Our query algorithm is recursive (not to be confused with the recursion of Algorithm Main). Each depth- call to Query instantiates new depth- recursive calls. This implicitly defines a tree where we associate the edges with executions of Query and the nodes with the state of the algorithm at each call (in particular, the set of live windows defined below).
Live windows
At each iteration, the algorithm maintains a set of live windows, denoted We denote and . The intention is that for sizeable fraction of windows we have , and vice-versa. At the beginning of the algorithm, we have .
Cliques
At each call to Query, we pick a uniformly random live window and query the edit distance between to all other windows in .
Definition 2** (Cliques).**
Given and , we let be a clique defined by
[TABLE]
where is the value returned by , and (see Table 1).
Remark*.*
By the triangle inequality, every pair of windows in is -close. Thus, we can include an edge in for every pair of windows in . Hence, we call a clique.
For the purposes of the query analysis, we assume that is always computed correctly by MAIN, that is
[TABLE]
We also assume that . We can ensure this by maintaining a hash table444For clarity of exposition, we do not include this step in the algorithm, but adding it is straightforward and can only improve the runtime. of computed window edit distances and only running MAIN on new pairs.
The algorithm will randomly sample a small number of for uniformly random and . During the analysis, we consider an ensemble of all such cliques (we can do this by pretending that was determined correctly for all and , even though we only need to computer a small number in the algorithm).
Intervals
An interval is a continuous segment of windows. (Thus, either or .) We let denote the set of intervals of each length in which are disjoint and cover , where this is the same as in the condition .
We also maintain a set of interval-multipliers.555We also use as an interval multiplier in parts of the analysis, but not where is used. For interval and multiplier , we let denote the interval of length centered at . If the centered interval goes off the ends of or , then we truncate appropriately. Thus, on occasion, but we always have that .
Snapping and stability
We also have a function which rounds to the largest power of which is at least . We say that . Thus, if , there are at most possible snapped values. In particular, this means that in a monotone sequence of length , there must be (many) consecutive values which snap to the same value.
Claim 10** (Stability).**
Let be a monotone sequence ( for all or for all ). Then, for all but values of ,
[TABLE]
Proof.
Let be the set of indices for which . Since the ’s are monotonic and takes on at most values, . If for some , Eq. (5) is not satisfied, then either or . Thus, the number of violating is at most . ∎
Density
For a clique we have a notion of density as we describe below.
The global density of a clique is given by666All snaps are to the closest power of .
[TABLE]
Define the local density of on interval as
[TABLE]
Now, the relative density of on is the ratio of the local and global densities:
[TABLE]
Unlike the other notations of density, relative density can often be greater than . We let denote the density threshold for our algorithm. We say that is dense on if
With this concept of density, we define , given a clique center and distance theshold to be
[TABLE]
In other words, is the union of all intervals which are -dense. In the algorithm, and are sampled uniformly at random.
Big cliques
Notice that if contains almost a constant fraction of the live windows, namely
[TABLE]
then no interval can be dense. On the high level this means that (i) we can’t make progress by recursing via “seed-and-expand”; but also we don’t need to because (ii) we’re in the “dense graph” case (here density is relative to the remaining live windows). In particular, we can simply add all the pairs from to and backtrack in the algorithm tree. We call such cliques big cliques.
The Query Algorithm
The following is the Query Algorithm, broken up into four methods.
5.3 Tools for analysis of the query algorithm
In this section, we define a number of important concepts that are crucial for the analysis of our the Query Algorithm.
Notation for
Recall that is a large monotone matching with low skew in that we would like to discover. Although is defined as a partial function from to , we extend to be a partial involution of . That is, for all for which . This abuse of notation keeps things symmetric.
For any set , we define In particular, , is the set of windows in which match to another window in .
Properties of cliques
The following proposition says the key properties of cliques that we shall use.
Proposition 11**.**
For all and , we have the following properties.
. 2. 2.
If , then . 3. 3.
If , . 4. 4.
If then 5. 5.
If then
Proof.
Since , we have . Thus, . 2. 2.
Since , we have . 3. 3.
implies 4. 4.
This follows precisely from because we memoize previous calls to Main. 5. 5.
Since , . In particular, for all ,
[TABLE]
∎
Cyclic indices of intervals
Given two intervals , we say that if and or . Define the shift of an interval , , to be the number of intervals to the left of of the same length. In other words,
[TABLE]
Given a multiplier , we say that if and have the same length, are both in or both in , and .
Note that for every and and every shift , there exists exactly one (the set of intervals with multiplier ) such that and . To do this, we need to include intervals in which are centered at an interval that is “off the boundary.” For example, the set of intervals of length with interval multiple is
[TABLE]
Decreasing interval-densities
In the previous section, we define the notion of density of a clique. In this section, we also need a notion of live-density. For any interval , we define its live-density to be the cardinality of the intersection divided by the length of the interval. That is,
[TABLE]
We would like to ensure for any , if the interval around increases, then the density cannot increase substantially. This is formalized in the following definition.
Definition 3**.**
We let be the set of such that for all with and ,
[TABLE]
Note that if , then . In general enforcing this condition only requires discarding a small fraction of .
Claim 12**.**
We have that
[TABLE]
Proof.
Define
[TABLE]
We then have that
[TABLE]
Thus,
[TABLE]
Note in the last step, we used . This implies Eq. (7). ∎
Good windows
In our analysis, we maintain an additional set of windows . Defined as follows
Definition 4** (Good windows).**
For a given node at level of the recursion tree, we define
[TABLE]
roughly keeps track of which also have . Note that the algorithm does not “know” because it does not know . We also require that and satisfy the decreasing densities condition.
Note that our base case is
[TABLE]
Active nodes
Throughout the algorithm, we say that a node at level in the algorithm tree is active if the following condition holds
Definition 5** (Active node).**
A node at level of the algorithm tree is active if the following holds:
[TABLE]
Eq. (9) ensures that remains non-negligible compared to . Note that as long as the inactive nodes do not cause the algorithm to run for too long, they cannot hurt the quality of our solution.
Stable balls
For a fixed , notice that
[TABLE]
Thus, by Claim 10, is often constant in a subsequence around . In fact, for any interval , we can similarly deduce that is often constant.
Definition 6** (Stable balls).**
We say that is stable at (or -stable) if for all and such that .
[TABLE]
and
[TABLE]
By definition of relative density, any -stable also satisfies
[TABLE]
Claim 13** ( is often -stable.).**
For all , is stable at for all but choices of .
Proof.
For a given , notice that there are at most intervals which contain , and at most intervals which contain . In addition to the global density condition, there are separate density conditions to satisfy. By Claim 10, any particular condition is violated for at most choices of . Thus, there are at most choices for which is not -stable. ∎
Colors
Definition 7** (Window colors).**
For a given node of the algorithm tree, we partition the windows in into a constant number of window-colors, or equivalence classes. Specifically, we say that with or belong to the same color, denoted as (equivalently ), if all of the following hold, for every , every interval-multiplier , and every pair of intervals such that , , and .
global density
and have approximately777Recall that all terms in the definition of density are snapped to the nearest power of . the same global density, including when intersected with :
[TABLE]
local density
and have approximately the same local density. Namely,
[TABLE]
Definition 8** (Matching colors).**
For all , we say that ’s matching-color (or just color) is
[TABLE]
We let denote the partition of into matching-colors (which are just called colors in the rest of the paper). For a given , is ’s color. Note that and have the same color if and only if and . Also note that and have the same color if and only if and have the same color (this fact is critical in Claim 29).
For the analysis, note that which is a constant independent of . In particular as long as . Also note that color is independent of the algorithm’s choice of and .
The following are some of the most useful facts about colors. We start with showing that the property of being -stable is consistent within a color. This is an important tool in proofs of later propositions.
Proposition 14** (Stability is identical within color.).**
For all , , and , is -stable if and only if is -stable.
Proof.
It suffices to show that is -stable implies that is -stable.
Let be any interval such that . We have that there is an equivalent interval such that .
[TABLE]
By a similar argument, the global densities are also stable. Thus, is -stable. ∎
Next, we show that most windows are in a large color. This makes sure that when we randomly sample windows in the algorithm, we are likely to sample a distribution of colors which reflects the true distribution.
Proposition 15** (Most are in a large color.).**
Assume that is an active node. For all but fraction of ,
[TABLE]
Proof.
Let be the set of colors such that
[TABLE]
For all , we have that
[TABLE]
Observe that
[TABLE]
as desired. ∎
We now prove a stronger version that most intervals around most windows have many of the same color. That is, most windows are not “isolated.” This helps makes sure that most windows are ‘discoverable’ by making it likely that for most windows, some sampled window will be of the same color and close in proximity.
Proposition 16** (In ’s interval, there are many of the same color.).**
Assume that is active. For fraction of for all such that ,
[TABLE]
Proof.
Let be the set of such that
[TABLE]
By logic similar to that of the proof of Proposition 15, we have that
[TABLE]
Summing over all choices of , we have that
[TABLE]
Thus, at least fraction of satisfy Eq. (13) for all choices of . ∎
The following is a refined version of the above proposition.
Corollary 17**.**
Assume that is active. For fraction of for all such that ,
[TABLE]
Proof.
Consider equivalent to such that . Then, . Thus, whenever (13) is satisfied
[TABLE]
∎
Maximal intervals
In the query algorithm, we take the union of ‘dense’ intervals around each of the sampled windows. These intervals are formally defined as follows.
Definition 9** (Maximal interval).**
For any and , define to be the maximal such that and
[TABLE]
If no such interval exists, then
Note that if and are chosen by the algorithm and , then . In particular, .
We also define
[TABLE]
Note that . First, we show that every maximal interval is very close in relative density to the ‘target’ relative density of .
Proposition 18**.**
For all for which ,
[TABLE]
Proof.
The lower bound follows immediately from the definition of .
To show the upper bound, first note that cannot be the entire string ( or ), since then
[TABLE]
Otherwise, we can consider which is the next larger interval in . Since is a maximal interval such that Eq. (15) holds,
[TABLE]
where the last line uses that . ∎
The following proposition unpacks the previous proposition into an explicit statement about interval lengths and their intersections with .
Proposition 19**.**
For all such that
[TABLE]
Proof.
[TABLE]
Most of the steps follow by definitions of local, global, and relative densities (with approximation due to the snaps), with the exception of the third line, which follows from Proposition 18. Note that because . ∎
We also need to make sure that the maximal intervals are not .
Proposition 20**.**
For all and such that . For all , we have that
[TABLE]
In particular, for all , such that is small, .
Proof.
Consider the interval around . Then,
[TABLE]
Thus, either or a superset of is in . ∎
We also show that two windows of the same color in closer proximity have the same maximal interval.
Proposition 21**.**
Fix . For all such that is small, and , we have that
[TABLE]
Proof.
For brevity, let and . Since and and have the same color,
[TABLE]
Thus, (by maximality of ). Which in particular implies that . Therefore,
[TABLE]
Therefore, , and so . ∎
In addition, we show that these maximal intervals do not change at -stable points when the radius is changed.
Proposition 22** ( stability).**
For a fixed and , for all , if is -stable (Definition 6), then
[TABLE]
Thus, for all , by Proposition 21,
[TABLE]
Proof.
Since is -stable and , we have that for all .
[TABLE]
Thus, by maximality. By a nearly identical argument (c.f., Proposition 21), we have that , so . ∎
We now show that going from to in the algorithm tree decreases the size of by a factor of roughly . This makes sure that the total work done in each level of the algorithmic tree is approximately the same.
Proposition 23**.**
Consider a node at level of the algorithm tree. Assume that are such that (the small clique case), then
[TABLE]
In particular, for all ,
[TABLE]
Proof.
By definition,
[TABLE]
where the last line follows from the fact that every is in intervals. The second statement follows by induction, and that . ∎
More on interval multipliers
Also note the following fact about interval multipliers, which will be of use during the analysis. Essentially it says that if two intervals share an edge of , then fully sends one into the scaled interval of the other. This proposition is the key reason we assume that .
Claim 24**.**
Let be intervals such that there exists such that . Then, at least one of the following is true
[TABLE]
Proof.
Let be the first window in such that . Let be the last window in such that . Define analogously.
It suffices to show that either or . Assume for sake of contradiction that both are false. In particular, this means that at least one of is is at least three times the length of the interval away from (respective fact for , too).
In equations,
[TABLE]
Now, using that has skew at most , we have
[TABLE]
a contradiction unless in which case . Thus, the claim holds. ∎
5.4 Correctness of the query algorithm
5.4.1 Surviving windows
Definition 10** (Surviving window).**
Given a node at level in the algorithm tree, we say that survives if the edge is discovered with probability at least over the remaining randomness in the algorithm and assuming all calls to are accurate.
The following is the key lemma we need concerning active nodes–that almost every active node survives in at least one branch of the algorithm tree.
Lemma 25** (Main inductive step).**
Assume that is an active node at level in the algorithm tree. Then, all but -fraction of survive.
Before we prove Lemma 25, we show the following necessary ingredient which shows that most active nodes have some of the properties for being active in the next level.
Lemma 26** (The Color Lemma).**
Let be any active node at level in the algorithm tree, then for all but windows with probability at least over the choice of and , we have that either
- •
, or
- •
.
Note that this Lemma is a bit weaker than Lemma 25, as we only obtain that (instead of ) and we do not know whether is active. We call this result the Color Lemma as the definition of colors (Definition 8) is crucial to its proof.
5.4.2 Proof of the Color Lemma
To prove the Color Lemma (Lemma 26), we need for every pair to identify a large collection of potential such that either or . The first case is very likely if and only if is a big clique. Otherwise, most come from a different set.
Let be the set of nodes for which is big. Let .
Consider any . For all and define
[TABLE]
That is is the union of ’s clique and all cliques whose center is nearby and has the same color as .
We also define a variant of which is symmetric in and :
[TABLE]
Our goal now is to show that for any , . To do this, we need to show some maximal intervals will contains and .
Claim 27** ( finds ).**
For all either or for any such that is -stable and for all ,
[TABLE]
In particular, , so .
Proof.
Let . Let . Assume that is stable at . By Proposition 22, ; let be this common interval.
For any , we have that is stable at by Proposition 14, and since ,
[TABLE]
Thus, it suffices to show that for all . Notice by Proposition 11,
[TABLE]
Since is stable at , this means that
[TABLE]
Thus, , as desired. ∎
Further, we need to make sure that is large so that we have a large chance of sampling a window from (and thus the window survives on). We make exception to the case is in a big clique, since that is likely to be discovered.
Claim 28** ( is big).**
For fraction of either or for all such that is -stable.
[TABLE]
Proof.
Assume that and such that Proposition 16 holds. Since is -stable, Proposition 22 holds for . Fix .
Let The size of is lower bounded by the sum of the set sizes, divided by the maximum number of ’s that could have generated any given :
[TABLE]
Note that if , then (by Proposition 11). Thus, for a fixed pair of and ,
[TABLE]
Because (by Proposition 22), we have by Proposition 19 that
[TABLE]
Plugging back into (24), we have that
[TABLE]
as desired. ∎
The previous statements were just that survives. Now we need to show that and survive.
Claim 29** ( is big).**
For fraction of either or or for all such that both and are -stable,
[TABLE]
Proof.
Assume that neither . Since at most fraction of fail to satisfy Claim 28, for all such that is -stable, we must have at most fraction of fail to satisfy Claim 28 for at least one of and (whenever both and are -stable).
Consider any and such that both and are -stable and Claim 28 is satisfied for both and . Since , it suffices then to show that either
[TABLE]
Let and . By Claim 24, we must then have that either
[TABLE]
If the first case holds, for all ,
[TABLE]
Thus, . Likewise, if the second case holds, for all
[TABLE]
Then, . Note we are using the fact that if and have the same color, then and have the same color. ∎
Now we have all the tools we need to prove the color lemma.
Proof of the Color Lemma..
First, consider the case that . That is, . Then, by triangle inequality, for all , the clique contains both and . The probability of sampling and is at least
[TABLE]
Similar logic covers the case .
Otherwise, we may assume that for all . For all but such , we have by Claim 27 that for all and any such that and are stable. Further, by Claim 29, we have for all such and that . Since the probability of selecting a proper is at least by Claim 13, the probability of success again is at least .
Note that for all , is not big, as we proved that there exists an interval for which the clique has relative density , implying the global density is at most . ∎
5.4.3 Proof of the main inductive step (Lemma 25)
Proof.
We prove this lemma by “reverse” induction with as the base case. Note that for every node at level , all pairs of windows in are queried. Thus, the base case follows as .
Now assume that the statement is true for some , we seek to show that it is also true for . Let be any active node at level .
Create a bipartite graph with and . Let be all pairs such that
[TABLE]
Let . Since is active, we know that
[TABLE]
Also, by Eq. (7)
[TABLE]
Let By Lemma 26, all but vertices have degree at least . Thus,
[TABLE]
Let , such that fraction of the have the degree exactly and all other vertices have degree [math] (including all vertices in (). Thus,
[TABLE]
Let be the set of nodes for which is big or
[TABLE]
For any such for which is not big and the degree is large, we then have that
[TABLE]
Thus, is active for all . Let . Observe that the average degree of is
[TABLE]
Thus, at most fraction of the edges are deleted. Therefore,
[TABLE]
Note that for all , is big or is active. Let be the edges such that
[TABLE]
By the inductive hypothesis, for every , the number of edges of that get deleted from to is at most
[TABLE]
Therefore,
[TABLE]
Since every vertex of has degree at most , by Markov’s inequality, all but of have degree at least . Let be the set of such . Then, for each , the probability that a given succeeds for and finds is at least . This implies that the probability succeeds for some is at least
[TABLE]
∎
5.4.4 Proof of Lemma 6
Proof.
The runtime and query complexity guarantees are proved in Section 5.5.
To prove the first point that all returned edges have edit distance . Note that for each clique and encountered by the algorithm, . The edit distance between any two windows in the clique is at most . Thus, the guarantee is satisfied.
To prove the second point, recall that we defined to be the edges of the matching with distance at most . By Lemma 25, all but fraction of can be discovered with probability at least . Thus by a union bound, with probability at least , all of these can be discovered together. Thus, the number of unfound edges is at most with high probability. ∎
5.5 Efficiency of the query algorithm
For each function, we compute upper bounds on its running time (outside of recursive calls to Main) as well as how many times it calls Main. When computing run time, the big- notation obscures all factors independent of .
Proposition 30**.**
* runs in time and makes no queries.*
Proof.
Iterating over such that can be done in by maintaining for each the list of intervals which intersect it (and marking which ones have been visited to avoid repeats).
Computing each relative density takes time in the worst case. Note that
[TABLE]
as each window is in intervals of . ∎
The next analysis is sufficiently obvious, we state it without proof.
Proposition 31**.**
* makes queries to and otherwise takes running time.*
We now unroll the Query recursion with the following two inductive claim.
Claim 32** (Queries to Main.).**
For all , for any node at level in the algorithm tree, makes at most calls to .
Proof.
We prove this by (reverse) induction on . The base case of , then queries are made to Main. By Proposition 23, we have that
[TABLE]
Thus, the number of queries is at most .
For , the outer loop of Query is iterated times. Each of these iterations makes calls to Main, and if the clique is small then a call is made to . By the induction hypothesis, this recursive call queries Main at most times. Thus, the total number of calls to Main is at most
[TABLE]
where the last step follows from . ∎
Claim 33** (Running time.).**
For all , for any node at level in the algorithm tree, has a running time of outside of calls to .
Proof.
Like the previous claim, we prove this by (reverse) induction on . The base case of , runtime outside of Main. By Proposition 23, we have that
[TABLE]
Thus, the number of queries is at most .
For , the outer loop of Query is iterated times. Each of these iterations, the runtime is outside of calls to Main. If the clique is small then a call is made to . By the induction hypothesis, this recursive has a runtime at most times. Thus, the total number of calls to Main is at most
[TABLE]
where the last step follows from . ∎
Applying the root of the algorithm tree (at level ) from the previous two claims, we get the following corollary.
Corollary 34**.**
* makes queries to and otherwise takes running-time.*
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[AHWW 16] Amir Abboud, Thomas Dueholm Hansen, Virginia Vassilevska Williams, and Ryan Williams. Simulating branching programs with edit distance and friends: or: a polylog shaved is a lower bound made. In Proceedings of the 48th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2016, Cambridge, MA, USA, June 18-21, 2016 , pages 375–388, 2016.
- 2[AKO 10] Alexandr Andoni, Robert Krauthgamer, and Krzysztof Onak. Polylogarithmic approximation for edit distance and the asymmetric query complexity. In 51th Annual IEEE Symposium on Foundations of Computer Science, FOCS 2010, October 23-26, 2010, Las Vegas, Nevada, USA , pages 377–386, 2010.
- 3[AO 12] Alexandr Andoni and Krzysztof Onak. Approximating edit distance in near-linear time. SIAM J. Comput. , 41(6):1635–1648, 2012.
- 4[BEG + 18] Mahdi Boroujeni, Soheil Ehsani, Mohammad Ghodsi, Mohammad Taghi Hajiaghayi, and Saeed Seddighin. Approximating edit distance in truly subquadratic time: Quantum and mapreduce. In Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2018, New Orleans, LA, USA, January 7-10, 2018 , pages 1170–1189, 2018.
- 5[BES 06] Tugkan Batu, Funda Ergün, and Süleyman Cenk Sahinalp. Oblivious string embeddings and edit distance approximations. In Proceedings of the Seventeenth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2006, Miami, Florida, USA, January 22-26, 2006 , pages 792–801, 2006.
- 6[BI 15] Arturs Backurs and Piotr Indyk. Edit distance cannot be computed in strongly subquadratic time (unless SETH is false). In Proceedings of the Forty-Seventh Annual ACM on Symposium on Theory of Computing, STOC 2015, Portland, OR, USA, June 14-17, 2015 , pages 51–58, 2015.
- 7[BJKK 04] Ziv Bar-Yossef, T. S. Jayram, Robert Krauthgamer, and Ravi Kumar. Approximating edit distance efficiently. In 45th Symposium on Foundations of Computer Science (FOCS 2004), 17-19 October 2004, Rome, Italy, Proceedings , pages 550–559, 2004.
- 8[CDG + 18] Diptarka Chakraborty, Debarati Das, Elazar Goldenberg, Michal Koucký, and Michael E. Saks. Approximating edit distance within constant factor in truly sub-quadratic time. Co RR , abs/1810.03664, 2018.