Peter Thanisch

Natural language interfaces to databases – an introduction

This paper is an introduction to natural language interfaces to databases (NLIDBS). A brief overview of the history of NLIDBS is first given. Some advantages and disadvantages of NLIDBS are then discussed, comparing NLIDBS to formal query languages, form-based interfaces, and graphical interfaces. An introduction to some of the linguistic problems NLIDBS have to confront follows, for the benefit of readers less familiar with computational linguistics. The discussion then moves on to NLIDB architectures, portability issues, restricted natural language input systems (including menu-based NLIDBS), and NLIDBS with reasoning capabilities. Some less explored areas of NLIDB research are then presented, namely database updates, meta-knowledge questions, temporal questions, and multi-modal NLIDBS. The paper ends with reflections on the current state of the art.

Models of machines and computation for mapping in multicomputers

It is now more than a quarter of a century since researchers started publishing papers on mapping strategies for distributing computation across the computation resources of multiprocessor systems. There exists a large body of literature on the subject, but there is no commonly accepted framework whereby results in the field can be compared. Nor is it always easy to assess the relevance of a new result to a particular problem. Furthermore, changes in parallel computing technology have made some of the earlier work of less relevance to current multiprocessor systems. In this paper, versions of the mapping problem are classified, and research in the field is considered in terms of its relevance to the problem of programming currently available hardware in the form of a distributed-memory multiple instruction stream multiple data stream computer: a multicomputer

Constructing OLAP cubes based on queries

An On-Line Analytical Processing (OLAP) user often follows a train of thought, posing a sequence of related queries against the data warehouse. Although their details are not known in advance, the general form of those queries is apparent beforehand. Thus, the user can outline the relevant portion of the data posing generalised queries against a cube representing the data warehouse.Since existing OLAP design methods are not suitable for non-professionals, we present a technique that automates cube design given the data warehouse, functional dependency information, and sample OLAP queries expressed in the general form. The method constructs complete but minimal cubes with low risks related to sparsity and incorrect aggregations. After the user has given queries, the system will suggest a cube design. The user can accept it or improve it by giving more queries. The method is also suitable for improving existing cubes using respective real MDX queries.

Paper: Assigning dependency graphs onto processor networks

This paper addresses the problem of assigning inter-dependent tasks to processing elements in parallel and distributed computers. We consider tasks with non-uniform execution and communication times. We present a new heuristic scheme to assign dependency graphs nonpreemptively. The heuristics are based on satisfying two properties: independent tasks execute on distinct processors and dependent tasks execute on the same processor. The algorithm is based on the so-called depth-first breadth-next (DFBN) search. We show that the time complexity of our scheme is at least one order less compared to other related schemes.

Time, tense and aspect in natural language database interfaces

Most existing Natural Language Database Interfaces (NLDB) were designed to be used with database systems that provide very limited facilities for manipulating time-dependent data, and they do not support adequately temporal linguistic mechanisms (verb tenses, temporal adverbials, temporal subordinate clauses, etc.). The database community is becoming increasingly interested in temporal database systems, which are intended to store and manipulate in a principled manner information not only about the present, but also about the past and future. When interfacing to temporal databases, supporting temporal linguistic mechanisms becomes crucial.We present a framework for constructing Natural Language Interfaces for Temporal Databases (NLTDB), which draws on research in tense and aspect theories, temporal logics and temporal databases. The framework consists of a temporal intermediate representation language, called TOP, an HPSG grammar that maps a wide range of questions involving temporal mechanisms to appropriate TOP expressions, and a provably correct method for translating from TOP to TSQL2, TSQL2 being a recently proposed temporal extension of the SQL database language. This framework was employed to implement a prototype NLTDB.

On the Scope of Applicability of the ETF Algorithm

Superficially, the Earliest Task First (ETF) heuristic [1] is attractive because it models heterogeneous messages passing through a heterogeneous network. On closer inspection, however, this is precisely the set of circumstances that can cause ETF to produce seriously sub-optimal schedules. In this paper we analyze the scope of applicability of ETF. We show that ETF has a good performance if messages are short and the links are fast and a poor performance otherwise. For the first application we choose the Diamond DAG with unit execution time for each task and the multiprocessor system in the form of the fully connected network. We show that ETF partitions the DAG into lines each of which is scheduled on the same processor. The analysis reveals that if the communication times between pairs of adjacent tasks in a precedence relation are all less than or equal to unit then the schedule is optimal. If the communication time is equal to the processing time needed to evaluate a row then the completion time is O(√n) times more than the optimal one for an n×n Diamond DAG. For the second application, we choose the join DAG evaluated by two connected processors.

Normalising OLAP cubes for controlling sparsity

A poorly designed OLAP (on-line analytical processing) cube can have a size much larger than the volume of information, potentially leading to problems with performance and usability. We give a new normal form for OLAP cube design and synthesis and decomposition algorithms to produce normalised OLAP cube schemata. OLAP cube normalisation controls the structural sparsity resulting from inter-dimensional functional dependencies. We assume that functional dependencies are used to describe the constraints of the application universe of discourse. Our methods help the user to identify cube schemata with structural sparsity, and to change the design in order to obtain more economy of space.

Experience Using TSQL2 in a Natural Language Interface

Attempting to use Tsql2 in a natural language interface for temporal databases has focused our attention on certain points in the semantics of Tsql2 where we believe that clarifications or modifications are needed. It has also led us to some extensions to Tsql2 that seem generally useful, regardless of natural language issues.

Linear time algorithm for finding a picture's connected components

Abstract An algorithm that identifies the connnected components of a thresholded digitized picture is presented. The time complexity of the algorithm is linear in the number of runs of object pixels in the picture.

Testing a dependency-preserving decomposition for losslessness

Abstract It is shown that when a decomposition of a relation scheme preserves the associated set of functional dependencies, the problem of testing the decomposition for the lossless join property reduces to the problem of computing the closures of the relation schemes in the decomposition. As a consequence of this result an efficient algorithm for losslessness is proposed.