Flavio Ferrarotti

A new thesis concerning synchronised parallel computing - simplified parallel ASM thesis

A behavioural theory consists of machine-independent postulates characterizing a particular class of algorithms or systems, an abstract machine model that provably satisfies these postulates, and a rigorous proof that any algorithm or system stipulated by the postulates is captured by the abstract machine model. The class of interest in this article is that of (synchronous) parallel algorithms. For this class a behavioural theory has already been developed by Blass and Gurevich, which unfortunately, though mathematically correct, fails to be convincing, as it is not intuitively clear that the postulates really capture the essence of (synchronous) parallel algorithms.In this article we present a much simpler (and presumably more convincing) set of four postulates for (synchronous) parallel algorithms, which are rather close to those used in Gurevichs celebrated sequential ASM thesis, i.e. the behavioural theory of sequential algorithms. The key difference is made by an extension of the bounded exploration postulate using multiset comprehension terms instead of ground terms formulated over the signature of the states. In addition, all implicit assumptions are made explicit, which amounts to considering states of a parallel algorithm to be represented by meta-finite first-order structures.The article first provides the necessary evidence that the axiomatization presented in this article characterizes indeed the whole class of (synchronous) parallel algorithms, then formally proves that parallel algorithms are captured by Abstract State Machines (ASMs). The proof requires some recourse to methods from finite model theory, by means of which it can be shown that if a critical tuple defines an update in some update set, then also every other tuple that is logically indistinguishable defines an update in that update set.

Distributing a Metric-Space Search Index onto Processors

This paper studies the problem of distributing a metric-space search index based on compact clustering onto a set of distributed memory processors. The aim is enabling efficient similarity search in large-scale Web search engines. The index data structure is composed of a set of clusters enclosing the database objects and we propose distribution methods based on two different solution approaches. The first one makes use of specific knowledge about the work-load generated by user queries. Here the challenge is how to represent and use such a knowledge into a method capable of producing a cluster distribution leading to high performance. The second one follows a novel direction by completely disregarding user behavior to look instead at the relationships among the index clusters themselves to decide their placement onto processors. Both methods perform efficiently depending on the context and they are generic enough to be applied to different distributed index data structures for metric-space databases.

A precious class of cardinality constraints for flexible XML data processing

Modern Web developers must often process collections of XML data that are aggregated from potentially thousands of heterogeneous sources. While the semi-structured nature of XML provides a high degree of syntactic flexibility there are significant shortcomings to specify the semantics of its data. For the advancement of XML applications it is therefore an important problem to identify natural classes of constraints that can be utilized effectively by XML data engineers. The problem is challenging given the range of intractability results in the area. In this paper we propose a class of XML cardinality constraints that is sufficiently flexible to process concisely XML data from various sources. The flexibility is a result of the right balance between expressiveness and efficiency of maintenance. In particular, we characterize the associated implication problem axiomatically, and algorithmically by a low-degree polynomial time decision procedure. Our class is precious as small extensions in expressiveness result in intractability.

A Last-Resort Semantic Cache for Web Queries

We propose a method to evaluate queries using a last-resort semantic cache in a distributed Web search engine. The cache stores a group of frequent queries and for each of these queries it keeps minimal data, that is, the list of machines that produced their answers. The method for evaluating the queries uses the inverse frequency of the terms in the queries stored in the cache ( Idf ) to determine when the results recovered from the cache are a good approximation to the exact answer set. Experiments show that the method is effective and efficient.

Performance analysis of algorithms to reason about XML keys

Keys are fundamental for database management, independently of the particular data model used. In particular, several notions of XML keys have been proposed over the last decade, and their expressiveness and computational properties have been analyzed in theory. In practice, however, expressive notions of XML keys with good reasoning capabilities have been widely ignored. In this paper we present an efficient implementation of an algorithm that decides the implication problem for a tractable and expressive class of XML keys. We also evaluate the performance of the proposed algorithm, demonstrating that reasoning about expressive notions of XML keys can be done efficiently in practice and scales well. Our work indicates that XML keys as those studied here have great potential for diverse areas such as schema design, query optimization, storage and updates, data exchange and integration. To exemplify this potential, we use the algorithm to calculate non-redundant covers for sets of XML keys, and show that these covers can significantly reduce the number of XML keys against which XML documents must be validated. This can result in enormous time savings.

The boyce-codd-heath normal form for SQL

In the relational model of data the Boyce-Codd-Heath normal form, commonly just known as Boyce-Codd normal form, guarantees the elimination of data redundancy in terms of functional dependencies. For efficient means of data processing the industry standard SQL permits partial data and duplicate rows of data to occur in database systems. Consequently, the combined class of uniqueness constraints and functional dependencies is more expressive than the class of functional dependencies itself. Hence, the Boyce-Codd-Heath normal form is not suitable for SQL databases. We characterize the associated implication problem of the combined class in the presence of NOT NULL constraints axiomatically, algorithmically and logically. Based on these results we are able to establish a suitable normal form for SQL.

Reasoning about functional and full hierarchical dependencies over partial relations

We study the implication problem for the combined class of functional and full hierarchical dependencies in the presence of SQLs NOT NULL constraints. Two different notions of implication are addressed: one where a dependency is implied by the given set of dependencies plus the underlying schema, and one where a dependency is implied by the given set of dependencies alone. We establish axiomatizations for both notions of implication, and reveal deep relationships between them.

Evolving concurrent systems: behavioural theory and logic

A concurrent system can be characterised by autonomously acting agents, where each agent executes its own program, uses shared resources and communicates with the others, but otherwise is totally oblivious to the behaviour of the other agents. In an evolving concurrent system agents may change their programs, enter or leave the collection at any time thereby changing the behaviour of the overall system. In this paper we present a behavioural theory of evolving concurrent systems, i.e. we provide (1) a small set of postulates that characterise evolving concurrent systems in a precise conceptual way without any reference to a particular language, (2) an abstract machine model together with a plausibility proof that the abstract machines satisfy the postulates, and (3) a characterisation proof that any system stipulated by the postulates can be step-by-step simulated by an abstract machine. The theory integrates the behavioural theories for unbounded (synchronous) parallel algorithms, asynchronous concurrent systems, and reflective algorithms, respectively. However, in the latter two theories only sequential agents and sequential reflective algorithms were considered. Furthermore, linguistic reflection has not been integrated with parallelism. We will show how these research gaps can be closed. The behavioural theory implies that concurrent reflective Abstract State Machines (crASMs) can be used as a specification and development language for evolving concurrent systems. We therefore investigate a logic for crASMs. Based on the simple observation that concurrent ASMs can be mimicked by non-deterministic parallel ASMs we exploit the complete one-step logic for non-deterministic ASMs for the definition of a logic capturing concurrency. By making the extra-logical rules in the logic subject to being interpreted in a state we extend the logic to capture also reflection.

A Behavioural Theory for Reflective Sequential Algorithms

We develop a behavioural theory of reflective sequential algorithms (RSAs), i.e. algorithms that can modify their own behaviour. The theory comprises a set of language-independent postulates characterising the class of RSAs, an abstract machine model that provably satisfies the postulates, and a proof that all RSAs are captured by this machine model. As in Gurevich’s thesis for sequential algorithms RSAs are sequential-time, bounded parallel algorithms, where the bound depends on the algorithm only and not on the input. Different from the class of sequential algorithms every state of an RSA includes a representation of the algorithm in that state, thus enabling linguistic reflection. The model of reflective Abstract State Machines (rASMs) extends sequential ASMs using extended states that include an updatable representation of the main ASM rule to be executed by the machine in that state.

A Logic for Non-deterministic Parallel Abstract State Machines

We develop a logic which enables reasoning about single steps of non-deterministic parallel Abstract State Machines ASMs. Our logic builds upon the unifying logic introduced by Nanchen and Stark for reasoning about hierarchical parallel ASMs. Our main contribution to this regard is the handling of non-determinism both bounded and unbounded within the logical formalism. Moreover, we do this without sacrificing the completeness of the logic for statements about single steps of non-deterministic parallel ASMs, such as invariants of rules, consistency conditions for rules, or step-by-step equivalence of rules.