19,407 research outputs found
An Algorithm to Compute the Character Access Count Distribution for Pattern Matching Algorithms
We propose a framework for the exact probabilistic
analysis of window-based pattern matching algorithms, such as
Boyer--Moore, Horspool, Backward DAWG Matching, Backward Oracle
Matching, and more. In particular, we develop an algorithm that
efficiently computes the distribution of a pattern matching
algorithm's running time cost (such as the number of text character
accesses) for any given pattern in a random text model. Text models
range from simple uniform models to higher-order Markov models or
hidden Markov models (HMMs). Furthermore, we provide an algorithm to
compute the exact distribution of \emph{differences} in running time
cost of two pattern matching algorithms. Methodologically, we use
extensions of finite automata which we call \emph{deterministic
arithmetic automata} (DAAs) and \emph{probabilistic arithmetic
automata} (PAAs)~\cite{Marschall2008}. Given an algorithm, a
pattern, and a text model, a PAA is constructed from which the
sought distributions can be derived using dynamic programming. To
our knowledge, this is the first time that substring- or
suffix-based pattern matching algorithms are analyzed exactly by
computing the whole distribution of running time cost.
Experimentally, we compare Horspool's algorithm, Backward DAWG
Matching, and Backward Oracle Matching on prototypical patterns of
short length and provide statistics on the size of minimal DAAs for
these computations
Fast, Small and Exact: Infinite-order Language Modelling with Compressed Suffix Trees
Efficient methods for storing and querying are critical for scaling
high-order n-gram language models to large corpora. We propose a language model
based on compressed suffix trees, a representation that is highly compact and
can be easily held in memory, while supporting queries needed in computing
language model probabilities on-the-fly. We present several optimisations which
improve query runtimes up to 2500x, despite only incurring a modest increase in
construction time and memory usage. For large corpora and high Markov orders,
our method is highly competitive with the state-of-the-art KenLM package. It
imposes much lower memory requirements, often by orders of magnitude, and has
runtimes that are either similar (for training) or comparable (for querying).Comment: 14 pages in Transactions of the Association for Computational
Linguistics (TACL) 201
Designing optimal- and fast-on-average pattern matching algorithms
Given a pattern and a text , the speed of a pattern matching algorithm
over with regard to , is the ratio of the length of to the number of
text accesses performed to search into . We first propose a general
method for computing the limit of the expected speed of pattern matching
algorithms, with regard to , over iid texts. Next, we show how to determine
the greatest speed which can be achieved among a large class of algorithms,
altogether with an algorithm running this speed. Since the complexity of this
determination make it impossible to deal with patterns of length greater than
4, we propose a polynomial heuristic. Finally, our approaches are compared with
9 pre-existing pattern matching algorithms from both a theoretical and a
practical point of view, i.e. both in terms of limit expected speed on iid
texts, and in terms of observed average speed on real data. In all cases, the
pre-existing algorithms are outperformed
New Algorithms and Lower Bounds for Sequential-Access Data Compression
This thesis concerns sequential-access data compression, i.e., by algorithms
that read the input one or more times from beginning to end. In one chapter we
consider adaptive prefix coding, for which we must read the input character by
character, outputting each character's self-delimiting codeword before reading
the next one. We show how to encode and decode each character in constant
worst-case time while producing an encoding whose length is worst-case optimal.
In another chapter we consider one-pass compression with memory bounded in
terms of the alphabet size and context length, and prove a nearly tight
tradeoff between the amount of memory we can use and the quality of the
compression we can achieve. In a third chapter we consider compression in the
read/write streams model, which allows us passes and memory both
polylogarithmic in the size of the input. We first show how to achieve
universal compression using only one pass over one stream. We then show that
one stream is not sufficient for achieving good grammar-based compression.
Finally, we show that two streams are necessary and sufficient for achieving
entropy-only bounds.Comment: draft of PhD thesi
- …