Natural Language Parser that can handle syntactic and lexical errors
I assume you already know about dynamic programming parsing, aka chart
parsing. This is usually defined for Context-Free grammars (CFG), but
can be extended to other grammatical formalisms, where it can make
more or less sense, depending on the structural complexity of these
algorithms. There are various papers describing chart parsing for
specific formalisms, particularly in the computational linguistic
literature. One general view of the underlying structure common to all
these algorithms is described in a 1995 paper by Lang, and to be found
in the Grune-Jacobs book, relies on a very simple view of parsing as
an intersection of two languages: the first is the singleton regular
language containing the sentence $w$ to be parsed, and the second being
the language $L$ for which we are given a grammar $G$. The idea is
that a single sentence $w$ can always be read as a FSA (or a regular
grammar) as in the following example for the sentence $abac$
$$q_0 \stackrel{a}\longrightarrow q_1 \stackrel{b}\longrightarrow q_2
\stackrel{a}\longrightarrow q_3 \stackrel{c}\longrightarrow q_f$$

Using this FSA $A_w$ and the grammar $G$ of the language $L$ (assume
first $L$ to be a CF language, and $G$ a CFG), the old cross-product
construction due to Bar-Hillel, Perles and Shamir (1961) to prove
closure of CFL with regulr sets can be used with $A_w$ and $G$, and
yield a new CF grammar $G_w$, which naturally generates only $w$ when
$w\in L$, or the empty language $\emptyset$ when $w\notin L$. The
important point is that, when $w\in L$, the grammar $G_w$ generates
$w$ with exactly the same parse trees as the original grammar $G$, up
to a renaming of non-terminal, though the correspondence between
non-terminals is kept (let us ignore details). In other words, we just
described a parser that yield a parse forest $G_w$ from which all the
parse trees for $w$ can be extracted, simply by using the grammar
$G_w$ as a generator.

As it turns out, the dynamic programming chart parsers are just
optimized variants of this very basic construction called parsing as
intersection.

The nice point about it is that it lends itself to many variations.
Closure under intersection with regular languages is a very common
property, so that this is a guide for producing parsers for a great
variety of formalisms, though it makes effective sense only for those
that have a simple generating structure (loosely). Typically it works
very well for tree adjoining grammars (TAG) an other mildly context
sensitive languages.

Another point is that, rather than parse only strings, one can parse
complete regular sets, keeping only the sentences that are also in the
context-free language. And it is largely compatibles with the many
"optimization" techniques commonly found in chart parsing

This is very important in natural language processing (NLP), and
particularly in speech processing, since the result of the first pass
of speech processor to identify the spoken words is usually not a
single string of words, but what is usually called a word lattice
(see Ambiguity and sharing in Natural Language Parsing, which is
actually the title of an answer to a question).

The interesting point is that a word lattice (see diagram in previous
reference) may be seen as a FSA that recognizes all the candidate
sentences (after noise processing) that could be the sentence to be
parsed. But chart parsing can be applied as well, as can the
intersection construction.

Now, it may well be that the word lattice contains spurious words to
be eliminated, or completely garbled sequences corresponding to
arbitrary number of missing words, or misunderstood words. That can be
modeled as a General Sequential Mapping (GSM) that does some editing
on the input sentence, adding, removing or substituting words,
possibly in a (finite) contextual way. Both regular and context free
languages are preserved by GSM mapping. Typically, the editing GSM can
be applied to the word lattice, yielding a new regual language and its
FSA (possibly even with cycles).  Then the parsing process is applied
to that new FSA.  This part is, I think, what you mainly wanted to
describe in the question.

The next point is that not all proposed sentences, or not all
corrections have the same likelyhood. Actually, word lattices may be
weighted structures that give weights to the corresponding sentences
in proportion to some likelyhood they they are correct.

Then the editing GSM can also have weighted transition corresponding
to some standard likelyhood that such error may have occurred.

Finally, the (CF) grammar of the language itself may be weighted.

The dynamic programming construction can use these weight (possibly
probabilities) to determine what are the most likely parses of the
given input according to the grammar used.

Note that I have been skipping the morphological analysis that
recognizes words, and uses similar techniques to end up with the word
lattice.

I am also skipping the use of attributes or feature structures, that
can combine with the process, provided they meet some algebraic
constraints.

The algebraic constraints (that concern also the numerical weights)
are related to the algebraic structures of the grammars themselves.
Typically, a CF derivation backbone (that is more than CF languages)
relies on semiring structures.

A CF rule such as $X\to VXW | aV$ may be read as an equation of the
 form $X = V\cdot X\cdot W \cup \{a\}\cdot W$ where the wariables take
 their values in sets of sentences (i.e. in languages). The domain of
 languages is a semi-ring under the two operations: Union "$\cup$" and
 concatenation "$\cdot$". And a context-free grammar is a specific kind of equation in that domain.

You should find more on this use of semirings in Goodman's "Parsing Inside-Out 1998.

There are some other references in my answer to the question "Is there a favoured data structure for storing ambiguous parse trees
in Natural Language Processing?"