Schema matching is a basic problem in many database application domains, such as data integration, E-business, data warehousing, and semantic query processing. In current implementations, schema matching is typically performed manually, which has significant limitations. On the other hand, previous research papers have proposed many techniques to achieve a partial automation of the match operation for specific application domains. We present a taxonomy that covers many of these existing approaches, and we describe the approaches in some detail. In particular, we distinguish between schema-level and instance-level, element-level and structure-level, and language-based and constraint-based matchers. Based on our classification we review some previous match implementations thereby indicating which part of the solution space they cover. We intend our taxonomy and review of past work to be useful when comparing different approaches to schema matching, when developing a new match algorithm, and when implementing a schema matching component.

/pdf/a-survey-of-approaches-to-automatic-schema-matching-4n2e5qtrpt.pdf

A survey of approaches to automatic schema matching

Social Network Analysis

In this paper we describe the Microsoft COCO Caption dataset and evaluation server. When completed, the dataset will contain over one and a half million captions describing over 330,000 images. For the training and validation images, five independent human generated captions will be provided. To ensure consistency in evaluation of automatic caption generation algorithms, an evaluation server is used. The evaluation server receives candidate captions and scores them using several popular metrics, including BLEU, METEOR, ROUGE and CIDEr. Instructions for using the evaluation server are provided.

/pdf/microsoft-coco-captions-data-collection-and-evaluation-44cn8debz2.pdf

Microsoft COCO Captions: Data Collection and Evaluation Server

We propose a novel formalism, called Frame Logic (abbr., F-logic), that accounts in a clean and declarative fashion for most of the structural aspects of object-oriented and frame-based languages. These features include object identity, complex objects, inheritance, polymorphic types, query methods, encapsulation, and others. In a sense, F-logic stands in the same relationship to the object-oriented paradigm as classical predicate calculus stands to relational programming. F-logic has a model-theoretic semantics and a sound and complete resolution-based proof theory. A small number of fundamental concepts that come from object-oriented programming have direct representation in F-logic; other, secondary aspects of this paradigm are easily modeled as well. The paper also discusses semantic issues pertaining to programming with a deductive object-oriented language based on a subset of F-logic.

/pdf/logical-foundations-of-object-oriented-and-frame-based-2acr2uie5u.pdf

Logical foundations of object-oriented and frame-based languages

Constraint Logic Programming (CLP) is a merger of two declarative paradigms: constraint solving and logic programming. Although a relatively new field, CLP has progressed in several quite different directions. In particular, the early fundamental concepts have been adapted to better serve in different areas of applications. In this survey of CLP, a primary goal is to give a systematic description of the major trends in terms of common fundamental concepts. The three main parts cover the theory, implementation issues, and programming for applications.

Constraint logic programming : A survey

SLD resolution with negation as finite failure (SLDNF) reflects the procedural interpretation of predicate calculus as a programming language and forms the computational basis for Prolog systems. Despite its advantages for stack-based memory management, SLDNF is often not appropriate for query evaluation for three reasons: (a) it may not terminate due to infinite positive recursion; (b) it may be terminate due to infinite recursion through negation; and (c) it may repeatedly evaluate the same literal in a rule body, leading to unacceptable performance.We address all three problems for goal-oriented query evaluation of general logic programs by presenting tabled evaluation with delaying, called SLG resolution. It has three distinctive features:(i) SLG resolution is a partial deduction procedure, consisting of seven fundamental transformations. A query is transformed step by step into a set of answers. The use of transformations separates logical issues of query evaluation from procedural ones. SLG allows an arbitrary computation rule for selecting a literal from a rule body and an arbitrary control strategy for selecting transformations to apply.(ii) SLG resolution is sound and search space complete with respect to the well-founded partial model for all non-floundering queries, and preserves all three-valued stable models. To evaluate a query under differenc three-valued stable models, SLG resolution can be enhanced by further processing of the answers of subgoals relevant to a query.(iii) SLG resolution avoids both positive and negative loops and always terminates for programs with the bounded-term-size property. It has a polynomial time data complexity for well-founded negation of function-free programs. Through a delaying mechanism for handling ground negative literals involved in loops, SLG resolution avoids the repetition of any of its derivation steps.Restricted forms of SLG resolution are identified for definite, locally stratified, and modularly stratified programs, shedding light on the role each transformation plays.

Tabled evaluation with delaying for general logic programs

We describe a novel logic, called HiLog, and show that it provides a more suitable basis for logic programming than does traditional predicate logic. HiLog has a higher-order syntax and allows arbitrary terms to appear in places where predicates, functions, and atomic formulas occur in predicate calculus. But its semantics is first-order and admits a sound and complete proof procedure. Applications of HiLog are discussed, including DCG grammars, higher-order and modular logic programming, and deductive databases.

HILOG: a foundation for higher-order logic programming

This paper describes the XSB system, and its use as an in-memory deductive database engine. XSB began from a Prolog foundation, and traditional Prolog systems are known to have serious deficiencies when used as database systems. Accordingly, XSB has a fundamental bottom-up extension, introduced through tabling (or memoing)[4], which makes it appropriate as an underlying query engine for deductive database systems. Because it eliminates redundant computation, the tabling extension makes XSB able to compute all modularly stratified datalog programs finitely and with polynomial data complexity. For non-stratified programs, a meta-interpreter with the same properties is provided. In addition XSB significantly extends and improves the indexing capabilities over those of standard Prolog. Finally, its syntactic basis in HiLog [2], lends it flexibility for data modelling.The implementation of XSB derives from the WAM [25], the most common Prolog engine. XSB inherits the WAM's efficiency and can take advantage of extensive compiler technology developed for Prolog. As a result, performance comparisons indicate that XSB is significantly faster than other deductive database systems for a wide range of queries and stratified rule sets. XSB is under continuous development, and version 1.3 is available through anonymous ftp.

XSB as an efficient deductive database engine

Interpretation Next we turn to another general area of recent active research in logic programming: abstract interpretation. In the area of declarative languages, the issue of optimization is of prime importance. The most successful example of the implementation of a declarative language is the relational database query language, Structured Query Language (SQL). This is the standard language used to interact with relational databases. It is critically important for the SQL compiler to produce a near optimal way to evaluate whatever query it is given. It is only because such optimization is possible that users are willing to use SQL. For general Horn clause programs, which include recursive definitions and recursive data structures, a comparable global optimization cannot yet (and may never) be achieved. Prolog, with its depth-first backtracking search through the tree of SLD refutations, is a procedural implementation of the declarative Horn clause language. And, as a procedural programming language, it can benefit f rom the kinds o f optimization techniques developed for traditional procedural languages. To perform certain optimizations, the compiler must know certain properties of any execution of the program being processed. For example, any Prolog predicate might be called with any arbitrary set of its parameters given ground values. This multidirectionality is one source of Prolog's power. However, many Prolog predicates are called in only one direction (i.e., in one mode). I f the Prolog compiler knows the mode of a call, it can often use that information to generate more efficient code. Such information depends on global properties of the program and query. One way to gain such information would be to execute, at compile time, the program for all inputs, and then use the information obtained. This direct approach is, of course, infeasible in practice. Any interesting program will have infinitely many computations. Therefore, rather than execute the program at compile time, we \"generalize\" the program to make a new approximate program. The approximate program preserves the structure of the original program but operates on abstract objects (perhaps representing sets of objects) rather than the concrete objects. Then the abstract program is executed to provide approximate information about all the executions of the original program. This process is called abstract interpretation. One simple example of abstract interpretation that is familiar to everyone is the rule o f signs. Consider a program in a very simple programming language that allows a sequence of assignments, each of which assigns to a variable an expression of plus, minus and times over integers and variables. Consider, for example, the program of Figure 12. Given a set of integer values for the input variables, X and Y, executing this program will generate integer values for the output variables: U, V, W and Z. For example, initializing X = 5 and Y = 6 , the program computes Z = 3 0 , W = 900, U = 9 3 0 , and V = 870. We can extract some information that relates the inputs and outputs of the program by using the rule of signs. We abstract the integers into three sets: 1) negative integers ( ) , 2) zero (0), and 3) positive integers (+). We also denote the whole set of integers by (all). We know how the operators of plus, minus and times operate on these sets o f integers. For example, the product of two positive integers is a positive integer. The abstracted table for times

Memoing for logic programs

The concept of a historical database is introduced as a tool for modeling the dynamic nature of some part of the real world. Just as first-order logic has been shown to be a useful formalism for expressing and understanding the underlying semantics of the relational database model, intensional logic is presented as an analogous formalism for expressing and understanding the temporal semantics involved in a historical database. The various components of the relational model, as extended to include historical relations, are discussed in terms of the model theory for the logic ILs, a variation of the logic IL formulated by Richard Montague. The modal concepts of intensional and extensional data constraints and queries are introduced and contrasted. Finally, the potential application of these ideas to the problem of natural language database querying is discussed.

David S. Warren

Papers

Tabled evaluation with delaying for general logic programs

HILOG: a foundation for higher-order logic programming

XSB as an efficient deductive database engine

Memoing for logic programs

Formal Semantics for Time in Databases.