Rattling Frigid Algorithms: Levenshtein Automata

Rattling Frigid Algorithms: Levenshtein Automata

Posted by Gash Johnson

| Filed under





In a previous Rattling Frigid Algorithms submit, I talked about BK-bushes, a suave indexing construction that makes it doable to see fuzzy fits on a textual divulge material string per Levenshtein distance – or any assorted metric that obeys the triangle inequality. This day, I will inform an replace near, which makes it doable to attain fuzzy textual divulge material search in a customary index: Levenshtein automata.


The basic perception in the encourage of Levenshtein automata is that it be doable to have a Finite speak automaton that acknowledges precisely the put of strings inner a given Levenshtein distance of a target discover. We can then feed in any discover, and the automaton will procure or reject it per whether the Levenshtein distance to the target discover is at most the distance specified when we constructed the automaton. Additional, as a result of the nature of FSAs, this could perhaps attain so in O(n) time with the length of the string being examined. Overview this to the customary Dynamic Programming Levenshtein algorithm, which takes O(mn) time, where m and n are the lengths of the two input phrases! It is thus valid now apparrent that Levenshtein automaton present, at a minimal, a faster manner for us to study many phrases in opposition to a single target discover and most distance – not a frightful boost to originate with!

Obviously, if that possess been the only real profit of Levenshtein automata, this would be a short article. There might be mighty extra to device, but first let’s leer what a Levenshtein automaton looks take care of, and the diagram in which we can originate one.

Construction and overview

The diagram on the accurate shows the NFA for a Levenshtein automaton for the discover ‘meals’, with most edit distance 2. As chances are you’ll also leer, it be very customary, and the construction is reasonably easy. The originate speak is in the decrease left. States are named the utilization of a ne model notation, where n is the preference of characters consumed to this point, and e is the preference of errors. Horizontal transitions symbolize unmodified characters, vertical transitions symbolize insertions, and the two sorts of diagonal transitions symbolize substitutions (these marked with a *) and deletions, respectively.

Let’s leer how we can have an NFA reminiscent of this given an input discover and a most edit distance. I can’t include the source for the NFA class here, because it be fairly customary; for gory particulars, leer the Gist. Right here is the related characteristic in Python:

def levenshtein_automata(time frame, k):
  nfa=NFA((0, 0))
  for i, c in enumerate(time frame):
    for e in differ(k + 1):
      # Correct character
      nfa.add_transition((i, e), c, (i + 1, e))
      if e 

This has to be easy to apply; we're in overall constructing the transitions you leer in the diagram in doubtlessly the most easy manner doable, in addition to denoting the staunch put of ultimate states. Verbalize labels are tuples, in preference to strings, with the tuples the utilization of the same notation we described above.

On fable of this is an NFA, there's also extra than one active states. Between them, these symbolize the doable interpretations of the string processed to this point. As an illustration, make a selection into fable the active states after drinking the characters 'f' and 'x':

This indicates there are several doable adaptations which would be per the first two characters 'f' and 'x': A single substitution, as in 'fxod', a single insertion, as in 'fxood', two insertions, as in 'fxfood', or a substitution and a deletion, as in 'fxd'. Additionally included are several redundant hypotheses, reminiscent of a deletion and an insertion, moreover ensuing in 'fxod'. As extra characters are processed, all these chances will almost definitely be eliminated, whereas assorted fresh ones will almost definitely be provided. If, after drinking your whole characters in the discover, an accepting (bolded) speak is in the put of most in model states, there is a mode to remodel the input discover into the target discover with two or fewer adjustments, and we know we can procure the discover as legit.

Essentially evaluating an NFA straight tends to be fairly computationally pricey, as a result of the presence of further than one active states, and epsilon transitions (that's, transitions that require no input symbol), so the customary reveal is to first convert the NFA to a DFA the utilization of powerset construction. The utilization of this algorithm, a DFA is constructed all over which each and every speak corresponds to a suite of active states in the usual NFA. We are in a position to not trot into detail about powerset construction here, because it be tangential to the predominant topic. Right here is an example of a DFA such as the NFA for the input discover 'meals' with one allowable error:

Existing that we depicted a DFA for one error, as the DFA such as our NFA above is a bit too advanced to fit very effortlessly in a weblog submit! The DFA above will procure precisely the phrases that possess an edit distance to the discover 'meals' of 1 or much less. Are attempting it out: clutch any discover, and designate its direction thru the DFA. In case you close up in a bolded speak, the discover is legit.

I can't include the source for powerset construction here; it be moreover in the gist for these that care.

Temporarily returning to the relate of runtime efficiency, you is also questioning how efficient Levenshtein DFA construction is. We can have the NFA in O(kn) time, where k is the edit distance and n is the length of the target discover. Conversion to a DFA has a worst case of O(2n) time - which results in a fairly terrifying worst-case of O(2kn) runtime! No longer all is doom and gloom, despite the undeniable fact that, for two reasons: First of all, Levenshtein automata will not device wherever almost about the 2n worst-case for DFA construction*. 2nd, some very suave computer scientists possess device up with algorithms to have the DFA straight in O(n) time, [SCHULZ2002FAST] and even an almost about skip the DFA construction totally and reveal a table-essentially based totally totally overview near!


Now that we possess established that it be doable to have Levenshtein automata, and demonstrated how they work, let's make a selection a glimpse at how we can reveal them to search an index for fuzzy fits efficiently. The first perception, and the near many papers [SCHULZ2002FAST] [MIHOV2004FAST] make a selection is to witness that a dictionary - that's, the put of information you're taking care of to make a selection to search - can itself be represented as a DFA. If truth be told, they're ceaselessly kept as a Trie or a DAWG, both of that might be considered as particular cases of DFAs. Provided that both the dictionary and the criteria (the Levenshtein automata) are represented as DFAs, it be then doable to efficiently intersect the two DFAs to procure precisely the phrases in the dictionary that match our standards, the utilization of a pretty easy diagram that appears to be like something take care of this:

def intersect(dfa1, dfa2):
  stack=[("http://blog.notdot.net/", dfa1.start_state, dfa2.start_state)]
  whereas stack:
    s, state1, state2=stack.pop()
    for edge in put(dfa1.edges(state1)).intersect(dfa2.edges(state2)):
      state1=dfa1.next(state1, edge)
      state2=dfa2.next(state2, edge)
      if state1 and state2:
        s=s + edge
        stack.append((s, state1, state2))
        if dfa1.is_final(state1) and dfa2.is_final(state2):
          yield s

That is, we traverse both DFAs in lockstep, simplest following edges that both DFAs possess in current, and maintaining music of the direction we possess adopted to this point. Any time both DFAs are in a final speak, that discover is in the output put, so we output it.

Right here is all very properly in case your index is kept as a DFA (or a trie or DAWG), but many indexes are not: if they're in-memory, they're doubtlessly in a sorted list, and if they're on disk, they're doubtlessly in a BTree or same construction. Is there a mode we can regulate this plan to work with these variety of indexes, and composed present a speedup on brute-pressure approaches? It appears to be like that there's.

The serious perception here is that with our standards expressed as a DFA, we can, given an input string that doesn't match, procure the next string (lexicographically talking) that does. Intuitively, this is reasonably easy to attain: we make a selection into fable the input string in opposition to the DFA unless we can not proceed further - to illustrate, because there will not be any legit transition for the next character. Then, we usually apply the threshold that has the lexicographically smallest trace unless we reach a final speak. Two particular cases apply here: First, on the first transition, we decide to apply the lexicographically smallest trace greater than character that had no legit transition in the preliminary step. 2nd, if we reach a speak and not using a legit outwards edge, we ought to trot into reverse to the previous speak, and make a selection a glimpse at yet again. Right here is reasonably mighty the 'wall following' maze fixing algorithm, as utilized to a DFA.

For an example of this, make a selection a glimpse at the DFA for meals(1), above, and make a selection into fable the input discover 'foogle'. We eat the first four characters dazzling, leaving us in speak 3141. The accurate out edge from here is 'd', whereas the next character is 'l', so we trot into reverse one step to the previous speak, 21303141. From here, our next character is 'g', and there's an out-edge for 'f', so we make a selection that edge, leaving us in an accepting speak (the same speak as beforehand, if truth be told, but with a sharp direction to it) with the output string 'fooh' - the lexicographically next string in the DFA after 'foogle'.

Right here is the Python code for it, as a near on the DFA class. As beforehand, I possess not included boilerplate for the DFA, which is all here.

  def next_valid_string(self, input):
    # Overview the DFA as some distance as doable
    for i, x in enumerate(input):
      stack.append((input[:i], speak, x))
      speak=self.next_state(speak, x)
      if not speak: destroy
      stack.append((input[:i+1], speak, None))

    if self.is_final(speak):
      # Input discover is already legit
      return input
    # Create a 'wall following' see the lexicographically smallest
    # accepting speak.
    whereas stack:
      direction, speak, x=stack.pop()
      x=self.find_next_edge(speak, x)
      if x:
        direction +=x
        speak=self.next_state(speak, x)
        if self.is_final(speak):
          return direction
        stack.append((direction, speak, None))
    return None

Within the first part of the characteristic, we make a selection into fable the DFA in the usual vogue, maintaining a stack of visited states, at the side of the direction to this point and the threshold we intend to strive to apply out of them. Then, assuming we didn't procure an accurate match, we acquire the backtracking search we described above, looking out out for out the smallest put of transitions we can apply to technique to an accepting speak. For some caveats concerning the generality of this characteristic, read on...

Additionally wanted is the utility characteristic find_next_edge, which finds the lexicographically smallest outwards edge from a speak that's greater than some given input:

  def find_next_edge(self, s, x):
    if x is None:
      x=unichr(ord(x) + 1)
    state_transitions=self.transitions.acquire(s, {})
    if x in state_transitions or s in self.defaults:
      return x
    pos=bisect.bisect_left(labels, x)
    if pos 

With some preprocessing, this is also made substantially extra efficient - to illustrate, by pregenerating a mapping from every character to the first outgoing edge greater than it, in preference to the utilization of binary search to procure it in many cases. I over yet again leave such optimizations as an reveal for the reader.

Now that we possess this diagram, we can at closing inform easy strategies to search the index with it. The algorithm is surprisingly easy:

  1. Originate the first ingredient out of your index - or alternately, a string you admire to be lower than any legit string in your index - and acquire in touch with it the 'most in model' string.
  2. Feed doubtlessly the most in model string into the 'DFA successor' algorithm we outlined above, obtaining the 'next' string.
  3. If the next string is equal to doubtlessly the most in model string, you possess got stumbled on a match - output it, procure the next ingredient from the index as doubtlessly the most in model string, and repeat from step 2.
  4. If the next string will not be equal to doubtlessly the most in model string, search your index for the first string greater than or equal to the next string. Create this the fresh most in model string, and repeat from step 2.

And over yet again, here's the implementation of this diagram in Python:

def find_all_matches(discover, k, lookup_func):
  "http://weblog.notdot.uncover/""Uses lookup_func to procure all phrases inner levenshtein distance k of discover.
    discover: The discover to glimpse up
    k: Most edit distance
    lookup_func: A single argument characteristic that returns the first discover in the
      database that's greater than or equal to the input argument.
    Every matching discover inner levenshtein distance k from the database.
  lev=levenshtein_automata(discover, k).to_dfa()
  whereas match:
    if not next:
    if match==next:
      yield match
      next=next + u''

One manner of taking a glimpse at this algorithm is to evaluate both the Levenshtein DFA and the index as sorted lists, and the diagram above to be same to App Engine's "zigzag merge be part of" device. We usually glimpse up a string on one facet, and reveal that to leap to the suitable put on the assorted facet. If there will not be any matching entry, we reveal the outcomes of the search for to leap ahead on the first facet, etc. The result is that we skip over swish numbers of non-matching index entries, in addition to swish numbers of non-matching Levenshtein strings, saving us the trouble of exhaustively enumerating both of them. Hopefully it be apparrent from the description that this diagram has the capability to lead particular of the need to make a selection into fable both all of the index entries, or all of the candidate Levenshtein strings.

As a facet divulge, it be not staunch that for all DFAs it be doable to procure a lexicographically minimal successor to any string. As an illustration, make a selection into fable the successor to the string 'a' in the DFA that acknowledges the sample 'a+b'. The reply is that there's not if truth be told one: it could per chance probably perhaps make a selection to include a limiteless preference of 'a' characters adopted by a single 'b' character! It is doable to develop a fairly easy modification to the diagram outlined above such that it returns a string that's assured to be a prefix of the next string identified by the DFA, which is enough for our applications. Since Levenshtein DFAs are constantly finite, despite the undeniable fact that, and thus constantly possess a finite length successor (excluding for the closing string, naturally), we leave such an extension as an reveal for the reader. There are doubtlessly full of life gains one can also attach this nearly about, reminiscent of listed customary expression search, which would require this change.


First, let's leer this in chase. We will present an explanation for a easy Matcher class, which presents an implementation of the lookup_func required by our find_all_matches characteristic:

class Matcher(object):
  def __init__(self, l):

  def __call__(self, w):
    self.probes +=1
    pos=bisect.bisect_left(self.l, w)
    if pos 

Note that the only reason we implemented a callable class here is because we want to extract some metrics - specifically, the number of probes made - from the procedure; normally a regular or nested function would be perfectly sufficient. Now, we need a sample dataset. Let's load the web2 dictionary for that:

>>> phrases=[x.strip().lower().decode('utf-8') for x in open('/usr/share/dict/web2')]
>>> phrases.kind()
>>> len(phrases)

We can also moreover reveal about a subsets for testing how things alternate with scale:

>>> phrases10=[x for x in words if random.random()>> words100=[x for x in words if random.random() 

And here it is in action:

>>> m=Matcher(words)
>>> list(automata.find_all_matches('nice', 1, m))
[u'anice', u'bice', u'dice', u'fice', u'ice', u'mice', u'nace', u'nice', u'niche', u'nick', u'nide', u'niece', u'nife', u'nile', u'nine', u'niue', u'pice', u'rice', u'sice', u'tice', u'unice', u'vice', u'wice']
>>> len(_)
>>> m.probes

Working completely! Finding the 23 fuzzy fits for 'tremendous' in the dictionary of almost 235,000 phrases required 142 probes. Existing that if we steal an alphabet of 26 characters, there are 4+26*4+26*5=238 strings inner levenshtein distance 1 of 'tremendous', so we possess made a cheap saving over exhaustively testing all of them. With increased alphabets, longer strings, or increased edit distances, this saving has to be extra pronounced. It goes to be instructive to leer how the preference of probes varies as a characteristic of discover length and dictionary size, by testing it with a range of inputs:

String length Max strings Diminutive dict Med dict Fleshy dict
1 79 47 (59%) 54 (68%) 81 (100%)
2 132 81 (61%) 103 (78%) 129 (97%)
3 185 94 (50%) 120 (64%) 147 (79%)
4 238 94 (39%) 123 (51%) 155 (65%)
5 291 94 (32%) 124 (43%) 161 (55%)

In this table, 'max strings' is the final preference of strings inner edit distance one in all the input string, and the values for puny, med, and elephantine dict symbolize the preference of probes required to search the three dictionaries (consisting of 1%, 10% and 100% of the web2 dictionary). Your whole following rows, a minimal of unless 10 characters, required a same preference of probes as row 5. The sample input string passe consisted of prefixes of the discover 'abracadabra'.

Several observations are valid now apparrent:

  1. For terribly short strings and swish dictionaries, the preference of probes will not be mighty decrease - if in any respect - than doubtlessly the most preference of legit strings, so there's exiguous saving.
  2. Because the string gets longer, the preference of probes required increases enormously slower than the preference of doable outcomes, in command that at 10 characters, we need simplest probe 161 of 821 (about 20%) doable outcomes. At usually encountered discover lengths (97% of phrases in the web2 dictionary are a minimal of 5 characters prolonged), the financial savings over naively checking every string variation are already well-known.
  3. Even supposing the scale of the sample dictionaries differs by an divulge of magnitude, the preference of probes required increases simplest reasonably at any time when. This affords encouraging evidence that this could perhaps scale properly for terribly swish indexes.

It is moreover instructive to leer how this varies for assorted edit distance thresholds. Right here is an identical table, for a max edit distance of two:

String length Max strings Diminutive dict Med dict Fleshy dict
1 2054 413 (20%) 843 (41%) 1531 (75%)
2 10428 486 (5%) 1226 (12%) 2600 (25%)
3 24420 644 (3%) 1643 (7%) 3229 (13%)
4 44030 646 (1.5%) 1676 (4%) 3366 (8%)
5 69258 648 (0.9%) 1676 (2%) 3377 (5%)

Right here is moreover promising: with an edit distance of two, despite the undeniable fact that we're having to attain mighty extra probes, it be a mighty smaller share of the preference of candidate strings. With a discover length of 5 and an edit distance of two, having to attain 3377 probes is certainly some distance preferable to doing 69,258 (one for every matching string) or 234,936 (one for every discover in the dictionary)!

As a transient comparison, a easy BK-tree implementation with the same dictionary requires examining 5858 nodes for a string length of 5 and an edit distance of 1 (with the same sample string passe above), whereas the same search info from with an edit distance of two required 58,928 nodes to be examined! Admittedly, many of these nodes have a tendency to be on the same disk page, if structured properly, but there's composed a startling inequity in the preference of lookups.

One final divulge: The 2nd paper we referenced on this text, [MIHOV2004FAST] describes a very nifty construction: a current Levenshtein automata. Right here's a DFA that determines, in linear time, if any pair of phrases are inner a given mounted Levenshtein distance of every assorted. Adapting the above plan to this near is, moreover, left as an reveal for the reader.

Your whole source code for this text is also stumbled on here.

* Tough proofs of this speculation are welcome.

[SCHULZ2002FAST] Like a flash string correction with Levenshtein automata

[MIHOV2004FAST] Like a flash approximate search in swish dictionaries

28 July, 2010

weblog comments powered by

Read More



β€œSimplicity, patience, compassion.
These three are your greatest treasures.
Simple in actions and thoughts, you return to the source of being.
Patient with both friends and enemies,
you accord with the way things are.
Compassionate toward yourself,
you reconcile all beings in the world.”
― Lao Tzu, Tao Te Ching