397 research outputs found
First-Order Query Evaluation with Cardinality Conditions
We study an extension of first-order logic that allows to express cardinality
conditions in a similar way as SQL's COUNT operator. The corresponding logic
FOC(P) was introduced by Kuske and Schweikardt (LICS'17), who showed that query
evaluation for this logic is fixed-parameter tractable on classes of structures
(or databases) of bounded degree. In the present paper, we first show that the
fixed-parameter tractability of FOC(P) cannot even be generalised to very
simple classes of structures of unbounded degree such as unranked trees or
strings with a linear order relation.
Then we identify a fragment FOC1(P) of FOC(P) which is still sufficiently
strong to express standard applications of SQL's COUNT operator. Our main
result shows that query evaluation for FOC1(P) is fixed-parameter tractable
with almost linear running time on nowhere dense classes of structures. As a
corollary, we also obtain a fixed-parameter tractable algorithm for counting
the number of tuples satisfying a query over nowhere dense classes of
structures
First-order query evaluation on structures of bounded degree
We consider the enumeration problem of first-order queries over structures of
bounded degree. It was shown that this problem is in the Constant-Delaylin
class. An enumeration problem belongs to Constant-Delaylin if for an input of
size n it can be solved by: - an O(n) precomputation phase building an index
structure, - followed by a phase enumerating the answers with no repetition and
a constant delay between two consecutive outputs. In this article we give a
different proof of this result based on Gaifman's locality theorem for
first-order logic. Moreover, the constants we obtain yield a total evaluation
time that is triply exponential in the size of the input formula, matching the
complexity of the best known evaluation algorithms
The tractability frontier of graph-like first-order query sets
We study first-order model checking, by which we refer to the problem of deciding whether or not a given first-order sentence is satisfied by a given finite structure. In particular, we aim to understand on which sets of sentences this problem is tractable, in the sense of parameterized complexity theory. To this end, we define the notion of a graph-like sentence set, which definition is inspired by previous work on first-order model checking wherein the permitted connectives and quantifiers were restricted. Our main theorem is the complete tractability classification of such graphlike sentence sets, which is (to our knowledge) the first complexity classification theorem concerning a class of sentences that has no restriction on the connectives and quantifiers. To present and prove our classification, we introduce and develop a novel complexity-theoretic framework which is built on parameterized complexity and includes new notions of reduction
On the first-order rewritability of conjunctive queries over binary guarded existential rules
We study conjunctive query answering and first-order rewritability of conjunctive queries for binary guarded existential rules. In particular, we prove that the problem of establishing whether a given set of binary guarded existential rules is such that all conjunctive queries admit a first-order rewriting is decidable, and present a technique for solving this problem. These results have a important practical impact, since they make it possible to identify those sets of binary guarded existential rules for which it is possible to answer every conjunctive query through query rewriting and standard evaluation of a first-order query (actually, a union of conjunctive queries) over a relational database system
Computing FO-Rewritings in EL in Practice: from Atomic to Conjunctive Queries
A prominent approach to implementing ontology-mediated queries (OMQs) is to
rewrite into a first-order query, which is then executed using a conventional
SQL database system. We consider the case where the ontology is formulated in
the description logic EL and the actual query is a conjunctive query and show
that rewritings of such OMQs can be efficiently computed in practice, in a
sound and complete way. Our approach combines a reduction with a decomposed
backwards chaining algorithm for OMQs that are based on the simpler atomic
queries, also illuminating the relationship between first-order rewritings of
OMQs based on conjunctive and on atomic queries. Experiments with real-world
ontologies show promising results
Updating DL-Lite ontologies through first-order queries
In this paper we study instance-level update in DL-LiteA, the description logic underlying the OWL 2 QL standard. In particular we focus on formula-based approaches to ABox insertion and deletion. We show that DL-LiteA, which is well-known for enjoying first-order rewritability of query answering, enjoys a first-order rewritability property also for updates. That is, every update can be reformulated into a set of insertion and deletion instructions computable through a nonrecursive datalog program. Such a program is readily translatable into a first-order query over the ABox considered as a database, and hence into SQL. By exploiting this result, we implement an update component for DLLiteA-based systems and perform some experiments showing that the approach works in practice.Peer ReviewedPostprint (author's final draft
Towards Characterizing the First-order Query Complexity of Learning (Approximate) Nash Equilibria in Zero-sum Matrix Games
In the first-order query model for zero-sum matrix games, players
observe the expected pay-offs for all their possible actions under the
randomized action played by their opponent. This classical model has received
renewed interest after the discovery by Rakhlin and Sridharan that
-approximate Nash equilibria can be computed efficiently from
instead of queries.
Surprisingly, the optimal number of such queries, as a function of both
and , is not known. We make progress on this question on two
fronts. First, we fully characterise the query complexity of learning exact
equilibria (), by showing that they require a number of queries
that is linear in , which means that it is essentially as hard as querying
the whole matrix, which can also be done with queries. Second, for
, the current query complexity upper bound stands at
. We argue that, unfortunately, obtaining
a matching lower bound is not possible with existing techniques: we prove that
no lower bound can be derived by constructing hard matrices whose entries take
values in a known countable set, because such matrices can be fully identified
by a single query. This rules out, for instance, reducing to an optimization
problem over the hypercube by encoding it as a binary payoff matrix. We then
introduce a new technique for lower bounds, which allows us to obtain lower
bounds of order for any , where is a constant independent of . We further discuss
possible future directions to improve on our techniques in order to close the
gap with the upper bounds
Towards characterizing the first-order query complexity of learning (approximate) Nash equilibria in zero-sum matrix games
In the first-order query model for zero-sum K × K matrix games, players observe the expected pay-offs for all their possible actions under the randomized action played by their opponent. This classical model has received renewed interest after the discovery by Rakhlin and Sridharan that ε-approximate Nash equilibria can be computed efficiently from O(ln K/ε) instead of O(ln K/ε2 ) queries. Surprisingly, the optimal number of such queries, as a function of both ε and K, is not known.We make progress on this question on two fronts. First, we fully characterise the query complexity of learning exact equilibria (ε = 0), by showing that they require a number of queries that is linear in K, which means that it is essentially as hard as querying the whole matrix, which can also be done with K queries. Second, for ε > 0, the current query complexity upper bound stands at O(min(ln(K)/ε, K)). We argue that, unfortunately, obtaining a matching lower bound is not possible with existing techniques: we prove that no lower bound can be derived by constructing hard matrices whose entries take values in a known countable set, because such matrices can be fully identified by a single query. This rules out, for instance, reducing to an optimization problem over the hypercube by encoding it as a binary payoff matrix. We then introduce a new technique for lower bounds, which allows us to obtain lower bounds of order Ω(log( ˜ 1 Kε )) for any ε ⩽ 1/(cK4 ), where c is a constant independent of K. We further discuss possible future directions to improve on our techniques in order to close the gap with the upper bounds
Separating Auxiliary Arity Hierarchy of First-Order Incremental Evaluation Using (3+1)-ary Input Relations
Presents a first-order incremental evaluation system that uses first-order queries to maintain a database view defined by a non-first-order query. Reduction of the arity of queries to understand the power of foies; Use of a key lemma for proving a query which encodes the multiple parity problem
Query Rewriting and Optimization for Ontological Databases
Ontological queries are evaluated against a knowledge base consisting of an
extensional database and an ontology (i.e., a set of logical assertions and
constraints which derive new intensional knowledge from the extensional
database), rather than directly on the extensional database. The evaluation and
optimization of such queries is an intriguing new problem for database
research. In this paper, we discuss two important aspects of this problem:
query rewriting and query optimization. Query rewriting consists of the
compilation of an ontological query into an equivalent first-order query
against the underlying extensional database. We present a novel query rewriting
algorithm for rather general types of ontological constraints which is
well-suited for practical implementations. In particular, we show how a
conjunctive query against a knowledge base, expressed using linear and sticky
existential rules, that is, members of the recently introduced Datalog+/-
family of ontology languages, can be compiled into a union of conjunctive
queries (UCQ) against the underlying database. Ontological query optimization,
in this context, attempts to improve this rewriting process so to produce
possibly small and cost-effective UCQ rewritings for an input query.Comment: arXiv admin note: text overlap with arXiv:1312.5914 by other author
- …