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

Structurally Tractable Uncertain Data

Many data management applications must deal with data which is uncertain, incomplete, or noisy. However, on existing uncertain data representations, we cannot tractably perform the important query evaluation tasks of determining query possibility, certainty, or probability: these problems are hard on arbitrary uncertain input instances. We thus ask whether we could restrict the structure of uncertain data so as to guarantee the tractability of exact query evaluation. We present our tractability results for tree and tree-like uncertain data, and a vision for probabilistic rule reasoning. We also study uncertainty about order, proposing a suitable representation, and study uncertain data conditioned by additional observations.Comment: 11 pages, 1 figure, 1 table. To appear in SIGMOD/PODS PhD Symposium 201

Efficient XML Data Management: An Analysis

Abstract. With XML rapidly gaining popularity as the standard for data exchange on the World Wide Web, a variety of XML management systems (XMLMS) are becoming available. The choice of an XMLMS is made difficult by the significant difference in the expressive power of the queries and the performance shown by these XMLMS. Most XMLMS are legacy systems (mostly relational) extended to load, query, and publish data in XML format. A few are native XMLMS and capture all the char-acteristics of XML data representation. This paper looks at expressive power and efficiency of various XMLMS. The performance analysis relies on the testbed provided by XOO7, a benchmark derived from OO7 to capture both data and document characteristics of XML. We present ef-ficiency results for two native XMLMS, an XML-enabled semi-structured data management system and an XML-enabled RDBMS, which em-phasize the need for a delicate balance between the data-centric and document-centric aspects of XML query processing.

XML Reconstruction View Selection in XML Databases: Complexity Analysis and Approximation Scheme

Query evaluation in an XML database requires reconstructing XML subtrees rooted at nodes found by an XML query. Since XML subtree reconstruction can be expensive, one approach to improve query response time is to use reconstruction views - materialized XML subtrees of an XML document, whose nodes are frequently accessed by XML queries. For this approach to be efficient, the principal requirement is a framework for view selection. In this work, we are the first to formalize and study the problem of XML reconstruction view selection. The input is a tree $T$, in which every node $i$ has a size $c_i$ and profit $p_i$, and the size limitation $C$. The target is to find a subset of subtrees rooted at nodes $i_1,\cdots, i_k$ respectively such that $c_{i_1}+\cdots +c_{i_k}\le C$, and $p_{i_1}+\cdots +p_{i_k}$ is maximal. Furthermore, there is no overlap between any two subtrees selected in the solution. We prove that this problem is NP-hard and present a fully polynomial-time approximation scheme (FPTAS) as a solution

Expressive Stream Reasoning with Laser

An increasing number of use cases require a timely extraction of non-trivial knowledge from semantically annotated data streams, especially on the Web and for the Internet of Things (IoT). Often, this extraction requires expressive reasoning, which is challenging to compute on large streams. We propose Laser, a new reasoner that supports a pragmatic, non-trivial fragment of the logic LARS which extends Answer Set Programming (ASP) for streams. At its core, Laser implements a novel evaluation procedure which annotates formulae to avoid the re-computation of duplicates at multiple time points. This procedure, combined with a judicious implementation of the LARS operators, is responsible for significantly better runtimes than the ones of other state-of-the-art systems like C-SPARQL and CQELS, or an implementation of LARS which runs on the ASP solver Clingo. This enables the application of expressive logic-based reasoning to large streams and opens the door to a wider range of stream reasoning use cases.Comment: 19 pages, 5 figures. Extended version of accepted paper at ISWC 201

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

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

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 $\beta$-acyclic queries in time linear in the certificate plus the output size, while for any $\beta$-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.

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

Reasoning about embedded dependencies using inclusion dependencies

The implication problem for the class of embedded dependencies is undecidable. However, this does not imply lackness of a proof procedure as exemplified by the chase algorithm. In this paper we present a complete axiomatization of embedded dependencies that is based on the chase and uses inclusion dependencies and implicit existential quantification in the intermediate steps of deductions