From 0dc1a8ea20820168149cedaa14e223d4d31dc4b6 Mon Sep 17 00:00:00 2001
From: "Douglas B. Rumbaugh" <doug@douglasrumbaugh.com>
Date: Sun, 6 Jul 2025 18:21:32 -0400
Subject: updates

---
 chapters/beyond-dsp.tex | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'chapters/beyond-dsp.tex')

diff --git a/chapters/beyond-dsp.tex b/chapters/beyond-dsp.tex
index 9e6adf0..7632261 100644
--- a/chapters/beyond-dsp.tex
+++ b/chapters/beyond-dsp.tex
@@ -3,7 +3,7 @@
 \begin{center}
     \emph{The following chapter is an adaptation of work completed in collaboration with Dr. Dong Xie and Dr. Zhuoyue Zhao
     and published
-    in PVLDB Volume 17, Issue 11 (July 2024) under the title "Towards Systematic Index Dynamization".
+    in PVLDB Volume 17, Issue 11 (July 2024) under the title ``Towards Systematic Index Dynamization''.
     }
     \hrule
 \end{center}
@@ -248,8 +248,8 @@ using the following interface,
         a final query result, $R$.
 \end{itemize}
 
-Let $P(n)$ be the cost of $\mathbftt{local\_preproc}$, $D(n)$ be
-the cost of $\mathbftt{distribute\_query}$,  $\mathscr{Q}_\ell(n)$
+Let $P(n)$ be the cost of $\mathbftt{local\_preproc}$, $\mathscr{D}(n)$ be
+the cost of $\mathbftt{distribute\_query}$,  $\mathscr{Q}_S(n)$
 be the cost of $\mathbftt{local\_query}$, and $C_e(n)$ be the cost
 $\mathbftt{combine}$. To solve a search problem with this interface
 requires calling $\mathbftt{local\_preproc}$ and $\mathbftt{local\_query}$
@@ -258,12 +258,12 @@ $\mathbftt{combine}$ once. For a Bentley-Saxe dynamization then, with
 $O(\log_2 n)$ blocks, the worst-case cost of answering an eDSP is,
 \begin{equation}
 \label{eqn:edsp-cost}
-O \left( \log_2 n \cdot P(n) + D(n) + \log_2 n \cdot \mathscr{Q}_\ell(n) + C_e(n) \right)
+O \left( \log_2 n \cdot P(n) + \mathscr{D}(n) + \log_2 n \cdot \mathscr{Q}_S(n) + C_e(n) \right)
 \end{equation}
 
 As an example, we'll express IRS using the above interface and
 analyze its complexity to show that the resulting solution is the
-same $\Theta(log^2 n + k)$ cost as the specialized solution from
+same $\Theta(\log^2 n + k)$ cost as the specialized solution from
 Chapter~\ref{chap:sampling}.  We use $\mathbftt{local\_preproc}$
 to determine the number of records on each block falling on the
 interval $[l, u]$ and return this, as well as $i_l$ and $i_u$ as the
@@ -332,8 +332,8 @@ each of these operations in pseudo-code.
     }
 \end{algorithm}
 
-These operations result in $P(n) \in \Theta(\log n)$, $D(n) \in
-\Theta(\log n)$, $\mathscr{Q}(n,k) \in \Theta(k)$, and $C_e(n) \in
+These operations result in $P(n) \in \Theta(\log n)$, $\mathscr{D}(n) \in
+\Theta(\log n)$, $\mathscr{Q}_S(n,k) \in \Theta(k)$, and $C_e(n) \in
 \Theta(1)$. At first glance, it would appear that we arrived at a
 solution with a query cost of $O\left(\log_2^2 n + k\log_2 n\right)$,
 and thus fallen short of our goal. However, Equation~\ref{eqn:edsp-cost}
@@ -455,7 +455,7 @@ following provides an upper bound on the worst-case query complexity of
 an IDSP,
 
 \begin{equation*}
-    O\left(\log_2 n \cdot P(n) + D(n) + R(n) \left(\log_2 n \cdot Q_s(n) +
+    O\left(\log_2 n \cdot P(n) + \mathscr{D}(n) + R(n) \left(\log_2 n \cdot Q_S(n) +
 	       C_e(n)\right)\right)
 \end{equation*}
 
@@ -1147,7 +1147,7 @@ a constant number of times per level (at most once for Bentley-Saxe,
 exactly once for tiering, and at most $s$ times for leveling), and there
 are at most $\log_s n$ levels. Thus, the amortized insertion cost is,
 \begin{equation*}
-    I_a(n) \in \Theta\left(\frac{B(n)}{n} \cdot \log_s n\right)
+    I_A(n) \in \Theta\left(\frac{B(n)}{n} \cdot \log_s n\right)
 \end{equation*}
 for standard search problems. Slightly more efficient solutions are
 possible for merge decomposable search problems based on the cost of
@@ -1319,7 +1319,7 @@ in Section~\ref{ssec:dyn-idsp}, with slight modifications to account for
 the different cost function of buffer querying and preprocessing. The
 cost is,
 \begin{equation*}
-\mathscr{Q}(n) \in O \left(P_B(N_B) + \log_s n \cdot P(n) + D(n) + R(n)\left(
+\mathscr{Q}(n) \in O \left(P_B(N_B) + \log_s n \cdot P(n) + \mathscr{D}(n) + R(n)\left(
     Q_B(n) + \log_s n \cdot Q_s(n) + C_e(n)\right)\right)
 \end{equation*}
 where $P_B(n)$ is the cost of pre-processing the buffer, and $Q_B(n)$ is
@@ -1747,7 +1747,7 @@ standard DDSP, we compare with the Bentley-Saxe Method (\textbf{BSM})\footnote{
     point-lookup directly on the VPTree.
 } and a dynamic data structure for the same search problem called an
 M-tree~\cite{mtree,mtree-impl} (\textbf{MTree}), which is an example of a so-called
-"ball tree" structure that partitions high dimensional space using nodes
+``ball tree'' structure that partitions high dimensional space using nodes
 representing spheres, which are merged and split to maintain balance in
 a manner not unlike a B+tree.  We also consider a static instance of a
 VPTree built over the same set of records (\textbf{VPTree}).  We used
@@ -1875,7 +1875,7 @@ same massive degradation in query performance that PGM's native update
 support does in its own update-optimized configuration.\footnote{
     It's also worth noting that PGM implements tombstone deletes by
     inserting a record with a matching key to the record to be deleted,
-    and a particular "tombstone" value, rather than using a header. This
+    and a particular ``tombstone'' value, rather than using a header. This
     means that it can not support duplicate keys when deletes are used,
     unlike our approach. It also means that the records are smaller,
     which should improve query performance, but we're able to beat it even
-- 
cgit v1.2.3

