624 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
Online Matrix Completion Through Nuclear Norm Regularisation
It is the main goal of this paper to propose a novel method to perform matrix
completion on-line. Motivated by a wide variety of applications, ranging from
the design of recommender systems to sensor network localization through
seismic data reconstruction, we consider the matrix completion problem when
entries of the matrix of interest are observed gradually. Precisely, we place
ourselves in the situation where the predictive rule should be refined
incrementally, rather than recomputed from scratch each time the sample of
observed entries increases. The extension of existing matrix completion methods
to the sequential prediction context is indeed a major issue in the Big Data
era, and yet little addressed in the literature. The algorithm promoted in this
article builds upon the Soft Impute approach introduced in Mazumder et al.
(2010). The major novelty essentially arises from the use of a randomised
technique for both computing and updating the Singular Value Decomposition
(SVD) involved in the algorithm. Though of disarming simplicity, the method
proposed turns out to be very efficient, while requiring reduced computations.
Several numerical experiments based on real datasets illustrating its
performance are displayed, together with preliminary results giving it a
theoretical basis.Comment: Corrected a typo in the affiliatio
Towards an ASM thesis for reflective sequential algorithms
Starting from Gurevich's thesis for sequential algorithms (the so-called
"sequential ASM thesis"), we propose a characterization of the behaviour of
sequential algorithms enriched with reflection. That is, we present a set of
postulates which we conjecture capture the fundamental properties of reflective
sequential algorithms (RSAs). Then we look at the plausibility of an ASM thesis
for the class of RSAs, defining a model of abstract state machine (which we
call reflective ASM) that we conjecture captures the class of RSAs as defined
by our postulates
An Entailment Relation for Reasoning on the Web
Reasoning on the Web is receiving an increasing attention because of emerging fields such as Web adaption and Semantic Web. Indeed, the advanced functionalities striven for in these fields call for reasoning capabilities. Reasoning on the Web, however, is usually done using existing techniques rarely fitting the Web. As a consequence, additional data processing like data conversion from Web formats (e.g. XML or HTML) into some other formats (e.g. classical logic terms and formulas) is often needed and aspects of the Web (e.g. its inherent inconsistency) are neglected. This article first gives requirements for an entailment tuned to reasoning on the Web. Then, it describes how classical logic’s entailment can be modified so as to enforce these requirements. Finally, it discusses how the proposed entailment can be used in applying logic programming to reasoning on the Web
The tractability frontier of well-designed SPARQL queries
We study the complexity of query evaluation of SPARQL queries. We focus on
the fundamental fragment of well-designed SPARQL restricted to the AND,
OPTIONAL and UNION operators. Our main result is a structural characterisation
of the classes of well-designed queries that can be evaluated in polynomial
time. In particular, we introduce a new notion of width called domination
width, which relies on the well-known notion of treewidth. We show that, under
some complexity theoretic assumptions, the classes of well-designed queries
that can be evaluated in polynomial time are precisely those of bounded
domination width
Context-Free Path Queries on RDF Graphs
Navigational graph queries are an important class of queries that canextract
implicit binary relations over the nodes of input graphs. Most of the
navigational query languages used in the RDF community, e.g. property paths in
W3C SPARQL 1.1 and nested regular expressions in nSPARQL, are based on the
regular expressions. It is known that regular expressions have limited
expressivity; for instance, some natural queries, like same generation-queries,
are not expressible with regular expressions. To overcome this limitation, in
this paper, we present cfSPARQL, an extension of SPARQL query language equipped
with context-free grammars. The cfSPARQL language is strictly more expressive
than property paths and nested expressions. The additional expressivity can be
used for modelling graph similarities, graph summarization and ontology
alignment. Despite the increasing expressivity, we show that cfSPARQL still
enjoys a low computational complexity and can be evaluated efficiently.Comment: 25 page
Beyond Worst-Case Analysis for Joins with Minesweeper
We describe a new algorithm, Minesweeper, that is able to satisfy stronger
runtime guarantees than previous join algorithms (colloquially, `beyond
worst-case guarantees') for data in indexed search trees. Our first
contribution is developing a framework to measure this stronger notion of
complexity, which we call {\it certificate complexity}, that extends notions of
Barbay et al. and Demaine et al.; a certificate is a set of propositional
formulae that certifies that the output is correct. This notion captures a
natural class of join algorithms. In addition, the certificate allows us to
define a strictly stronger notion of runtime complexity than traditional
worst-case guarantees. Our second contribution is to develop a dichotomy
theorem for the certificate-based notion of complexity. Roughly, we show that
Minesweeper evaluates -acyclic queries in time linear in the certificate
plus the output size, while for any -cyclic query there is some instance
that takes superlinear time in the certificate (and for which the output is no
larger than the certificate size). We also extend our certificate-complexity
analysis to queries with bounded treewidth and the triangle query.Comment: [This is the full version of our PODS'2014 paper.
Gyrokinetic studies of core turbulence features in ASDEX Upgrade H-mode plasmas
Gyrokinetic validation studies are crucial in developing confidence in the
model incorporated in numerical simulations and thus improving their predictive
capabilities. As one step in this direction, we simulate an ASDEX Upgrade
discharge with the GENE code, and analyze various fluctuating quantities and
compare them to experimental measurements. The approach taken is the following.
First, linear simulations are performed in order to determine the turbulence
regime. Second, the heat fluxes in nonlinear simulations are matched to
experimental fluxes by varying the logarithmic ion temperature gradient within
the expected experimental error bars. Finally, the dependence of various
quantities with respect to the ion temperature gradient is analyzed in detail.
It is found that density and temperature fluctuations can vary significantly
with small changes in this parameter, thus making comparisons with experiments
very sensitive to uncertainties in the experimental profiles. However,
cross-phases are more robust, indicating that they are better observables for
comparisons between gyrokinetic simulations and experimental measurements
Answering Conjunctive Queries under Updates
We consider the task of enumerating and counting answers to -ary
conjunctive queries against relational databases that may be updated by
inserting or deleting tuples. We exhibit a new notion of q-hierarchical
conjunctive queries and show that these can be maintained efficiently in the
following sense. During a linear time preprocessing phase, we can build a data
structure that enables constant delay enumeration of the query results; and
when the database is updated, we can update the data structure and restart the
enumeration phase within constant time. For the special case of self-join free
conjunctive queries we obtain a dichotomy: if a query is not q-hierarchical,
then query enumeration with sublinear delay and sublinear update time
(and arbitrary preprocessing time) is impossible.
For answering Boolean conjunctive queries and for the more general problem of
counting the number of solutions of k-ary queries we obtain complete
dichotomies: if the query's homomorphic core is q-hierarchical, then size of
the the query result can be computed in linear time and maintained with
constant update time. Otherwise, the size of the query result cannot be
maintained with sublinear update time. All our lower bounds rely on the
OMv-conjecture, a conjecture on the hardness of online matrix-vector
multiplication that has recently emerged in the field of fine-grained
complexity to characterise the hardness of dynamic problems. The lower bound
for the counting problem additionally relies on the orthogonal vectors
conjecture, which in turn is implied by the strong exponential time hypothesis.
By sublinear we mean for some
, where is the size of the active domain of the current
database
Eliminating Recursion from Monadic Datalog Programs on Trees
We study the problem of eliminating recursion from monadic datalog programs
on trees with an infinite set of labels. We show that the boundedness problem,
i.e., determining whether a datalog program is equivalent to some nonrecursive
one is undecidable but the decidability is regained if the descendant relation
is disallowed. Under similar restrictions we obtain decidability of the problem
of equivalence to a given nonrecursive program. We investigate the connection
between these two problems in more detail
- …