Janis Barzdins

Model transformation language MOLA

The paper describes a new graphical model transformation language MOLA. The basic idea of MOLA is to merge traditional structured programming as a control structure with pattern-based transformation rules. The key language element is a graphical loop concept. The main goal of MOLA is to describe model transformations in a natural and easy readable way.

Databases and information systems

Kazimierz Subieta and Jacek Plodzien Polish-I apanese Institute of Information Technology & Institute of Computer Science PAS, Warsaw, Poland E-mail: {subieta,jpl}@ ipipan.waw.pl We attempt to widen the scope in which object views are typically set, following the paradigms of programming languages rather than traditional database concepts, such as relational/object algebras or calculi. A well-known environment stack is used as a semantic basis for definitions of query operators. In this setting naming, scoping and binding are central issues and a virtual (non-materialised) database view is a stored function. A function output is a structure built upon atomic values, references and names. Such functions perfectly simulate virtual objects and virtual classes. The approach can be coupled with the query modification technique based on macro-substitution. It significantly reduces performance problems related to processing views. The approach is relevant to object query languages such as OQL.

Inductive Inference of Recursive Functions: Complexity Bounds

This survey includes principal results on complexity of inductive inference for recursively enumerable classes of total recursive functions. Inductive inference is a process to find an algorithm from sample computations. In the case when the given class of functions is recursively enumerable it is easy to define a natural complexity measure for the inductive inference, namely, the worst-case mindchange number for the first n functions in the given class. Surely, the complexity depends not only on the class, but also on the numbering, i.e. which function is the first, which one is the second, etc. It turns out that, if the result of inference is Goedel number, then complexity of inference may vary between log2n+o(log2n) and an arbitrarily slow recursive function. If the result of the inference is an index in the numbering of the recursively enumerable class, then the complexity may go up to const·n. Additionally, effects previously found in the Kolmogorov complexity theory are discovered in the complexity of inductive inference as well.

Model transformation languages and their implementation by bootstrapping method

In this paper a sequence of model transformation languages L0, L1, L2 is defined. The first language L0 is very simple, and for this language it is easy to build an efficient compiler to C++. The next language L1 is an extension of L0, and it contains powerful pattern definition facilities. The last language L2 is of sufficiently high level and can be used for implementation of traditional pattern-based high level model transformation languages, as well as for the development of model transformations directly. For languages L1 and L2 efficient compilers have been built using the bootstrapping method: L1 to L0 in L0, and L2 to L1 in L1. The results confirm the efficiency of model transformation approach for domain specific compiler building.

Automatic Construction of Test Sets: Theoretical Approach

We consider the problem of automatic construction of complete test set (CTS) from program text. The completeness criterion adopted is C1, i.e., it is necessary to execute all feasible branches of program at least once on the tests of CTS. A simple programming language is introduced with the property that the values used in conditional statements are not arithmetically deformed. For this language the CTS problem is proved to be algorithmically solvable and CTS construction algorithm is obtained. Some generalizations of this language containing counters, stacks or arrays are considered where the CTS problem remains solvable. In conclusion the applications of the obtained results to CTS construction for real time systems are considered.

Learning with Confidence

Herein we investigate learning in the limit where confidence in the current conjecture accrues with time. Confidence levels are given by rational numbers between 0 and 1. The traditional requirement that for learning in the limit is that a device must converge (in the limit) to a correct answer. We further demand that the associated confidence in the answer (monotonically) approach 1 in the limit. In addition to being a more realistic model of learning, our new notion turns out to be a more powerful as well. In addition, we give precise characterizations of the classes of functions that are learnable in our new model(s).

Towards Efficient Inductive Synthesis of Expressions from Input/Output Examples

Our goal through several years has been the development of efficient search algorithm for inductive inference of expressions using only input/output examples. The idea is to avoid exhaustive search by means of taking full advantage of semantic equality of many considered expressions. This might be the way that people avoid too big search when finding proof strategies for theorems, etc. As a formal model for the development of the method we use arithmetic expressions over the domain of natural numbers. A new approach for using weights associated with the functional symbols for restricting search space is considered. This allows adding constraints like the frequency of particular symbols in the expression. Additionally the current state of the art of computer experiments using this methodology is described. An example that is considered is the inductive inference of the formula for solving quadratic equations, the finding of which by pure exhaustive search would be unrealistic.

Export of Relational Databases to RDF Databases: A Case Study

The vast amount of business information nowadays is stored in relational databases. For the Semantic Web vision to become a reality, we need ways how to exploit this data in form of RDF triples. The universal and commonly accepted solution for this problem still does not exist. In most cases, mapping languages are used for specification of correspondences between OWL ontology and DB schema. At the same time, these languages generally are not well suited for specification of mappings in cases when there is a substantial difference between OWL ontology and DB schema. In this paper, we describe a new model transformation-based method for specification of correspondences between the elements of DB schema and OWL ontology. We also present our experience of using this method in a real world use case and sketch direction of future research.

Towards Open Graphical Tool-Building Framework

Towards Open Graphical Tool-Building Framework Nowadays, there are many frameworks for developing domain-specific tools. However, if we want to create a really sophisticated tool with specific functionality requirements, it is not always an easy task to do. Although tool-building platforms offer some means for extending the tool functionality and accessing it from external applications, it usually requires a deep understanding of various technical implementation details. In this paper we try to go one step closer to a really open graphical tool-building framework that would allow both to change the behavior of the tool and to access the tool from the outside easily. We start by defining a specialization of metamodels which is a great and powerful facility itself. Then we go on and show how this can be applied in the field of graphical domain-specific tool building. The approach is demonstrated on an example of a subset of UML activity diagrams. The benefits of the approach are also clearly indicated. These include a natural and intuitive definition of tools, a strict logic/presentation separation and the openness for extensions as well as for external applications.

Learning Formulae from Elementary Facts

Since the seminal paper by E.M. Gold [Gol67] the computational learning theory community has been presuming that the main problem in the learning theory on the recursion-theoretical level is to restore a grammar from samples of language or a program from its sample computations. However scientists in physics and biology have become accustomed to looking for interesting assertions rather than for a universal theory explaining everything.