From fce0c20992e6235680b53621cf749fd142f81dd1 Mon Sep 17 00:00:00 2001
From: Marcin Chrzanowski <mc370754@students.mimuw.edu.pl>
Date: Mon, 9 Aug 2021 20:50:02 -0400
Subject: Expand query problems section

---
 mgr.tex | 84 +++++++++++++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 59 insertions(+), 25 deletions(-)

(limited to 'mgr.tex')

diff --git a/mgr.tex b/mgr.tex
index a7bb567..8929626 100644
--- a/mgr.tex
+++ b/mgr.tex
@@ -170,8 +170,34 @@ We note that the converse of this theorem is also true (i.e. that for every tree
 automaton, there is a corresponding MSO formula), however we will use only the
 MSO to automata direction in this work.
 
+\section{Query answering problems}
+
+Consider a computational problem whose inputs are of the form $(S, q) \in
+\mathcal{S} \times Q$ for some set of \definedterm{structures} $\mathcal{S}$ and
+some set of \definedterm{queries} $Q$. This induces a \definedterm{query
+answering problem} which is divided into two phases:
+
+\begin{description}
+    \item[preprocessing] An input structure $S \in \mathcal{S}$ is given and a
+        \definedterm{preprocessing algorithm} outputs an indexing structure
+        $S'$.
+    \item[queries] On-line queries $q_1, \ldots$ from $Q$ about $S$ need to be
+        handled, with access to the preprocessing output $S'$.
+\end{description}
+
+We are interested in the time complexities of both phases. We use the following
+notation for algorithms that have both a preprocessing and query phase: If
+it takes $f(n)$ time to complete the preprocessing step for an input of size
+$n$, and $g(n, m)$ time to then handle a query of size $m$, we say the algorithm
+has time complexity \qptime{$f(n)$}{$g(n, m)$}.
+
+We turn to a discussion of several query problems with known solutions, both to
+serve as examples and because we will be using them in our algorithm.
+
+\subsection{Lowest Common Ancestor}
+
 \queryproblem{%
-    Least Common Ancestor (LCA) Queries
+    Lowest Common Ancestor (LCA) Queries
 }{%
     a tree $T$.
 }{%
@@ -180,23 +206,28 @@ MSO to automata direction in this work.
     ancestor.
 }
 
-\subsection{Range Minimum Query}
-f
-
-\chapter{Branch Infix Regular Queries}\label{r:branchinfix}
+\textcite{tarjan1984} were the first to show an optimal \qptime{$O(n)$}{$O(1)$}
+algorithm for LCA. \textcite{schieber1988} used a similar approach but
+simplified the indexing structure, keeping the same time complexities.
+\textcite{berkman1993} showed a completely new approach to the problem, which
+relies on answering range minimum queries (see below) about an array of properly
+ordered tree vertices. \textcite{bender2000} offer a simpler presentation of the
+algorithm in \cite{berkman1993} and note the equivalence between the LCA and RMQ
+problems.
 
-In this chapter we will present a solution to the following query problem:
+\subsection{Range Minimum Query (RMQ)}
 
-\queryproblem[%
-    regular language $L$ over alphabet $\Sigma$.
-]{Branch Infix Regular Queries}{%
-    a $\Sigma$-labeled tree $T$.
+\queryproblem{Range Minimum Queries}{%
+    an array $A$ of integers.
 }{%
-    given a vertex $x$ and its descendant $y$, does the word given by labels on
-    the path from $x$ to $y$ belong to $L$?
+    given indices $i$ and $j$, return the index of the smallest
+    element in the subarray $A[i, j]$.
 }
 
-\section{Word infix regular queries}
+As mentioned above, \textcite{bender2000} show an \qptime{$O(n)$}{$O(1)$}
+algorithm for the RMQ problem.
+
+\subsection{Word infix regular queries}
 
 \queryproblem[%
     regular language $L$ over alphabet $\Sigma$.
@@ -211,7 +242,7 @@ There is a simple and well-known data structure that, given a fixed automaton
 $A$, preprocesses an input word $w$ in time $O(n)$, and afterwards is able to
 answer in time $O(1)$ questions of the form ``Is the infix $w[i, j]$ accepted by
 $A$?''. We present the full construction as we will be generalizing its
-internals for the tree case.
+internals for the tree case in \Ref{branchinfix}.
 
 Take $A$ that is deterministic. We begin by replacing each letter of $w$ with
 the set of states of $A$, $Q$.
@@ -254,6 +285,19 @@ The construction is as follows:
 Additionally, in each vertex, we store the index of the next copy of $Q$ in
 which the path of this vertex's color is broken by a lower color.
 
+\chapter{Branch Infix Regular Queries}\label{branchinfix}
+
+In this chapter we will present a solution to the following query problem:
+
+\queryproblem[%
+    regular language $L$ over alphabet $\Sigma$.
+]{Branch Infix Regular Queries}{%
+    a $\Sigma$-labeled tree $T$.
+}{%
+    given a vertex $x$ and its descendant $y$, does the word given by labels on
+    the path from $x$ to $y$ belong to $L$?
+}
+
 \section{Generalizing to trees}
 
 We generalize the above construction from regular infix queries on a
@@ -280,17 +324,7 @@ to handle such queries in constant time. The structure is heavily inspired by
 \textcite{bender2000}, where a simple algorithm for computing LCA queries is
 presented.
 
-First, let's define an auxillary problem we will use, that of Range Minimum
-Queries (RMQ):
-
-\queryproblem{Range Minimum Queries}{%
-    an array $A$ of integers.
-}{%
-    given indices $i$ and $j$, return the index of the smallest
-    element in the subarray $A[i, j]$.
-}
-
-Fact: RMQ queries can be answered in constant time after linear preprocessing of
+Recall that RMQ queries can be answered in constant time after linear preprocessing of
 the input array.
 
 We turn to describing the index structure for our tree problem.
-- 
cgit v1.2.3

