Maurizio Lenzerini

LOCAL++: a C++ framework for local search algorithms

We present LOCAL++, an object-oriented framework to be used as a general tool for the development and the implementation of local search algorithms in C++. The framework comprises a hierarchy of abstract template classes, one for each local search technique taken into account (i.e., hill-climbing, simulated annealing, and tabu search). Each class specifies and implements the invariant part of the algorithm built according to the technique, and is supposed to be specialized by a concrete class which implements the problem-dependent part of the algorithm. LOCAL++ comprises also a set of abstract classes for creating new techniques by combining different search techniques and different neighborhood relations. The architecture of LOCAL++ provides a principled method for the solution of combinatorial search problems, and helps the designer deriving a neat conceptual scheme of the application, thus facilitating the development and debugging phases. LOCAL++ proved to be flexible enough for the implementation of the algorithms solving various scheduling problems.

Making Metaquerying Practical for Hi(DL − LiteR) Knowledge Bases

Hi(DL − Lite R ) is a higher-order Description Logic obtained from DL − Lite R by adding metamodeling features, and is equipped with a query language that is able to express higher-order queries. We investigate the problem of answering a particular class of such queries, called instance higher-order queries, posed over Hi(DL − Lite R ) knowledge bases (KBs). The only existing algorithm for this problem is based on the idea of reducing the evaluation of a higher-order query q over a Hi(DL − Lite R ) KB to the evaluation of a union of first-order queries over a DL − Lite R KB, built from q by instantiating its metavariables in all possible ways. Although of polynomial time complexity with respect to the size of the KB, this algorithm turns out to be inefficient in practice. In this paper we present a new algorithm, called Smart Binding Planner (SBP), that compiles Q into a program, that issues a sequence of first-order conjunctive queries, where each query has the goal of providing the bindings for metavariables of the next ones, and the last one completes the process by computing the answers to Q. We also illustrate some experiments showing that, in practice, SBP is significantly more efficient than the previous approach.

International Workshop on Description Logics : Bonn, May 28/29, 1994

ion is a weil known mechanism in reasoning about individuals in concept-based systems. It consists in retrieving all the assertions relevant to a given individual a and collecting them into a single concept. Such concept has the property of being the most specific concept (expressible in the language) such that the individual a is an instance of. For this reason it is generally indicated by MSC(a) (Most Specific Concept). Abstraction, together with subsumption, allows one to perform instance checking. In fact, an algorithm for checking whether A 1= C(a) can work as follows: Step 1. compute MSC(a). Step 2. check whether C subsurnes MSC(a). This algorithm, called Abstraction/Subsumption, has been broadly exploited in actual systems (see [Quantz and Kindermann,1990; Nebel,1990]) . However, the problem of exploiting this algorithm is that, in general, it is not possible to completely fit in the information relevant to an individual into a single concept of the language. Let us clarify this point by means of an example: Let A be the following ABox A = {R(a,a), B(a)}. Now consider the individual a; the abstraction for a in A.ct: returns M SC(a) = Bn3R.B. In MSC(a), the information that the individual related to a is exactly a itself is lost . This fact has an impact on the completeness of the algorithm; for instance the algorithm fails to draw the conclusion that A 1= 3R.3R.B(a). In general, any time an individual is referred more than once in the knowledge base, the connection between the different occurrences may be lost. For this reason, the algorithms for instance checking based on abstraction, for expressive languages, are in general incomplete. Nevertheless, if the language indudes ONE-OF it is possible to make a lostless abstraction. In the previous exampie, if the language is AC& plus ONE-OF instead of AC&, the abstraction for a gives M SC( a) = {a} nB n 3R. {a}, and it is easy to see that the inference A F 3R.3R.B(a) is captured because {a}nBn3R.{a} !; 3R.3R.B holds. In conclusion the use of ONE-OF gives the possibility of doing comptete reasoning using the Abstraction/Subsumption algorithm. 3 Complexity of Reasoning with ONE-OF We start our complexity analisys by showing that when OHE-OF is in use, the reasoning problems involving the ABox have always the same complexity than the ones involving only concepts (which is not the case for AC&, as shown in [Schaerf,1993a]). In order to achieve this result, we present the transformation cl>, from an ABox to a concept, cl> : ABox ~ Concept defined as folIows . Let A be an ABox, Ca concept, and a, b two individuals, then:

Queries, rules and definitions as epistemic statements in concept languages

Concept languages have been studied in order to give a formal account of the basic features of frame-based languages. The focus of research in concept languages was initially on the semantical reconstruction of frame-based systems and the computational complexity of reasoning. More recently, attention has been paid to the formalization of other aspects of frame-based languages, such as non-monotonic reasoning and procedural rules, which are necessary in order to bring concept languages closer to implemented systems. In this paper we discuss the above issues in the framework of concept languages enriched with an epistemic operator. In particular, we show that the epistemic operator both introduces novel features in the language, such as sophisticated query formulation and closed world reasoning, and makes it possible to provide a formal account for some aspects of the existing systems, such as rules and definitions, that cannot be characterized in a standard first-order framework.