arXiv subjects

Simon R. Tarnow

Publications and source records attributed to Simon R. Tarnow.

4 recordsLinked to original sources

arXiv2026

Tighter Bounds for Wheeler Determinization

Given a Wheeler NFA $\mathcal{A}$, the Wheeler determinization problem is to construct a Wheeler DFA $\mathcal{D}$ that accepts the same language as $\mathcal{A}$. We use the notation $n_{\mathcal{A}},m_{\mathcal{A}}$ for the number of vertices and edges of $\mathcal{A}$, and equivalently $n_{\mathcal{D}},m_{\mathcal{D}}$ for $\mathcal{D}$. Alanko et al. [SODA 2020, Inf. Comp. 2021] solve this problem in $O(n_{\mathcal{A}}^3)$ time, by constructing a $\\mathcal{D}$ that always satisfies $n_\mathcal{D}\leq 2n_\mathcal{A} - 1$. In this paper, we show how to improve the running time to $O(n_{\mathcal{A}} + m_{\mathcal{A}} + n_{\mathcal{D}} + m_{\mathcal{D}})$ when the Wheeler order of $\mathcal{A}$ is given. If the Wheeler order is not present, we achieve $O(n_\mathcal{A} + m_\mathcal{A}\log n_\mathcal{A} + n_\mathcal{D} + m_\mathcal{D})$ time by using an algorithm of Becker et al. [ESA 2023]). Our running time is a factor $n_{\mathcal{A}}^2/σ$ faster than the state of the art for sorted inputs, where $σ$ is the size of the alphabet. Furthermore, for $σ=O(1)$ we have the first linear time algorithm for this problem. We show that our bound is tight with any combination of $n_\mathcal{A}$ and $σ$, by giving a family of inputs for which our output $\mathcal{D}$ is minimum, and of maximum size $Θ(n_\mathcal{A}σ)$.

cs.DS↗

arXiv2025

Compressed Dictionary Matching on Run-Length Encoded Strings

Given a set of pattern strings $\mathcal{P}=\{P_1, P_2,\ldots P_k\}$ and a text string $S$, the classic dictionary matching problem is to report all occurrences of each pattern in $S$. We study the dictionary problem in the compressed setting, where the pattern strings and the text string are compressed using run-length encoding, and the goal is to solve the problem without decompression and achieve efficient time and space in the size of the compressed strings. Let $m$ and $n$ be the total length of the patterns $\mathcal{P}$ and the length of the text string $S$, respectively, and let $\overline{m}$ and $\overline{n}$ be the total number of runs in the run-length encoding of the patterns in $\mathcal{P}$ and $S$, respectively. Our main result is an algorithm that achieves $O( (\overline{m} + \overline{n})\log \log m + \mathrm{occ})$ expected time, and $O(\overline{m})$ space, where $\mathrm{occ}$ is the total number of occurrences of patterns in $S$. This is the first non-trivial solution to the problem. Since any solution must read the input, our time bound is optimal within an $\log \log m$ factor. We introduce several new techniques to achieve our bounds, including a new compressed representation of the classic Aho-Corasick automaton and a new efficient string index that supports fast queries in run-length encoded strings.

cs.DS↗

arXiv2024

Succinct Data Structures for Segments

We consider succinct data structures for representing a set of $n$ horizontal line segments in the plane given in rank space to support \emph{segment access}, \emph{segment selection}, and \emph{segment rank} queries. A segment access query finds the segment $(x_1, x_2, y)$ given its $y$-coordinate ($y$-coordinates of the segments are distinct), a segment selection query finds the $j$th smallest segment (the segment with the $j$th smallest $y$-coordinate) among the segments crossing the vertical line for a given $x$-coordinate, and a segment rank query finds the number of segments crossing the vertical line through $x$-coordinate $i$ with $y$-coordinate at most $y$, for a given $x$ and $y$. This problem is a central component in compressed data structures for persistent strings supporting random access. Our main result is data structure using $2n\lg{n} + O(n\lg{n}/\lg{\lg{n}})$ bits of space and $O(\lg{n}/\lg{\lg{n}})$ query time for all operations. We show that this space bound is optimal up to lower-order terms. We will also show that the query time for segment rank is optimal. The query time for segment selection is also optimal by a previous bound. To obtain our results, we present a novel segment wavelet tree data structure of independent interest. This structure is inspired by and extends the classic wavelet tree for sequences. This leads to a simple, succinct solution with $O(\log n)$ query times. We then extend this solution to obtain optimal query time. Our space lower bound follows from a simple counting argument, and our lower bound for segment rank is obtained by a reduction from 2-dimensional counting.

cs.DS↗

arXiv2022

Hierarchical Relative Lempel-Ziv Compression

Relative Lempel-Ziv (RLZ) parsing is a dictionary compression method in which a string $S$ is compressed relative to a second string $R$ (called the reference) by parsing $S$ into a sequence of substrings that occur in $R$. RLZ is particularly effective at compressing sets of strings that have a high degree of similarity to the reference string, such as a set of genomes of individuals from the same species. With the now cheap cost of DNA sequencing, such data sets have become extremely abundant and are rapidly growing. In this paper, instead of using a single reference string for the entire collection, we investigate the use of different reference strings for subsets of the collection, with the aim of improving compression. In particular, we form a rooted tree (or hierarchy) on the strings and then compressed each string using RLZ with parent as reference, storing only the root of the tree in plain text. To decompress, we traverse the tree in BFS order starting at the root, decompressing children with respect to their parent. We show that this approach leads to a twofold improvement in compression on bacterial genome data sets, with negligible effect on decompression time compared to the standard single reference approach. We show that an effective hierarchy for a given set of strings can be constructed by computing the optimal arborescence of a completed weighted digraph of the strings, with weights as the number of phrases in the RLZ parsing of the source and destination vertices. We further show that instead of computing the complete graph, a sparse graph derived using locality sensitive hashing can significantly reduce the cost of computing a good hierarchy, without adversely effecting compression performance.

cs.DS↗