More work on adjusting S.3

app_hardness-results.tex

@@ -4,11 +4,11 @@ We use \Cref{lem:qEk-multi-p} to prove \Cref{thm:mult-p-hard-result}:
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \subsection{Proof of Theorem~\ref{thm:mult-p-hard-result}}
 \begin{proof}
-For the sake of contradiction, let us assume we can solve our problem in $f(\kElem)\cdot m^c$ time for some absolute constant $c$. Then given a graph $G$ we can compute the query polynomial or rather, expression tree representation of $\rpoly_G^\kElem$ (in the obvious way) in $O(km)$ time. Then after we run our algorithm on $\rpoly_G^\kElem$, we get $\rpoly_{G}^\kElem(\prob_i,\ldots, \prob_i)$ for $0\leq i\leq 2\kElem$ in additional $f(\kElem)\cdot m^c$ time. \Cref{lem:qEk-multi-p} then computes the number of $k$-matchings in $G$ in $O(\kElem^3)$ time. Thus, overall we have an algorithm for computing the number of $k$-matchings in time
+For the sake of contradiction, let us assume we can solve our problem in $f(\kElem)\cdot m^c$ time for some absolute constant $c$. Given a graph $G$ by \Cref{lem:pdb-for-def-qk} we can compute the \abbrPDB encoding in $\bigO{\numedge}$ time. Then after we run our algorithm on $\rpoly_G^\kElem$, we get $\rpoly_{G}^\kElem(\prob_i,\ldots, \prob_i)$ for $0\leq i\leq 2\kElem$ in additional $\inparen{2k + 1}f(\kElem)\cdot m^c$ time. \Cref{lem:qEk-multi-p} then computes the number of $k$-matchings in $G$ in $O(\kElem^3)$ time. Thus, for $f'(\cdot) = \inparen{2k + 1}\cdot f(\cdot)$, overall we have an algorithm for computing the number of $k$-matchings in time
 \begin{align*}
- O(km) + f(\kElem)\cdot m^c + O(\kElem^3)
-&\le \inparen{O(\kElem^3) + f(\kElem)}\cdot m^{c+1} \\
-&\le \inparen{O(\kElem^3) + f(\kElem)}\cdot n^{2c+2},
+ O(km) + \inparen{2k + 1}\cdot f(\kElem)\cdot m^c + O(\kElem^3)
+&\le \inparen{O(\kElem^3) + f'(\kElem)}\cdot m^{c+1} \\
+&\le \inparen{O(\kElem^3) + f'(\kElem)}\cdot n^{2c+2},
 \end{align*}
 which together with \Cref{thm:k-match-hard} contradicts the conjecture that $\sharpwone$ problems cannot be solved in $f(k)\cdot \numvar^c$ time.
 \qed

circuits-model-runtime.tex

@@ -25,6 +25,7 @@ We now show that this model corresponds to the behavior of a deterministic datab
 %That is for \bis that fulfill this restriction approximating the expectation of results of SPJU queries is only has a constant factor overhead over deterministic query processing (using one of the algorithms for which we prove the claim).
 % with the same complexity as it would take to evaluate the query on a deterministic \emph{bag} database of the same size as the input PDB.
 We adopt a minimalistic compute-bound model of query evaluation drawn from the worst-case optimal join literature~\cite{skew,ngo-survey}.
+
 %
 \noindent\resizebox{1\linewidth}{!}{
 \begin{minipage}{1.0\linewidth}

mult_distinct_p.tex

@@ -77,12 +77,27 @@ Only two relations need be constructed, one for the set $\vset$ and one for the
 \end{proof}
 
 \begin{Lemma}\label{lem:tdet-om}
-For $\query$ defined above, the runtime $\qruntime{\query^k, \dbbase}$ is $O_k(\numedge)$.
+For the $\query^k$ of \Cref{def:qk}, the runtime $\qruntime{\query^k, \dbbase}$ is $O_k(\numedge)$.
 \end{Lemma}
 \begin{proof}[Proof of \Cref{lem:tdet-om}]
-Since by definition, $\dbbase = \cup_{\db \in \idb}\db$, it follows that $\dbbase$ consists of the relations that contain all possible $v \in \vset$ and $e \in \edgeSet$.  Because the result for $\query^1$ cannot be any larger than the relation encoding $\edgeSet$ (i.e., $\abs{\edgeSet}$), it follows that (using an efficient query evaluation strategy such as indexing) the runtime of $\qruntime{\query^1, \dbbase}$ is indeed $O(\numedge)$.  When $k > 1$, since by \Cref{def:qk} $\query^k$ is simply a cross product of the original query $\query^1$, we arrive at the desired runtime of $O_k(\numedge)$.
+By the recursive defintion of $\qruntime{\cdot, \cdot}$ (see \Cref{sec:gen}), we have the following equation for our hard query $\query$ when $k = 1$.
+\begin{equation*}
+\qruntime{\query^1, \dbbase} = \abs{\dbbase.\vset} + \abs{\dbbase.\edgeSet} + \abs{\dbbase.\vset} + \abs{\dbbase.\vset \join \dbbase.\edgeSet \join \dbbase.\vset}
+\end{equation*}
+The quantity $\abs{\dbbase.\vset \join \dbbase.\edgeSet}$ is $\bigO{\numedge}$ by \Cref{def:qk}.  Then by the assumption of \Cref{lem:pdb-for-def-qk} (each $v \in \vset$ has degree $\geq 1$), the sum of the first three terms is $\bigO{\numedge}$.  We then obtain that $\qruntime{\query^1, \dbbase} = \bigO{\numedge} + \bigO{\numedge} = \bigO{\numedge}$.  For $\query^k = \query_1^1 \times\cdots\times\query_k^1$, we have the recurrence $\qruntime{\query^k, \dbbase} = \qruntime{\query_1^1, \dbbase} + \cdots +\qruntime{\query_k^1, \dbbase} + \abs{\query_1^1\join\cdots\join\query_k^1}$.  The dominating term in the sum of the recursive definition is $\abs{\query_1^1\join\cdots\join\query_k^1} = \bigO{\numedge^k} = O_k(\numedge)$.
+%Since by definition, $\dbbase = \cup_{\db \in \idb}\db$, it follows that $\dbbase$ consists of the relations that contain all possible $v \in \vset$ and $e \in \edgeSet$.  Because the result for $\query^1$ cannot be any larger than the relation encoding $\edgeSet$ (i.e., $\abs{\edgeSet}$), it follows that (using an efficient query evaluation strategy such as indexing) the runtime of $\qruntime{\query^1, \dbbase}$ is indeed $O(\numedge)$.  When $k > 1$, since by \Cref{def:qk} $\query^k$ is simply a cross product of the original query $\query^1$, we arrive at the desired runtime of $O_k(\numedge)$.
 \end{proof}
 
+%\begin{Corollary}\label{cor:at-least-kmatch}
+%\end{Corollary}
+%\begin{proof}[Proof of \Cref{cor:at-least-kmatch}
+%\end{proof}
+%
+%\begin{Corollary}\label{cor:best-curr-algo}
+%\end{Corollary}
+%\begin{proof}[Proof of \Cref{cor:best-curr-algo}
+%\end{proof}
+
 \subsection{Multiple Distinct $\prob$ Values}
 \label{sec:multiple-p}
 %Unless otherwise noted, all proofs for this section are in \Cref{app:single-mult-p}.