In the field of Knowledge Engineering, dissatisfaction with the rapid-prototyping approach has led to a number of more principled methodologies for the construction of knowledgebased systems. Instead of immediately implementing the gathered and interpreted knowledge in a given implementation formalism according to the rapid-prototyping approach, many such methodologies centre around the notion of a conceptual model: an abstract, implementation independent description of the relevant problem solving expertise. A conceptual model should describe the task which is solved by the system and the knowledge which is required by it. Although such conceptual models have often been formulated in an informal way, recent years have seen the advent of formal and operational languages to describe such conceptual models more precisely, and operationally as a means for model evaluation. In this paper, we study a number of such formal and operational languages for specifying conceptual mode...

Ontologies in current computer science parlance are computer based resources that represent agreed domain semantics. Unlike data models, the fundamental asset of ontologies is their relative independence of particular applications, i.e. an ontology consists of relatively generic knowledge that can be reused by different kinds of applications/tasks. The first part of this paper concerns some aspects that help to understand the differences and similarities between ontologies and data models. In the second part we present an ontology engineering framework that supports and favours the genericity of an ontology. We introduce the DOGMA ontology engineering approach that separates “atomic ” conceptual relations from “predicative” domain rules. A DOGMA ontology consists of an ontology base that holds sets of intuitive context-specific conceptual relations and a layer of “relatively generic ” ontological commitments that hold the domain rules. This constitutes what we shall call the double articulation of a DOGMA ontology 1.

This paper introduces the concept of learning agent shell as a new class of tools for rapid development of practical endto-end knowledge-based agents, by domain experts, with limited assistance from knowledge engineers. A learning agent shell consists of a learning and knowledge acquisition engine as well as an inference engine and supports building an agent with a knowledge base consisting of an ontology and a set of problem solving rules. The paper describes a specific learning agent shell and its associated agent building methodology. The process of developing an agent relies on importing ontologies from existing repositories of knowledge, and on teaching the agent how to perform various tasks, in a way that resembles how an expert would teach a human apprentice when solving problems in cooperation. The shell and methodology represent a practical integration of knowledge representation, knowledge acquisition, learning and problem solving. This work is illustrated with an example of developing a hierarchical non-linear planning agent.

which is available at

. The paper describes a novel architecture for image understanding. It is based on acquisition of radiologist knowledge, and combines low-level structure analysis with high-level interpretation of image content, within a task-oriented model. A case based reasoner working on a segment case-base contains the individual image segments. These cases with labels are considered indexes for another case based reasoner working on an organ interpretation case base. Both are Creek type case based reasoners, here operating within a propose-critique -modify task structure. Methods for criticizing suggested interpretations by way of explanation, and how interpretations may be modified, are presented. An example run illustrates the system architecture and its key concepts. 1 Introduction Image understanding has turned out to be a very difficult application task for AI methods. Methods exist that are able to do edge detection, and to some extent object identification, but methods for interp...

input args: (D-SUBSTANCE-CONCEPT D-SUBSTANCE-CONCEPT) predicate: (LAMBDA (X Y) (OR (EQUAL (SLOT-VALUE X (QUOTE NAME)) (SLOT-VALUE Y (QUOTE NAME))) (MEMBER (SLOT-VALUE Y (QUOTE NAME)) (SUBSTANCE-SPECIALIZATIONS (SLOT-VALUE X (QUOTE NAME)))))) name: LESS-ABSTRACT input args: (D-SUBSTANCE-CONCEPT D-SUBSTANCE-CONCEPT) predicate: (LAMBDA (X Y) (OR (EQUAL (SLOT-VALUE X (QUOTE NAME)) (SLOT-VALUE Y (QUOTE NAME))) (MEMBER (SLOT-VALUE X (QUOTE NAME)) (SUBSTANCE-SPECIALIZATIONS (SLOT-VALUE Y (QUOTE NAME)))))) name: ROOT-SPECIALIZATION input args: (D-MEMORY-ROOT D-PROPERTY) output args: (LIST-OF D-MEMORY-NODE) truth table: ROOT-SPECIALIZATION-RELATION indexing relation: T name: NODE-SPECIALIZATION input args: (D-MEMORY-NODE D-VALUE) output args: (LIST-OF D-MEMORY-NODE) truth table: NODE-SPECIALIZATION-RELATION indexing relation: T name: VALUE-SPECIALIZATION input args: (D-VALUE) output args: (LIST-OF D-VALUE) truth table: VALUE-SPECIALIZATION-RELATION name: INDEXING input args: (D-MEMORY-NODE) out...

Reusable problem-solving methods as provided by the PROTÉGÉ-II improve knowledge engineering by allowing developers to design reasoners quickly from pre-existing components. The PROTÉGÉ-II approach allows developers to select methods from a library, and to map the methods to a domain ontology. Still, these methods lack a clear conceptual and formal description that would enable their reuse through matching their competence and assumptions with the available domain knowledge and the given task. KARL is a conceptual and formal knowledge-specification language that provides modeling primitives for specifying problem-solving methods. In this paper, we show how the code and informal descriptions of problem-solving methods in PROTÉGÉ-II can be complemented with the conceptual and formal method definitions in KARL. For our case study we choose two methods from the PROTÉGÉ-II framework: chronological backtracking and a task-specific refinement, the board-game method. In addition to the concept...

Abstract not found

Problem-solving methods model the problem-solving behavior of knowledge-based systems. The PROTG-II framework includes a library of problem-solving methods that can be viewed as reusable components. For developers to use these components as building blocks in the construction of methods for new tasks, they must configure the components to fit with each other and with the needs of the new task. As part of this configuration process, developers must relate the ontologies of the generic methods to the ontologies associated with other methods and submethods. We present a model of method configuration that incorporates the use of several ontologies in multiple levels of methods and submethods, and we illustrate the approach by providing examples of the configuration of the board-game method.

This paper presents roles and role models as new abstractions for specifying, modelling, and designing intelligent agent systems. The approach is particularly valuable for applications that involve information and process management because it represents a unified approach. Software agents, objects, processes, organizations, and people can play roles and can therefore be incorporated into a role model. This paper provides an overview of role modelling and describes research at BT that is documenting role model patterns of intelligent agent systems. 1. INTRODUCTION The analysis and design of systems that include intelligent agents, as one type of software engineering, should answer the following questions (along with others): 1. What does this application do ? 2. Should intelligent agents be used in this application ? 3. What does each intelligent agent do ? 4. What goals, responsibilities, tasks, and expertise does each agent have ? 5. How do the intelligent agents interact with each...