On Constrained Open-World Probabilistic Databases

TL;DR

This paper addresses the challenge of answering queries in open-world probabilistic databases by introducing constraints to improve precision, proposing algorithms, hardness results, and approximations for different query classes.

Contribution

It introduces a constrained approach to open-world probabilistic databases, enhancing query accuracy and efficiency with new algorithms and complexity analysis.

Findings

Proposed an algorithm for a class of queries.

Established a hardness result for another query class.

Developed an efficient approximation for a broad query class.

Abstract

Increasing amounts of available data have led to a heightened need for representing large-scale probabilistic knowledge bases. One approach is to use a probabilistic database, a model with strong assumptions that allow for efficiently answering many interesting queries. Recent work on open-world probabilistic databases strengthens the semantics of these probabilistic databases by discarding the assumption that any information not present in the data must be false. While intuitive, these semantics are not sufficiently precise to give reasonable answers to queries. We propose overcoming these issues by using constraints to restrict this open world. We provide an algorithm for one class of queries, and establish a basic hardness result for another. Finally, we propose an efficient and tight approximation for a large class of queries.

Tables

Table 1. Table 1 : Comparison of upper bounds for the same query and database with different model assumptions: Closed-World (CW), Open-World (OW), and Constrained Open-World (COW).

Query	CW	OW	COW
$\mathrm{𝐿𝑖𝐿𝐴}\left(x\right),S\left(x\right)$	$0$	$1-{10}^{-290}$	$1-{10}^{-15}$
$\mathrm{𝐿𝑖𝑆𝑝𝑟}\left(x\right),S\left(x\right)$	$0$	$1-{10}^{-191}$	$0.96$

Equations

$$P_{\mathcal{P}}(\omega )=\prod _{t\in \omega }{P}_{\mathcal{P}}(t)\prod _{t\notin \omega }(1-P_{\mathcal{P}}(t))$$

$$\text{ where }{P}_{\mathcal{P}}(t)=\{\begin{array}{ll}p& \text{if }⟨t:p⟩\in \mathcal{P}\\ 0& \text{otherwise}\end{array}$$

$${\mathsf{Q}}_1=\exists x.\exists y.S(x)\wedge CoA(x,y)$$

$$P({\mathsf{Q}}_1)=\sum _{\omega \models {\mathsf{Q}}_1}{P}_{\mathcal{P}}(\omega )$$

$${\mathsf{Q}}_1=S(x),CoA(x,y).$$

$${\underline{P}}_{\mathcal{G}}(\mathsf{Q})=\underset{P\in K_{\mathcal{G}}}{\min }P(\mathsf{Q})$$

$$\bar{p}>\frac{1}{|Tup(R)|}\sum _{⟨t:p⟩\in Tup(R)}p$$

$${\underline{P}}_{\mathcal{G}}^{\Phi }(\mathsf{Q})=\underset{P\in K_{\mathcal{G}}^{\Phi }}{\min }P(\mathsf{Q})$$

$$\forall ⟨t:p⟩\in \mathcal{T}$$

$$\forall ⟨t:p⟩\in \left({\mathcal{P}}^{\prime }\setminus \mathcal{P}\right)\setminus \mathcal{T}$$

$$\forall ⟨t:p⟩\in {\mathcal{P}}^{\prime }\setminus \mathcal{P}:p\in \{0,\lambda \}.$$

$$\underset{c\in \{c_1,\dots c_j\}}{\bigvee }\mathsf{Q}(x/c,y/c_y)$$

$$D(j+1,y/c_y,b)=$$

$$\underset{k\in \{1,\dots ,b\}}{\max }1-D(j,y/c_y,b-k)\cdot A(x/c_{j+1},y/c_y,k).$$

$$M_0=\exists x\exists y\exists z$$

$$\vee \left(R(x,y,z)\wedge W(z)\right)\vee \left(U(x)\wedge V(y)\right)$$

$$\vee \left(U(x)\wedge W(z)\right)\vee \left(V(y)\wedge W(z)\right)$$

$$S_{\mathcal{P},\mathsf{Q}}(X)=P_{\mathcal{P}\cup \{⟨t:\lambda ⟩|t\in X\}}(\mathsf{Q}).$$

$$S_{\mathcal{P},\mathsf{Q}}^{\prime }(X)=P_{\mathcal{P}\cup \{⟨t:\lambda ⟩|t\in X\}}(\mathsf{Q})-P_{\mathcal{P}}(\mathsf{Q}).$$

$$P_{Greedy}(\mathsf{Q})-P_{\mathcal{P}}(\mathsf{Q})\ge (1-\frac{1}{e})({\overline{P}}_{\mathcal{G}}^{\Phi }(\mathsf{Q})-P_{\mathcal{P}}(\mathsf{Q}))$$

$$P_{Greedy}(\mathsf{Q})\le {\overline{P}}_{\mathcal{G}}^{\Phi }(\mathsf{Q})\le \frac{e\cdot P_{Greedy}(\mathsf{Q})-P_{\mathcal{P}}(\mathsf{Q})}{e-1}$$

$$S_{\mathcal{P},\mathsf{Q}}(X\cup \{x\})-S_{\mathcal{P},\mathsf{Q}}(X)$$

$$=P(\neg \alpha \wedge \gamma )$$

$$\ge P(\neg \beta \wedge \gamma )$$

$$=P(\beta \vee \gamma )-P(\beta )$$

$$=S_{\mathcal{P},\mathsf{Q}}(Y\cup \{x\})-S_{\mathcal{P},\mathsf{Q}}(Y)$$

$$\underset{c\in \{c_1,\dots c_j\}}{\bigvee }\mathsf{Q}(x_{i_1}/c,x_{i_2}/c_{i_2},\dots ,x_{i_{|I|}}/c_{i_{|I|}})$$

$$D$$

$$=\underset{k\in \{1,\dots ,b\}}{\max }1-D(j,x_{i_2}/c_{i_2},\dots ,x_{i_{|I|}}/c_{i_{|I|}},b-k)$$

$$\cdot$$

Full text

1 Introduction

An ubiquitous pursuit in the study of knowledge base representation is the search for a model that can represent uncertainty while simultaneously answering interesting queries efficiently. The key underlying challenge is that these goals are at odds with each other. Modelling uncertainty requires additional model complexity. At the same time, the ability to answer meaningful queries usually demands fewer model assumptions. Both of these properties are at odds with the key limiting factor of tractability: success in the first two goals is not nearly as impactful if it is not achieved efficiently. Unfortunately, probabilistic reasoning is often computationally hard, even on databases (Roth, 1996; Dalvi and Suciu, 2012).

One approach towards achieving this goal is to begin with a simple model such a probabilistic database (PDB) (Suciu et al., 2011; Van den Broeck and Suciu, 2017). A PDB models uncertainty, but is inherently simple and makes very strong independence assumptions and closed-world assumptions allowing for tractability on a very large class of queries (Dalvi and Suciu, 2007, 2012). However, PDBs can fall short under non-ideal circumstances, as their semantics are brittle to incomplete knowledge bases (Ceylan et al., 2016).

To bring PDBs closer to the desired goal, Ceylan et al. (2016) propose open-world probabilistic databases (OpenPDB), wherein the semantics of a PDB are strengthened to relax the closed-world assumption. While OpenPDBs maintain a large class of tractable queries, their semantics are so relaxed these queries lose their precision: they model further uncertainty, but in exchange give less useful query answers.

In this work, we aim to overcome these querying challenges, while simultaneously maintaining the degree of uncertainty modeled by OpenPDBs. To achieve this, we propose further strengthening the semantics of OpenPDBs by constraining the mean probability allowed for a relation. These constraints work at the schematic level, meaning no additional per-item information is required. They are practically motivated by knowledge of summary statistics, of how many tuples we expect to be true. A theoretical analysis shows that, despite their simplicity, such constraints fundamentally change the difficulty landscape of queries, leading us to propose a general-purpose approximation scheme.

The rest of the paper is organized as follows: Section 2 provides necessary background on relational logic and PDBs, as well as an introduction to OpenPDBs. Section 3 motivates and introduces our construction for constraining OpenPDBs. Section 4 analyses exact solutions subject to these constraints, providing a class of tractable queries along with an algorithm. It also shows that the problem is in general hard, even in some cases where standard PDB queries are tractable. Section 5 investigates an efficient and provably bounded approximation scheme. Section 6 discusses our findings, and summarizes interesting directions that we leave as open problems.

2 Background

This section provides background and motivation for probabilistic databases and their open-world counterparts. Notation and definitions are adapted from Ceylan et al. (2016).

2.1 Relational Logic and Databases

We now describe necessary background from function-free finite-domain first-order logic. An atom $R(x_{1},x_{2},...,x_{n})$ consists of a predicate $R$ of arity $n$, together with $n$ arguments. These arguments can either be constants or variables. A ground atom is an atom that contains no variables. A formula is a series of atoms combined with conjunctions ($\land$) or disjunctions ($\lor$), and with quantifiers $\forall,\exists$. A substitution $\mathsf{Q}[x/t]$ replaces all occurences of $x$ by $t$ in a formula $\mathsf{Q}$.

A relational vocabulary $\sigma$ is comprised of a set of predicates $\mathcal{R}$ and a domain $\mathcal{D}$. Using the Herbrand semantics (Hinrichs and Genesereth, 2006), the Herbrand base of $\sigma$ is the set of all ground atoms possible given $\mathcal{R}$ and $\mathcal{D}$. A $\sigma$-interpretation $\omega$ is then an assignment of truth values to every element of the Herbrand base of $\sigma$. We say that $\omega$ models a formula $\mathsf{Q}$ whenever $\omega$ satisfies $\mathsf{Q}$. This is denoted by $\omega\models\mathsf{Q}$.

A reasonable starting point for the target knowledge base to construct would be to use a traditional relational database. Using the standard model-theoretic view (Abiteboul et al., 1995), a relational database for a vocabulary $\sigma$ is a $\sigma$-interpretation $\omega$. Less formally, a relational database consists of a series of relations, each of which corresponds to a predicate. Each relation consists of a series of rows, also called tuples, each of which corresponds to an atom of the predicate being true. Any atom not appearing as a row in the relation is considered to be false, following the closed-world assumption (Reiter, 1981). Figure 1 shows an example database.

2.2 Probabilistic Databases

Despite the success of relational databases, their deterministic nature leads to a few shortcomings. A common way to gather a large knowledge base is to apply some sort of statistical model (Carlson et al., 2010; Suchanek et al., 2007; Peters et al., 2014; Dong et al., 2014) which returns a probability value for potential tuples. Adapting the output of such a model to a relational database involves thresholding on the probability value, discarding valuable information along the way. A probabilistic database (PDB) circumvents this problem by assigning each tuple a probability.

Definition 1**.**

A (tuple-independent) probabilistic database $\mathcal{P}$ for a vocabulary $\sigma$ is a finite set of tuples of the form $\langle{t:p}\rangle$ where $t$ is a $\sigma$-atom and $p\in[0,1]$. Furthermore, each $t$ can appear at most once.

Given such a collection of tuples and their probabilities, we are now going to define a distribution over relational databases. The semantics of this distribution are given by treating each tuple as an independent random variable.

Definition 2**.**

A probabilistic database $\mathcal{P}$ for vocabulary $\sigma$ induces a probability distribution over $\sigma$-interpretations $\omega$:

[TABLE]

Notice this last statement is again making the closed-world assumption: any tuple that we have no information about is assigned probability zero. Figure 2 shows an example PDB.

Probabilistic Queries

In relational databases, the fundamental task we are interested in solving is how to answer queries. The same is true for probabilistic databases, with the only difference being that we are now interested in probabilities over queries. In particular, we are interested in queries that are fully quantified - also known as Boolean queries. On a relational database, this corresponds to a query that has an answer of True or False.

For example, on the database given in Figure 1, we might ask if there is a scientist who is a coauthor:

[TABLE]

If we instead asked this query of the probabilistic database in Figure 2, we would be computing the probability by summing over the worlds in which the query is true:

[TABLE]

Queries of this form that are a conjunction of atoms are called conjunctive queries. They are commonly shortened as:

[TABLE]

A disjunction of conjunctive queries is known as a union of conjunctive queries (UCQ). UCQs have been shown to live in a dichotomy of efficient evaluation (Dalvi and Suciu, 2012): computing the probability of a UCQ is either polynomial in the size of the database, or it is $\#P$-hard. This property can be checked through the syntax of a query, and we say that a UCQ is safe if it admits efficient evaluation. In the literature of probabilistic databases (Suciu et al., 2011; Dalvi and Suciu, 2012), as well as throughout the rest of this paper, UCQs are the primary query object studied.

2.3 Open-World Probabilistic Databases

In the context of automatically constructing a knowledge base, as is done in for example NELL (Carlson et al., 2010) or Google’s Knowledge Vault (Dong et al., 2014), making the closed-world assumption is conceptually unreasonable. Conversely, it is also not feasible to include all possible tuples and their probabilities in the knowledge base. The resulting difficulty is that there are an enormous number of probabilistic facts that can be scraped from the internet, and by definition these tools will keep only those with the very highest probability. As a result, knowledge bases like NELL (Carlson et al., 2010), PaleoDeepDive (Peters et al., 2014), and YAGO (Suchanek et al., 2007) consist almost entirely of probabilities above $0.95$. This tells us that the knowledge base we are looking at is fundamentally incomplete. In response to this problem, Ceylan et al. (2016) propose the notion of a completion for a probabilistic database.

Definition 3**.**

A $\lambda$-completion of a probabilistic database $\mathcal{P}$ is another probabilistic database obtained as follows. For each atom $t$ that does not appear in $\mathcal{P}$, we add tuple $\langle{t:p}\rangle$ to $\mathcal{P}$ for some $p\in[0,\lambda]$.

Then, we can define the open world of possible databases in terms of the set of distributions induced by all completions.

Definition 4**.**

An open-world probabilistic database (OpenPDB) is a pair $\mathcal{G}=(\mathcal{P},\lambda)$, where $\mathcal{P}$ is a probabilistic database and $\lambda\in[0,1]$. $\mathcal{G}$ induces a set of probability distributions $K_{\mathcal{G}}$ such that a distribution P belongs to $K_{\mathcal{G}}$ iff P is induced by some $\lambda$-completion of probabilistic database $\mathcal{P}$.

Open-World Queries

OpenPDBs specify a set of probability distributions rather than a single one, meaning that a given query produces a set of possible probabilities rather than a single one. We focus on computing the minimum and maximum possible probability values that can be achieved by completing the database.

Definition 5**.**

The probability interval of a Boolean query $\mathsf{Q}$ in OpenPDB $\mathcal{G}$ is $K_{\mathcal{G}}(\mathsf{Q})=[\underline{P}_{\mathcal{G}}(\mathsf{Q}),\overline{P}_{\mathcal{G}}(\mathsf{Q})]$, where

[TABLE]

In general, computing the probability interval for some first-order $\mathsf{Q}$ is not tractable. As observed in Ceylan et al. (2016), however, the situation is different for UCQ queries, because they are monotone (they contain no negations). For UCQs, the upper and lower bounds are given respectively by the full completion (where all unknown probabilities are $\lambda$), and the closed world database. This is a direct result of the fact that OpenPDBs form a credal set: a closed convex set of probability measures, meaning that probability bounds always come from extreme points (Cozman, 2000). Furthermore, Ceylan et al. (2016) also provide an algorithm for efficiently computing this upper bound corresponding to a full completion, and show that it works whenever the UCQ is safe.

3 Mean-Constrained Completions

This section motivates the need to strengthen the OpenPDB semantics, and introduces our novel probabilistic data model.

3.1 Motivation

The ability to perform efficient query evaluation provides an appealing case for OpenPDBs. They give a more reasonable semantics, better matching their use, and for a large class of queries they come at no extra cost in comparison to traditional PDBs. However, in practice computing an upper bound in this way tends to give results very close to $1$. Intuitively, this makes sense: our upper bound comes from simultaneously assuming that every possible missing atom has some reasonable probability. While such a bound is easy to compute, it is too strong of a relaxation of the closed-world assumption.

The crux of this issue is that OpenPDBs consider every possible circumstance for unknown tuples: even ones that are clearly unreasonable. For example, suppose that a table in our database describes whether or not a person is a scientist. The OpenPDB model considers the possibility that every person it knows nothing about has a nontrivial probability of being a scientist - this will clearly return nonsensical query results as we know that fewer than 1% of the population are scientists.

In order to consider a restricted subset of completions representing reasonable situations, we propose directly incorporating these summary statistics. Specifically, we place constraints on the overall probability of a relation across the entire population. In the scientist example, our model only considers completions in which the total probability mass of people being scientists totals less than 1%. This allows us to include more information at the schema level, without having more information about each individual.

To illustrate the effect this has, consider a schema in which we have 3 relations: $\mathit{LiLA}(x)$ denoting whether one lives in Los Angeles, $\mathit{LiSpr}(x)$ denoting whether one lives in Springfield, and $S(x)$ denoting whether one is a scientist. Using a vocabulary of 500 people where each person is present in at most one relation, Table 1 shows the resulting upper probability bound under different model assumptions, where the constrained open-world restricts at most $50\%$ of mass on $\mathit{LiLA}$, $5\%$ on $S$, and $0.5\%$ on $\mathit{LiSpr}$. In particular, notice how extreme the difference is in upper bound with and without constraints being imposed. The closed-world probability of both of these queries is always 0, as each person in our database only has a known probability for at most one relation. It is clear that of these three options, the constrained open-world is the most reasonable – the rest of this section formalizes this idea and investigates the resulting properties.

3.2 Formalization

We begin here by defining mean based constraints, before examining some immediate observations about the structure of the resulting constrained database.

Definition 6**.**

Suppose we have a PDB $\mathcal{P}$, and let $\mathit{Tup}(R)\subseteq\mathcal{P}$ be the set of probabilistic tuples in relation $R$. Let $\bar{p}$ be a probability threshold. Then a mean tuple probability constraint (MTP constraint) $\varphi$ is a linear constraint of the form

[TABLE]

Definition 7**.**

We say that a $\lambda$-completion is $\varphi$-constrained if the $\lambda$-completed database satisfies MTP $\varphi$. If it satisfies all of $\Phi=(\varphi_{1},\varphi_{2},...,\varphi_{n})$, then we say it is $\Phi$-constrained.

Being $\varphi$-constrained is not a property of OpenPDBs, but of their PDB completions. Hence, we are interested in the subset of completions that satisfy this property.

Definition 8**.**

An OpenPDB $\mathcal{G}=(\mathcal{P},\lambda)$ together with MTP constraints $\Phi$ induces a set of probability distributions $K_{\mathcal{G}}^{\Phi}$ , where distribution P belongs to $K_{\mathcal{G}}^{\Phi}$ iff P is induced by some $\Phi$-constrained $\lambda$-completion of $\mathcal{P}$.

Much like with standard OpenPDBs, for a Boolean query $\mathsf{Q}$ we are interested in computing bounds on $P(\mathsf{Q})$.

Definition 9**.**

The probability interval of a Boolean query $\mathsf{Q}$ in OpenPDB $\mathcal{G}$ with MTP constraints $\Phi$ is $K_{\mathcal{G}}^{\Phi}(\mathsf{Q})=[\underline{P}_{\mathcal{G}}^{\Phi}(\mathsf{Q}),\overline{P}_{\mathcal{G}}^{\Phi}(\mathsf{Q})]$, where

[TABLE]

3.3 Completion Properties

A necessary property of OpenPDBs for efficient query evaluation is that they are credal – this is what allows us to consider only a finite subset of possible completions. MTP-constrained OpenPDBs maintain this property.111Proofs of all theorems and lemmas are given in the appendix

Proposition 1**.**

Suppose we have an OpenPDB $\mathcal{G}$ together with MTP constraints $\Phi$. Then the induced set of probability distributions $K_{\mathcal{G}}^{\Phi}$ is credal.

This property allows us to examine only a finite subset of configurations when looking at potential completions, since query probability bounds of a credal set are always achieved at points of extrema (Cozman, 2000). Next, we would like to characterize these points of extrema, by showing that the number of tuples not on their own individual boundaries (that is, [math] or $\lambda$) is given by the number of MTP constraints.

Theorem 2**.**

Suppose we have an OpenPDB $\mathcal{G}=(\mathcal{P},\lambda)$ with MTP constraints $\Phi$, and a UCQ $Q$. If $\mathcal{P}^{\prime}$ is a $\Phi$-constrained $\lambda$-completion satisfying $K_{\mathcal{G}}^{\Phi}(\mathsf{Q})=[P_{\mathcal{P}}(\mathsf{Q}),P_{\mathcal{P}^{\prime}}(\mathsf{Q})]$, there exist completed tuples $\mathcal{T}\subseteq\mathcal{P}^{\prime}\setminus\mathcal{P}$ with $|\mathcal{T}|\leq|\Phi|$ such that

[TABLE]

That is, our upper bound is given by a completion that has at most $|\Phi|$ added tuples with probability not exactly [math] or $\lambda$. Intuitively, each MTP constraint contributes a single non-boundary tuple, which can be thought of as the “leftover” probability mass once the rest has been assigned in full.

This insight allows us to treat MTP query evaluation as a combinatorial optimization problem for the rest of this paper. Thus, we only consider the case where achieving the mean tuple probability exactly leaves us with every individual tuple at its boundary. To see that we can do this, we observe that Theorem 2 leaves a single tuple per MTP constraint not necessarily on the boundary. But this tuple can always be forced to be on the boundary by very slightly increasing the mean $\bar{p}$ of the constraint, as follows.

Corollary 3**.**

Suppose we have an OpenPDB $\mathcal{G}=(\mathcal{P},\lambda)$ with MTP constraints $\Phi$, and a UCQ $\mathsf{Q}$. Suppose further that each relation in $\mathcal{G}$ has at most $1$ constraint in $\Phi$, and that each constraint allows adding open-world probability mass exactly divisible by $\lambda$. Then if $\mathcal{P}^{\prime}$ is a $\Phi$-constrained $\lambda$-completion of $\mathcal{P}$ with $K_{\mathcal{G}}^{\Phi}(\mathsf{Q})=[P_{\mathcal{P}}(\mathsf{Q}),P_{\mathcal{P}^{\prime}}(\mathsf{Q})]$, we have

[TABLE]

Our investigation into the algorithmic properties of MTP query evaluation will be focused on constraining a single relation, subject to a single combinatorial budget constraint.

4 Exact MTP Query Evaluation

With Section 3 formalizing MTP constraints and showing that computing upper bounds subject to MTP constraints is a combinatorial problem of choosing which $\lambda$-probability tuples to add in the completion, we now investigate exact solutions.

4.1 An Algorithm for Inversion-Free Queries

We begin by describing a class of queries which admits poly-time evaluation subject to an MTP constraint. We first need to define some syntactic properties of queries.

Definition 10**.**

Let $\mathsf{Q}$ be a conjunctive query, and let $at(x)$ denote the set of relations containing variable $x$. We say that $\mathsf{Q}$ is hierarchical if for any $x,y$, we have either $at(x)\subseteq at(y)$, $at(y)\subseteq at(x)$, or $at(x)\cap at(y)=\emptyset$.

Intuitively, a conjunctive query being hierarchical indicates that it can either be separated into independent parts (the $at(x)\cap at(y)=\emptyset$ case), or there is some variable that appears in every atom. This simple syntactic property is the basis for determining whether query evaluation on a conjunctive query can be done in polynomial time (Dalvi and Suciu, 2007). We can further expand on this definition in the context of UCQs.

Definition 11**.**

A UCQ $\mathsf{Q}$ is inversion-free if each of its conjuncts is hierarchical, and they all share the same hierarchy.222See Jha and Suciu (2011) for a more detailed definition. If $\mathsf{Q}$ is not inversion-free, we say that it has an inversion.

This query class remains tractable under MTP constraints.

Theorem 4**.**

For any inversion-free query $\mathsf{Q}$, evaluating the probability $\overline{P}_{\mathcal{G}}^{\Phi}(\mathsf{Q})$ subject to an MTP constraint is in PTIME.

In order to prove Theorem 4, we provide a polytime algorithm for MTP query evaluation on inversion-free queries. As with OpenPDBs, our algorithm depends on Algorithm 1, the standard lifted inference algorithm for PDBs. Algorithm 1 proceeds in steps recursively processing $\mathsf{Q}$ to compute query probabilities in polynomial time for safe queries (Dalvi and Suciu, 2012). Further details of the algorithm including the necessary preprocessing steps and notation can be found in Dalvi and Suciu (2012) and Gribkoff et al. (2014a).

We now present an algorithm for doing exact MTP query evaluation on inversion-free queries. For brevity, we present the binary case; the general case follows similarly and can be found in appendix. Suppose that we have a probabilistic database $\mathcal{P}$, a domain $T$ of constants denoted $c$, a query $\mathsf{Q}$, and an MTP constraint on relation $R(x,y)$ allowing us to add exactly $B$ tuples with probability $\lambda$. Suppose that $\mathsf{Q}$ immediately reaches Step 5 of Algorithm 1 (other steps will be discussed later), implying that $x$ and $y$ are unique variables in the query. We let $A(c_{x},c_{y},b)$ denote the upper query probability of $\mathsf{Q}(x/c_{x},y/c_{y})$ subject to an MTP constraint allowing budget $b$ on the relevant portion of $R$. That is, $A$ tells us the highest probability we can achieve for a partial assignment given a fixed budget. Observe that we can compute all entries of $A$ using a slight modification of Algorithm 1 where we compute probabilities with and without each added tuple. This will take time polynomial in $|T|$.

Next, we impose an ordering $c_{1},\dots,c_{|T|}$ on the domain. Then we let $D(j,c_{y},b)$ denote the upper query probability of

[TABLE]

with a budget of $b$ on the relevant portions of $R$. Then $D(|T|,c_{y},b)$ considers all possible substitutions in our first index, meaning we have effectively removed a variable. Doing this repeatedly would allow us to perform exact MTP query evaluation. However, $D$ is non-trivial to compute, and cannot be done by simply modifying Algorithm 1. Instead, we observe the following recurrence:

[TABLE]

Intuitively, this recurrence says that since the tuples from each fixed constant are all independent, we do not need to store which budget configuration on the first $j$ constants got us our optimal solution. Thus, when we add the $j+1$th constant, we just need to check each possible value we could assign to our new constant, and see which gives the overall highest probability. This recurrence can be implemented efficiently, yielding a dynamic programming algorithm that runs in time polynomial in the domain size and budget.

Finally, we would like to generalize this algorithm beyond assuming that $\mathsf{Q}$ immediately reaches Step 5 of Algorithm 1. Looking at other cases, we see that Steps 0 and 1 have no effect on this recurrence, and Steps 2 and 4 correspond to multiplicative factors. For a query that reaches Step 3 (inclusion-exclusion), we need to construct such $A$ and $D$ for each term in the inclusion-exclusion sum, and follow the analogous recurrence. Notice that the modified algorithm would only work in the case where we can always pick a common variable for all sub-queries to do dynamic programming on – that is, when the query is inversion-free, as was our assumption.

4.2 Queries with Inversion

We now show that allowing for inversions in safe queries can cause MTP query evaluation to become NP-hard. Interestingly, this means that MTP constraints fundamentally change the difficulty landscape of query evaluation.

To show this, we investigate the following UCQ query.

[TABLE]

A key observation here is that the query $M_{0}$ is a safe UCQ. That is, if we ignore constraints and evaluate it subject to the closed- or open-world semantics, computing the probability of the query would be polynomial in the size of the database. We now show that this is not the case for open-world query evaluation subject to a single MTP constraint on $R$.

Theorem 5**.**

Evaluating the upper query probability bound $\overline{P}_{\mathcal{G}}^{\Phi}(M_{0})$ subject to an MTP constraint $\Phi$ on $R$ is NP-hard.

The full proof of Theorem 5 can be found in appendix, showing a reduction from the NP-complete 3-dimensional matching problem to computing $\overline{P}_{\mathcal{G}}^{\Phi}(M_{0})$ with an MTP constraint on $R$. It uses the following intuitive correspondence.

Definition 12**.**

Let $X,Y,Z$ be finite disjoint sets representing nodes, and let $T\subseteq X\times Y\times Z$ be the set of available hyperedges. Then $M\subseteq T$ is a matching if for any distinct triples $(x_{1},y_{1},z_{1})\in M,(x_{2},y_{2},z_{2})\in M$, we have that $x_{1}\neq x_{2},y_{1}\neq y_{2},z_{1}\neq z_{2}$. The 3-dimensional matching decision problem is to determine for a given $X,Y,Z,T$ and positive integer $k$ if there exists a matching $M$ with $|M|\geq k$.

The set of available tuples for $R$ will correspond to all edges in $T$. Our MTP constraint forces a decision on which subset of $T$ to take and include in the $\lambda$-completion.

However, if we simply queried to maximize $P(R(x,y,z))$, this completion need not correspond to a matching. Instead, we have the conjunct $R(x,y,z)\land U(x)$ which is maximized when each tuple chosen from $R$ has a different $x$ value. Similar conjuncts for $y$ and $z$ ensure that the query is maximized when using distinct $y$ and $z$ values. Putting all of these together ensures that the query probability is maximized when the subset of tuples chosen to complete $R$ form a matching.

Finally, the last part of the query $(U(x)\land V(y))\lor(U(x)\land W(z))\lor(V(y)\land W(z))$ ensures that inference on $M_{0}$ is tractable, but it is unaffected by the choice of tuples in $R$.

5 Approximate MTP Query Evaluation

With Section 4.2 answering definitively that a general-purpose algorithm for evaluating MTP query bounds is unlikely to exist, even when restricted to safe queries, an approximation is the logical next step. We now restrict our discussion to situations where we constrain a single relation, and dig deeper into the properties of MTP constraints to show their submodular structure. We then exploit this property to achieve efficient bounds with guarantees.

5.1 On the Submodularity of Adding Tuples

To formally define and prove the submodular structure of the problem, we analyze query evaluation as a set function on adding tuples. We begin with a few relevant definitions.

Definition 13**.**

Suppose that we have an OpenPDB $\mathcal{G}$, with an MTP constraint $\varphi$ on a single relation $R$, and we let $\mathbf{O}$ be the set of possible tuples we can add to $R$. Then the set query probability function $S_{\mathcal{P},\mathsf{Q}}:2^{\mathbf{O}}\to[0,1]$ is defined as

[TABLE]

Intuitively, this function describes the probability of the query as a function of which open tuples have been added. It provides a way to reason about the combinatorial properties of this optimization problem. Observe that $S_{\mathcal{P},\mathsf{Q}}(\emptyset)$ is the closed-world probability of the query, while $S_{\mathcal{P},\mathsf{Q}}(\mathbf{O})$ is the open-world probability.

We want to show that $S_{\mathcal{P},\mathsf{Q}}$ is a submodular set function.

Definition 14**.**

A submodular set function is a function $f:2^{\Omega}\to\mathbb{R}$ such that for every $X\subseteq Y\subseteq\Omega$, and every $x\in\Omega\setminus Y$, we have that $f(X\cup\{x\})-f(X)\geq f(Y\cup\{x\})-f(Y)$.

Theorem 6**.**

The set query probability function $S_{\mathcal{P},\mathsf{Q}}$ is submodular for any tuple independent probabilistic database $\mathcal{P}$ and UCQ query $\mathsf{Q}$ without self-joins.

This gives us the desired submodularity property, which we can exploit to build efficient approximation algorithms.

5.2 From Submodularity to Approximation

Given the knowledge that the probability of a safe query without self-joins is submodular in the completion of a single relation, we are now tasked with using this to construct an efficient approximation. Since we further know the probability is also monotone as we have restricted our language to UCQs, Nemhauser et al. (1978) tells us that we can get a $1-\frac{1}{e}$ approximation using a simple greedy algorithm. The final requirement to achieve the approximation described in Nemhauser et al. (1978) is that our set function must have the property that $f(\emptyset)=0$. This can be achieved in a straightforward manner as follows.

Definition 15**.**

In the context of the set query probability function of Definition 13, the normalized set query probability function $S^{\prime}_{\mathcal{P},\mathsf{Q}}:2^{\mathbf{O}}\to[0,1]$ is defined as

[TABLE]

Proposition 7**.**

Any normalized set query probability function $S^{\prime}_{\mathcal{P},\mathsf{Q}}$ is monotone, submodular, and satifies $S^{\prime}_{\mathcal{P},\mathsf{Q}}(\emptyset)=0$.

By simply normalizing the set query probability function, we can now directly apply the greedy approximation described in Nemhauser et al. (1978). We slightly modify Algorithm 1 to efficiently compute the next best tuple to add based on the current database, and add it. This is repeated until adding another tuple would violate the MTP constraint. Finally, we say that $P_{\mathit{Greedy}}(\mathsf{Q})$ is the approximation given by this greedy algorithm and recall that the true upper bound is $\overline{P}_{\mathcal{G}}^{\Phi}(\mathsf{Q})$. We observe that $P_{\mathit{Greedy}}(\mathsf{Q})\leq\overline{P}_{\mathcal{G}}^{\Phi}(\mathsf{Q})$. Furthermore, Nemhauser et al. (1978) tells us the following:

[TABLE]

Combining these and multiplying through gives us the following upper and lower bound on the desired probability.

[TABLE]

It should be noted that depending on the query and database, it is possible for this upper bound to exceed $1$.

6 Discussion, Future & Related Work

We propose the novel problem of constraining open-world probabilistic databases at the schema level, without having any additional ground information over individuals. We introduced a formal mechanism for doing this, by limiting the mean tuple probability allowed in any given completion, and then sought to compute bounds subject to these constraints. We now discuss remaining open problems and related work.

Section 4 showed that there exists a query that is NP-hard to compute exactly, and also presented a tractable algorithm for a class of inversion-free queries. The question remains how hard the other queries are - in particular, is the algorithm presented complete. Is there a complexity dichotomy, that is, a set of syntactic properties that determine the hardness of a query subject to MTP constraints. Questions of this form are a central object of study in probabilistic databases. It has been explored for conjunctive queries (Dalvi and Suciu, 2007), UCQs (Dalvi and Suciu, 2012), and a more general class of queries with negation (Fink and Olteanu, 2016).

The central goal of our work is to find stronger semantics based on OpenPDBs, while still maintaining their desirable tractability. This notion of achieving a powerful semantics while maintaining tractability is a common topic of study. Raedt and Kimmig (2015) study this problem by using a probabilistic interpretation of logic programs to define a model, leading to powerful semantics but a more limited scope of tractability (Fierens et al., 2015). The description logics (Nardi et al., 2003) is a knowledge representation formalism that can be used as the basis for a semantics. This is implemented in a probabilistic setting in, for example, probabilistic ontologies (Riguzzi et al., 2012, 2015), probabilistic description logics (Heinsohn, 1994), probabilistic description logic programs (Lukasiewicz, 2005), or the bayesian description logics (Ceylan and Peñaloza, 2014).

Probabilistic databases in particular are of interest due to their simplicity and practicality. Foundational work defines a few types of probabilistic semantics, and provides efficient algorithms as well as when they can be applied (Dalvi and Suciu, 2004, 2007, 2012). These algorithms along with practical improvements are implemented as industrial level systems such as MystiQ (Ré and Suciu, 2008), SPROUT (Olteanu et al., 2009), MayBMS (Huang et al., 2009), and Trio which implements the closely related Uncertainty-Lineage Databases (Benjelloun et al., 2007). Problems outside of simple query evaluation are also points of interest for PDBs, for example the most probable database (Gribkoff et al., 2014b), or of ranking the top-k results (Ré et al., 2007). In the context of OpenPDBs in particular, Grohe and Lindner (2018) study the notion of an infinite open world, using techniques from analysis to explore when this is feasible.

Acknowledgements

The authors thank Yitao Liang and YooJung Choi for helpful feedback. This work is partially supported by NSF grants #IIS1657613, #IIS-1633857, #CCF-1837129, DARPA XAI grant #N66001-17-2-4032, NEC Research and a gift from Intel.

Appendix A Proofs of Theorems, Lemmas, and Propositions

A.1 Proof of Proposition 1

Proof.

To prove this, we need to show that $K_{\mathcal{G}}^{\Phi}$ is both closed and convex.

Due to the way our constraints are defined, we know that $K_{\mathcal{G}}^{\Phi}=K_{\mathcal{G}}\cap K^{\Phi}$, where $K^{\Phi}$ is the set of all completions satisfying $\Phi$ (but not necessarily having all tuple probabilities $\leq\lambda$). We already know that $K_{\mathcal{G}}$ is credal, and thus closed and convex. $K^{\Phi}$ is a half-space, which we also know is closed and convex. The intersection of closed spaces is closed, and the intersection of convex spaces is convex, so $K_{\mathcal{G}}^{\Phi}$ is credal. ∎

A.2 Proof of Theorem 2

Proof.

Since $K_{\mathcal{G}}^{\Phi}$ is credal, we are interested here in determining the point of extrema of $K_{\mathcal{G}}^{\Phi}$, as this will tell us precisely which completions can represent boundaries.

Consider the construction of the set $K_{\mathcal{G}}^{\Phi}$, and suppose that there are $d$ possible open-world tuples, meaning that $K_{\mathcal{G}}^{\Phi}\subseteq\mathbb{R}^{d}$. As we observed in the proof of Theorem 1, $K_{\mathcal{G}}^{\Phi}=K_{\mathcal{G}}\cap K^{\Phi}$, where $K^{\Phi}$ is the set of all completions satisfying $\Phi$. We now make three key observations about these sets:

Each individual possible open-world tuple is described by the intersection of 2 half-spaces: that is, the tuple on dimension $i$ is described by $x_{i}\geq 0$ and $x_{i}\leq\lambda$. $K_{\mathcal{G}}$ is the intersection of all $2d$ of these half-spaces. 2. 2.

For any individual open-world tuple, the boundaries of the two half-spaces that describe it cannot intersect each other. 3. 3.

An MTP constraint is a linear constraint, and thus can be described by a single half-space. So $K^{\Phi}$ is described by the intersection of these $|\Phi|$ half-spaces.

Observations 1 and 3, together with Lemma 10 tells us that any point of extrema of $K_{\mathcal{G}}^{\Phi}$ must be given by the intersection of the boundaries of at least $d$ of the half-spaces that form $K_{\mathcal{G}}^{\Phi}$. Observation 3 tells us that at most $|\Phi|$ of these half-spaces come from MTP constraints, leaving the boundaries of at least $d-|\Phi|$ half-spaces which come from $K_{\mathcal{G}}$. Finally, observation 2 tells us that each of these $d-|\Phi|$ half-spaces is describing a different open world tuple. But this means we must have at least $d-|\Phi|$ tuples which lie on the boundary of one of their defining half-spaces: they must be either [math] or $\lambda$.

∎

A.3 Proof of Theorem 5

Before we present the formal proof, we state and prove 2 Lemmas we will need.

Lemma 8**.**

Suppose we have two completions $P_{1}$ and $P_{2}$ of $R$, which only differ on a single triple, that is $P_{1}=P_{0}\cup\{x_{1},y_{1},z_{1}\}$ and $P_{2}=P_{0}\cup\{x_{2},y_{2},z_{2}\}$. Further suppose that $y_{1}=y_{2}$, $z_{1}=z_{2}$, and that $P_{0}$ contains no triples with x-value $x_{1}$, but does contain at least 1 triple with x-value $x_{2}$. Then $P_{1}(M_{0})>P_{2}(M_{0})$.

Proof.

We will apply a similar technique here to the one used to prove Theorem 6, where we directly examine $\Delta$, the logical formula found by grounding $M_{0}$. Since $M_{0}$ is a union of conjunctive queries, $\Delta$ must be a DNF. Each conjunct either does not contain $R$, in which case it does not vary with the choice of completion, or it contains it exactly once. Any conjunct containing an atom of $R$ not assigned probability by a completion is logically false.

In order to prove that $P_{1}(M_{0})>P_{2}(M_{0})$, let us compare the ground atoms that result from each. It is clear that the only spot on which they differ is on conjuncts involving $R(x_{1},y_{1},z_{1})$ or $R(x_{2},y_{1},z_{1})$. Any conjuncts involving one of these and $V$ or $W$ will also have an identical effect on the probability of the query, since the completions are identical over $y$ and $z$.

Finally this means we need to compare the term $R(x_{1},y_{1},z_{1}),U(x_{1})$ with the term $R(x_{2},y_{1},z_{1}),U(x_{2})$. Observe that we know $P_{0}$ contains triples with x-value $x_{2}$, which means the term only contributes new probability mass when $U(x_{2})$ is true and none of the other triples involving $x_{2}$ are true. However, $P_{0}$ does not contain any triples with x-value $x_{1}$, so the term $R(x_{1},y_{1},z_{1}),U(x_{1})$ contributes the maximum probability possible. Thus, for any choice of probabilities on $U$ such that $U(x_{2})<1$, we have that $P_{1}(M_{0})>P_{2}(M_{0})$. ∎

Lemma 9**.**

The upper bound $\overline{P}(M_{0})$ is maximized if and only if $P$ is a completion formed by a matching of size $k$, where $k$ is the maximum number of tuples with probability $\lambda$ that can be added to $R$ in $M_{0}$.

Proof.

Observe that if we begin with a completion given by a matching, we can repeatedly apply Lemma 8 to arrive at any completion. Thus a completion given by a matching must have higher probability than any completion not given by a matching. ∎

Finally, we are ready to present the proof of Theorem 5.

Proof.

Suppose we are given an instance of a 3-dimensional matching problem $X,Y,Z,T$ and an integer $k$. Let $U(x),V(y),W(z)$ be $0.8$ wherever $x\in X,y\in Y$, or $z\in Z$ respectively, and 0 everywhere else. Additionally, let $R(x,y,z)$ be unknown for any $(x,y,z)\in T$, and 0 otherwise. Finally, we place an MTP constraint on $R$ ensuring that at most $k$ tuples can be added, and let $\lambda=0.8$. Then Lemma 9 tells us that $M_{0}$ evaluated on this database will be maximized if and only if the completion used corresponds to a matching of size $k$. We determine this probability $P_{max}$ using a standard probabilistic database query algorithm, and fixing $R$ to have entries $0.8$ for some disjoint set of triples.

Finally, we use our oracle for MTP constrained query evaluation to check $\overline{P}(M_{0})$ with the database we constructed from the matching problem. We compare the upper bound given by the oracle, and if it is equal to $P_{max}$, Lemma 9 tells us that a matching of size $k$ does exist. Similarly, if the upper bound given by the oracle is lower than $P_{max}$, Lemma 9 tells us a matching of size $k$ does not exist. ∎

Lemma 10**.**

If $S\subseteq\mathbb{R}^{n}$ is a set formed by the intersection of $k<n$ half-spaces, $S$ has no points of extrema.

Proof.

Written as a set of linear equalities, the solution clearly must have at least 1 degree of freedom. This indicates that for any potential extrema point $x$, one can move in either direction along this degree of freedom to construct an open line intersecting $x$, but entirely contained in $S$. ∎

A.4 Proof of Theorem 6

Proof.

Without directly computing probabilities, let us inspect $\Delta$, the logical formula we get by grounding $\mathsf{Q}$. $\mathsf{Q}$ is a union of conjunctive queries, and thus $\Delta$ is a very large disjunction of conjuncts. Each conjunct can contain our constrained relation $R$ at most once due to the query not having self-joins, and any one of these conjuncts containing an atom of $R$ not assigned any probability is logically false.

Next, to show that $S_{\mathcal{P},\mathsf{Q}}$ is submodular, let $X\subseteq Y\subseteq\mathbf{O}$, and let $x\in\mathbf{O}\setminus Y$ be given. We assign names to the following subformulas of $\Delta$

• –

$\alpha$ ($\beta$) is the disjunction of all conjuncts of $\Delta$ which are not logically false due to missing $R_{B}$ tuples in $X$ ($Y$)

• –

$\gamma$ is the disjunction of all conjuncts of $\Delta$ containing the tuple $x$

Additionally, since $X\subseteq Y$, we also know that $\alpha\Rightarrow\beta$. Now, we make a few observations relating these quantities with our desired values for submodularity:

• –

$S_{\mathcal{P},\mathsf{Q}}(X)=P(\alpha)$

• –

$S_{\mathcal{P},\mathsf{Q}}(Y)=P(\beta)$

• –

$S_{\mathcal{P},\mathsf{Q}}(X\cup\{x\})=P(\alpha\lor\gamma)$

• –

$S_{\mathcal{P},\mathsf{Q}}(Y\cup\{x\})=P(\beta\lor\gamma)$

Finally, we have the following:

[TABLE]

∎

Appendix B General Algorithm for Inversion-Free Queries

We now present an algorithm for doing exact MTP query evaluation on inversion-free queries. Suppose that we have a probabilistic database $\mathcal{P}$, a domain $T$ of constants denoted $c$, a query $\mathsf{Q}$, and an MTP constraint on relation $R(x_{1},x_{2},\dots,x_{r})$ allowing us to add $B$ tuples. For any $I\subseteq\{1,\dots,r\}$, we let $A(x_{i_{1}}/c_{i_{1}},x_{i_{2}}/c_{i_{2}},\dots,x_{i_{|I|}}/c_{i_{|I|}},b)$ denote the upper query probability of $\mathsf{Q}(x_{i_{1}}/c_{i_{1}},x_{i_{2}}/c_{i_{2}},\dots,x_{i_{|I|}}/c_{i_{|I|}})$ subject to an MTP constraint allowing budget $b$ on the relevant portion of $R$. That is, $A$ tells us the highest probability we can achieve for a partial assignment given a fixed budget. Observe that we can compute all entries of $A$ using a slight modification of Algorithm 1. This will take time polynomial in $|T|$.

Next, we impose an ordering $c_{1},c_{2},\dots,c_{|T|}$ on the domain. For any $I\subseteq\{1,\dots,r\}$, we let $D(j,x_{i_{2}}/c_{i_{2}},\dots,x_{i_{|I|}}/c_{i_{|I|}},b)$ denote the upper query probability of

[TABLE]

with a budget of $b$ on the relevant portions of $R$. Then $D(|T|,x_{i_{2}}/c_{i_{2}},\dots,x_{i_{|I|}}/c_{i_{|I|}},b)$ considers all possible substitutions in our first index, meaning we no longer need to worry about it. Doing this repeatedly would allow us to perform exact MTP query evaluation. However, $D$ is non-trivial to compute, and cannot be done by simply modifying Algorithm 1. Instead, we observe the following recurrence:

[TABLE]

Intuitively, this recurrence is saying that since the tuples from each fixed constant are independent of each other, we can add a new constant to our vocabulary by simply considering all combinations of budget assignments. This recurrence can be implemented efficiently, yielding a dynamic programming algorithm that runs in time polynomial in the domain size and budget.

The keen reader will now observe that the above definition and recurrence only make sense if $\mathsf{Q}$ immediately reaches Step 5 of Algorithm 1. While this is true, we see that Steps 0 and 1 have no effect on this recurrence, and Steps 2 and 4 correspond to multiplicative factors. For a query that reaches Step 3: inclusion-exclusion, we indeed need to construct such matrices for each sub-query. Notice that the modified algorithm would only work in the case where we can always pick a common $x_{i}$ for all sub-queries to do dynamic programming on - that is, when the query is inversion-free.