user: text: Write a concise one-sentence TLDR summary of the scientific paper content below.

Title: Query2box: Reasoning over Knowledge Graphs in Vector Space Using Box Embeddings

Paper content:
Answering complex logical queries on large-scale incomplete knowledge graphs (KGs) is a fundamental yet challenging task.
Recently, a promising approach to this problem has been to embed KG entities as well as the query into a vector space such that entities that answer the query are embedded close to the query.
However, prior work models queries as single points in the vector space, which is problematic because a complex query represents a potentially large set of its answer entities, but it is unclear how such a set can be represented as a single point.
Furthermore, prior work can only handle queries that use conjunctions ($\wedge$) and existential quantifiers ($\exists$).
Handling queries with logical disjunctions ($\vee$) remains an open problem.
Here we propose query2box, an embedding-based framework for reasoning over arbitrary queries with $\wedge$, $\vee$, and $\exists$ operators in massive and incomplete KGs.
Our main insight is that queries can be embedded as boxes (i.e., hyper-rectangles), where a set of points inside the box corresponds to a set of answer entities of the query.
We show that conjunctions can be naturally represented as intersections of boxes and also prove a negative result that handling disjunctions would require embedding with dimension proportional to the number of KG entities.
However, we show that by transforming queries into a Disjunctive Normal Form, query2box is capable of handling arbitrary logical queries with $\wedge$, $\vee$, $\exists$ in a scalable manner.
We demonstrate the effectiveness of query2box on two large KGs and show that query2box achieves up to 25% relative improvement over the state of the art.
Knowledge graphs (KGs) capture different types of relationships between entities, e.g., Canada citizen −−−−→ Hinton.
Answering arbitrary logical queries, such as "where did Canadian citizens with Turing Award graduate?", over such KGs is a fundamental task in question answering, knowledge base reasoning, as well as AI more broadly.
First-order logical queries can be represented as Directed Acyclic Graphs (DAGs) ( Fig. 1(A) ) and be reasoned according to the DAGs to obtain a set of answers ( Fig. 1(C) ).
While simple and intuitive, such approach has many drawbacks: (1) Computational complexity of subgraph matching is exponential in the query size, and thus cannot scale to modern KGs; (2) Subgraph matching is very sensitive as it cannot correctly answer queries with missing relations.
To remedy (2) one could impute missing relations (Koller et al., 2007; Džeroski, 2009; De Raedt, 2008; Nickel et al., 2016) but that would only make the KG denser, which would further exacerbate issue (1) (Dalvi & Suciu, 2007; Krompaß et al., 2014) .
Recently, a promising alternative approach has emerged, where logical queries as well as KG entities are embedded into a low-dimensional vector space such that entities that answer the query are embedded close to the query (Guu et al., 2015; Hamilton et al., 2018; Das et al., 2017) .
Such approach robustly handles missing relations (Hamilton et al., 2018) and is also orders of magnitude faster, as answering an arbitrary logical query is reduced to simply identifying entities nearest to the embedding of the query in the vector space.
However, prior work embeds a query into a single point in the vector space.
This is problematic because answering a logical query requires modeling a set of active entities while traversing the KG ( Fig. 1(C) ), and how to effectively model a set with a single point is unclear.
Furthermore, it We then obtain query embedding according to the computation graph (B) as a sequence of box operations: start with two nodes TuringAward and Canada and apply Win and Citizen projection operators, followed by an intersection operator (denoted as a shaded intersection of yellow and orange boxes) and another projection operator.
The final embedding of the query is a green box and query's answers are the entities inside the box.
is also unnatural to define logical operators (e.g., set intersection) of two points in the vector space.
Another fundamental limitation of prior work is that it can only handle conjunctive queries, a subset of first-order logic that only involves conjunction (∧) and existential quantifier (∃), but not disjunction (∨).
It remains an open question how to handle disjunction effectively in the vector space.
Here we present QUERY2BOX, an embedding-based framework for reasoning over KGs that is capable of handling arbitrary Existential Positive First-order (EPFO) logical queries (i.e., queries that include any set of ∧, ∨, and ∃) in a scalable manner.
First, to accurately model a set of entities, our key idea is to use a closed region rather than a single point in the vector space.
Specifically, we use a box (axis-aligned hyper-rectangle) to represent a query ( Fig. 1(D) ).
This provides three important benefits: (1) Boxes naturally model sets of entities they enclose; (2) Logical operators (e.g., set intersection) can naturally be defined over boxes similarly as in Venn diagrams (Venn, 1880); (3) Executing logical operators over boxes results in new boxes, which means that the operations are closed; thus, logical reasoning can be efficiently performed in QUERY2BOX by iteratively updating boxes according to the query computation graph ( Fig. 1(B)(D) ).
We show that QUERY2BOX can naturally handle conjunctive queries.
We first prove a negative result that embedding EPFO queries to only single points or boxes is intractable as it would require embedding dimension proportional to the number of KG entities.
However, we provide an elegant solution, where we transform a given EPFO logical query into a Disjunctive Normal Form (DNF) (Davey & Priestley, 2002) , i.e., disjunction of conjunctive queries.
Given any EPFO query, QUERY2BOX represents it as a set of individual boxes, where each box is obtained for each conjunctive query in the DNF.
We then return nearest neighbor entities to any of the boxes as the answers to the query.
This means that to answer any EPFO query we first answer individual conjunctive queries and then take the union of the answer entities.
We evaluate QUERY2BOX on standard KG benchmarks and show: (1) QUERY2BOX provides strong generalization as it can answer complex queries that it has never seen during training; (2) QUERY2BOX is robust as it can answer any EPFO query with high accuracy even when relations involving answering the query are missing in the KG; (3) QUERY2BOX provides up to 25% relative improvement in accuracy of answering EPFO queries over state-of-the-art baselines.
In this paper we proposed a reasoning framework called QUERY2BOX that can effectively model and reason over sets of entities as well as handle EPFO queries in a vector space.
Given a logical query, we first transform it into DNF, embed each conjunctive query into a box, and output entities closest to their nearest boxes.
Our approach is capable of handling all types of EPFO queries scalably and accurately.
Experimental results on standard KGs demonstrate that QUERY2BOX significantly outperforms the existing work in answering diverse logical queries.

assistant: text: Answering a wide class of logical queries over knowledge graphs with box embeddings in vector space