Conceptual Structures for Knowledge Engineering and ... - CiteSeerX

3 downloads 6791 Views 37KB Size Report
Email: [email protected] ... Email: [email protected] .... This framework is based on the DEsign and Specification of Interacting .... where a catalogue enumerating all the permitted basic templates (comparable to the.
Conceptual Structures for Knowledge Engineering and Knowledge Modelling Dickson Lukose1, Guy Mineau2, Marie-Laure Mugnier3, Jens-Uwe Möller4, Philippe Martin5, Rob Kremer6 and Gian Piero Zarri7 1 Department

of Mathematics, Statistics and Computing Science, University of New England, Armidale, N.S.W., 2350, AUSTRALIA. Email: [email protected]

2 Department

of Computer Science, Université Laval, Quebec City, Quebec, CANADA, G1K 7P4 Email: [email protected] 3

4

5

LIRMM (CNRS et Université Montpellier II), FRANCE. Email: [email protected]

Natural Language Systems Division, Department of Computer Science, University of Hamburg, Vogt-Koelln-Str. 30, D-22527 Hamburg, GERMANY. Email: [email protected]

INRIA-ACACIA Project, 2004, route des Lucioles - BP 93, 06902 Sophia Antipolis, Cedex, FRANCE. Email: [email protected] 6

Knowledge Science Institute, University of Calgary, Calgary, Alberta, CANADA T2N 1N4. Email: [email protected] 7 Centre

National de la Recherche Scientifique, EHESS - CAMS, 54, Boulevard Raspail, 75270 PARIS Cedex 06, FRANCE. Email: [email protected] Abstract

This paper outlines the result of the discussions that took place at the Ninth Knowledge Acquisition Workshop in Banff, Canada, in February 1995 (KAW'95). The authors attempt to summarise the current efforts in using the Conceptual Graphs (CGs) for knowledge acquisition and modelling expertise. The work on CGKAT, [KADS]->(ON)->[CG], CG-DESIRE, and MODEL-ECS are briefly outlined. In addition to this, a list of limitations as seen by the Knowledge Acquisition Community is outlined, together with a list of requirements that is specifically solicited by the KA-Community to enable them to actively utilise CG as a modelling and representation formalism for building knowledge-based systems. We further outlined how and where CG could make effective contributions in the areas of knowledge acquisition. Finally, we present the areas of research that is severely lacking and the future work to be carried out, in particular, work on evaluation of the methodologies, systems, and tools using CG for knowledge acquisition and modelling.

1. Introduction This paper outlines the result of the discussions that have taken place at the Ninth Knowledge Acquisition Workshop in Banff, Canada, in February 1995 (KAW'95). D. Lukose and M-L. Mugnier co-chaired a track entitled Knowledge Acquisition using Conceptual Graphs (CG-Track), with G. Mineau presenting his paper at the Shareable and Reusable Ontologies track. There were forty five papers presented at KAW'95, upon which four of the papers were from the CG-Track. In total, eight papers were submitted to the CG-Track. After the paper review process, we accepted six, but only four were presented for one reason or the other. KAW'95 was a five day workshop, with paper presentation from every track taking place in the mornings of the first three days, while track discussions taking place in the afternoons and the fourth day, with poster reception: posters,

videos and demonstrations in the first two evenings. The papers presented in the CG-Track outline some of the current work on knowledge modelling and knowledge engineering using conceptual graphs, while the topic of discussion in the track discussion session was to answer the question: Why conceptual graphs are still not (or seldom) used by knowledge engineer for building large scale knowledge based systems. There were over a dozen participants in this track discussion. Among the participants are A. Rappaport, D. Bourigault, D. Skuce, F. Gomez, G. Boy, and J-G. Ganascia, just to name a few. In this paper we attempt to summarise the outcome of this discussion. In brief, the content of this paper is as follows. We will first outline our objective for organising the CG-Track, and a brief outline of the papers presented in this track. This will be followed with a discussion on a list of requirements put forward by the knowledge and requirements engineering community to be met by conceptual graphs for it to be liberally adopted for knowledge modelling and representation in the development of large scale knowledge based systems. We then review the conventional system development processes and determine how and where conceptual graphs are able to make the most contributions. Finally, we conclude this paper with an outline of the future work to be carried out by the participants of the CG-Track.

2. Objectives and Current Efforts Our main objective for organising the CG-Track at Banff (KAW'95) was to present some of the current knowledge acquisition, modelling and engineering work carried out by the members of the CG-Community, and to solicit constructive feedback from researchers working a long time in the knowledge engineering field. The four papers presented in the CG-Track used the Conceptual Graph (CG) formalism of Sowa (1984). In a nutshell, these papers cover the following areas: knowledge acquisition tool (Martin, 1995), conceptual models programming tool (Möller, 1994), CG formalism for engineering and representing formal specification (Möller and Willems, 1995), and finally modelling and engineering executable conceptual models (Lukose, 1995). In brief, the paper by Martin (1995) outlines how in CGKAT, any document element and its semantics may be represented using CG. This paper also outlines the kinds of hypertext links necessary between the document elements and concepts and relations of the CG knowledge base. These links enable the use of various search techniques on the KB for finding information from the documents. Finally, this paper also presents the top-level ontologies in CGKAT and its exploitation of a semantically structured dictionary for the compositions of the knowledge base. The paper by Möller (1995) introduces an architecture and basic functions of a tool for programming conceptual models. The tool is called [KADS]->(ON)->[CG]. This architecture is based on the KADS knowledge engineering methodology to engineer the conceptual model and uses Conceptual Graphs as a knowledge representation and implementation formalism. This paper outlines some additional features that must be added to the standard CG formalism to enable the representation of modules. The domain knowledge resulting from applying the KADS methodology is mapped into CGs; the inference knowledge is represented with CGs as structural transformations which are instantiated from generic descriptions; it is declaratively described by using modules of semantic networks (or by using Sowa's terminology, a canon). The task knowledge is represented in CG as the goals to be achieved by the knowledge base system. The paper by Möller and Willems (1995) introduced CG-DESIRE framework for the engineering and representation of formal specifications. This framework is based on the DEsign and Specification of Interacting REasoning modules (DESIRE) language, which emphasises some very desirable principles of specification: declarativity, compositionality, reflection and executability (Langevelde, et. al., 1992). DESIRE represents both data and control of a system in a declarative manner using many-sorted first-order logic. This paper presents the DESIRE framework and redefine it using CGs. This paper also outlines the representational features that were added to the standard CG to meet the requirements for translating DESIRE to CG-DESIRE. Finally, the paper by Lukose (1995) demonstrates the use of CGs and Executable Conceptual Structures (ECSs) (Lukose, 1993) for modelling expertise. Building the model of expertise is only an intermediate process in the overall KADS methodology (which comprises of building seven models before realising a prototype system). In

conventional KADS approach, the executable prototype is only produced after the completing the Design Model stage (where the decision on an appropriate knowledge representation formalism is made). In the approach proposed in Lukose (1995), the decision for using CG and ECS is determined at a very early stage of the modelling process, as both CG and ECS are used for modelling the system and as the knowledge representation formalism. On completion of the Expertise Models and the Models of Cooperation, we obtain an executable Conceptual Model, as opposed to a static non-executable Conceptual Model in the conventional KADS methodology. In summary, what is apparent from the above papers are that for a successful application of CG for modelling and engineering knowledge base systems, the "standard" CG formalism is in many ways inadequate, both at the representational and executability level. One should not miss-understand a crucial point that CG was initially proposed by Sowa as only a declarative knowledge representation formalism. In the late 80's and early 90's we have been attempting to extend CG to be able to do more. For example, for it to be used as a representation formalism for formal specifications of systems and to be executable. These are some of the issues to be discussed in the remaining of this paper, together with a list of requirements put forward by the knowledge engineering community.

3. Limitations and Requirements The reaction of the KA-Community towards the use of CG for knowledge modelling and knowledge engineering has been mixed. The appreciation shown for using CG for knowledge modelling and knowledge engineering lies with its logical foundation, but on the hand, the sentiment shown by some of the participants can best be summarised as follows: Within the CG-Community, an explicit tendency to present conceptual graphs as having the ability for dealing with all sort of problems in all the artificial intelligence and knowledge engineering domains is clearly developing. Of course, there is nothing of surprising or blameworthy in this tendency. However, it could be wise to keep in mind that conceptual graphs theory originates from a relatively limited application domain, defined by the intersection of some linguistic and psychological concerns with database theory. As a consequence, it presents itself, basically, as a powerful variety of semantic network augmented with specific constructs for dealing with linguistic problems (e.g., tools for representing sets and plural situations). A more in-depth investigation of the conditions of applicability of this theory in domains that seem to be considerably far from the original one is required. During the CG-Track discussion sessions, a large number of issued were raised. They may be categorised into three main sub-categories: Expressive Adequacy, Inference Adequacy, and CG Tools. These lists of issues are by no means exhaustive. The CG-community has addressed almost all of these issues in one way or another, but these issues remain to attain a universally (at least by the members of the CG-community) accepted solution. Under the sub-category of Expressive Adequacy the issues that were paramount were the declaratively adequate representation of the following: quantification and sets; semantic constraints; inheritance; control structures. Here the semantic constraints refer to constraints on the domain (they are related to the canon). For instance: cardinalities: An employee can work for no more than one department. Inheritance in CG is defined along the type hierarchy, but we still cannot express inheritance between contexts or canons (Möller and Willems, 1995). Further to these the following issues were raised: requirement for a modular knowledge base as opposed to single monolithic; and embedded graphs as opposed to "simple" graphs. Within the sub-category of Inference Adequacy, the issues of main concern to the knowledge engineering community were: classification and inheritance; CG operations to merge, generalise, specialise and compare graphs (these operations are well defined for "simple" CGs, but not for embedded CGs); representation and implementation of control structures (e.g., conditional control structures and loops); and active graphs (executable conceptual graphs) (i.e., execute the conceptual model). The main point raised with respect to classification and inheritance is the need for an algorithms that classifies a graph with an unspecified concept. This form of algorithm provide flexibility for knowledge engineering. When one moves from considering a single knowledge base to that of a distributed multi

knowledge base systems (DAI Systems), there is a whole range of new inference problems that need to be resolved, in particular, multi-agent interactions. Apart from the above theoretical issues that were of concern to the knowledge engineering community, they were particularly astonished (to say the least) that the CG-Community does not have an adequate and universally available CG Tool that knowledge engineers could use to prototype systems and experiment the adequacies of CG for modelling and engineering knowledge base systems. It was made clear during the discussion sessions and during private conversations, that knowledge engineers will not touch a formalism that does not have a set of adequately supported tools. Tools that were of particular interest are: visual graphs editors, tools to manipulate ontologies, systems that will support multiple ontologies and multiple knowledge bases, tools to support knowledge acquisition and modelling, and natural language interface tool. These are some of the tools that must exist (with CG as its knowledge representation scheme) to enable knowledge engineers to consider using CG for constructing knowledge based systems. It is further emphasised that the CG tool also must come with a set of top-level ontologies that can be used as the starting point. A more in-depth investigation of the conditions of applicability of the CG theory is paramount. Examples of such work are in progress, in particular, the use of ECSs for modelling expertise (Lukose, 1995) and the operationalisation of KADS models by using conceptual graph modules (Möller, 1995). This type of investigation appears even more necessary when we consider that some "conceptual" deficiencies that were present in the original formulation of the theory are still there more than ten years later. In recent years, some of these limitations are at the centre of many researchers agenda around the world. In particular, the problems related to representation, deep semantics, and implementation are actively being investigated. In the course of the discussion that followed, in Banff, it is further evident that no agreement still exists within the CG-Community with respect to several important issues. This confirms a well-known criticism which has been often levelled against the conceptual graph approach. Conceptual Graphs scholars have successfully developed a general and elegant formal theory allowing for a very precise definition of the basic operations which can be used on these graphs. Unfortunately, little attention has been paid to establishing precise directions concerning the way these general tools can find a concrete incarnation in the context of a practical application. For example, when an application is being built, the system builder has to create a catalogue of basic conceptual graph structures, which results, among other things, in serious difficulties to secure the reproduction or the sharing of previous results. In an attempt to overcome this problem, researchers are investigating methodologies for constructing canonical graphs for very general context. An example of such an attempt is the NKRL (Narrative Knowledge Representation Language (Zarri, 1994)) formalism, where a catalogue enumerating all the permitted basic templates (comparable to the canonical graphs) and describing their rules of formation and their modalities of use are constructed for a very general socio-economico-political context. In addition to the above issues, there are two most urgent requirements that must be satisfied by the members of the CG Community working on knowledge engineering. Firstly, to put together a complete document on the advantages and disadvantages of using CG for knowledge engineering. This document should also state the past and present attempts to overcoming the disadvantages and the status of these attempts. Secondly, an in-depth comparative study has to be carried out to justify that CG has distinct advantages compared to the more traditionally adopted representational formalisms (e.g., KL-ONE). In a nutshell, the advantages of using CG for knowledge modelling and knowledge engineering has to be made explicit.

4. Role of CG in System Development Processes An alternative aim of this CG-Track is to identify where and how CGs can contribute effectively in Knowledge Engineering. From the formal and informal discussions in Banff, it is apparent that there are a number of ways that the CG formalism can make a significant contribution. Among them are the following: • Mediating Representation; • Uniform Representation Language; and • Modular Knowledge Bases.

The contributions of CG in each of the above areas are outlined below. There is currently considerable work in the areas of CG as a mediating representation for system design and realising the final operational system (Möller (1995), Möller and Willems (1995), and Lukose (1995)). Lukose et. al. (1995) further demonstrated how CG can be used as a uniform representation of the Task, Inference and Domain Knowledge. The contributions of Möller (1995) demonstrates the need for building modular knowledge bases and ways of manipulating and merging these modules. 4.1. Mediating Representation To achieve this aim, one has to review in detail the system development process as shown in Figure 1 (adopted from Shaw and Gaines (1995)). At the top of the figure, you will observe the informal social and psychological processes involved in knowledge and requirements elicitation. This elicitation phase develops a system specification expressed in humanly understandable terms (in some form of mediating representation), so that it can be checked for validity by a community of experts. An example of a mediating representation that is easily understandable to humans is concept maps (Kremer, 1995). The mediating representation does not demand that the knowledge be precise, consistent, or complete, but rather, its primary requirement is that it be easy for the human users to work with. Users should be encouraged to freely put down their thoughts in this representation without the undue burden of translating their thoughts into a format acceptable to an unforgiving and rigid representational system. In contrast, the objective of the system engineering phase at the bottom is to implement a precise, correct and complete system specification expressed in formal terms such that the final implementation can be verified as complying with the specification. CG is an excellent candidate for formal representation. By transforming this formal representation into Executable Conceptual Structures (for example, ECS as described in Lukose (1993)), one could represent the final operational system. In brief, the use of concept maps, CG and ECS as representational formalism in the conventional systems development and the final artefact is as follows: FROM

INFORMAL Concept Map

TO

FORMAL Conceptual Graphs

FROM

FORMAL Conceptual Graphs

TO

EXECUTABLE Conceptual Graphs + Executable Conceptual Structures

While transformation from CGs to an executable system seems to quite clear (Lukose, 1993), Shaw and Gaines (1995) point out that there is a major problem in ensuring the fidelity of the transformation from the humanly understandable mediating representations to implementable formal representation. One of the solutions proposed by Shaw and Gaines (1995) is to remove the central region altogether, as shown in Figure 2. This will imply that we have to create mediating representations that are formal, to bring the expert as close as possible to the structure of an operational system. Another possible way around the fidelity problem is to build a system which uses the same representational system for both informal representations and formal representations (Kremer 1995). This type of system would bridge the mediating representation and formal representation shown in Figure 1, and would embody the formalisation methodologies and tools of the transformational knowledge representational process. Such a system would have to meet the seemingly conflicting goals of an informal system (ease of use and acceptance of incomplete and inconsistent data) and a formal system (computational services such as detection of incompleteness and inconsistency): it would have to be a drawing package on the one hand and a formal language on the other. This may not be as ridiculous as it may seem. Generalised concept maps are graphs that look a lot like CGs, are easy to use and understand (Lambiotte, et. al., 1989; Nosek and Roth, 1990), but have no semantics; in fact, CGs may be viewed as a highly constrained (or formal) form of concept maps. A formalizable system would be capable of accepting unstructured and untyped concept maps in the knowledge elicitation phase, then working with the user to smoothly massage and formalise these graphs into fully complete and consistent CGs, which could, in turn, be transformed into an executable system.

REPRESENTATION SCHEME

SYSTEM DESIGN PROCESSES Community of Experts and Associated Knowledge Sources Informal Knowledge Sociological and Psychological Processes

Knowledge KnowledgeElicitation Elicitation Methodologies Methodologiesand andTools Tools

Validity

CONCEPT MAP

Knowledge-Based System Mediating Representation

Transformational Knowledge Representation Processes

Knowledge System Formalisation Methodologies and Tools

Fidelity

CONCEPTUAL GRAPHS

Knowledge-Based System Formal Representation Formal Knowledge Logical and Algebraic Processes

Knowledge Engineering Methodologies and Tools

Operational Knowledge-Based System

Elicitation Phase

Veracity

System Engineering Phase CONCEPTUAL GRAPHS + EXECUTABLE CONCEPTUAL STRUCTURES

Community of Users

Figure 1: System Development Processes (adapted from (Shaw and Gaines, 1995)) Any system which embodies the mediating representation system for knowledge base systems must at least fulfil the following requirements: • Ease of use: Domain experts are a precious commodity and must be treated kindly; • Modularity: Large knowledge base systems must be divided up into understandable chunks to be useful; • Flexibility: Commitment to a particular model or methodology must be deferred until the domain is sufficiently understood, usually as late in the development cycle as possible; • Navigational Aids: Users must have some convenient means or indexing and navigating within large knowledge based systems; • Computational Services: Users require computational services on the knowledge base ranging from identifier substitution to consistency and completeness analysis; and • Annotatability: Knowledge bases generally need to be annotated to document anomalies, authorship, history, explanation, and other data.

REPRESENTATION SCHEME

SYSTEM DESIGN PROCESSES Community of Experts and Associated Knowledge Sources Informal Knowledge Sociological and Psychological Processes

Knowledge KnowledgeElicitation Elicitation Methodologies Methodologiesand andTools Tools

Validity

CONCEPTUAL GRAPHS

Knowledge-Based System Formal Representation Formal Knowledge Logical and Algebraic Processes

Knowledge Engineering Methodologies and Tools

Elicitation Phase

Veracity

Operational Knowledge-Based System

System Engineering Phase CONCEPTUAL GRAPHS + EXECUTABLE CONCEPTUAL STRUCTURES

Community of Users

Figure 2: Simplified System Design Processes 4.2. Uniform Representation Over the last five years, there have been a large number of knowledge engineering methodologies, as well as modelling languages that is based on these methodologies. There are two main dimensions of classification for these modelling languages. The first dimension being "non-executable" vs "executable" modelling languages. The scale in Figure 3 depicts the range of these modelling languages. The second dimension of classification is "algorithmic" vs "graphical". Research and development work along this dimension has been of central focus in the mid-90's. For example, at KAW'95, no new algorithmic modelling language was introduced, but there were three graphical based modelling tools. All three were based on "extended" conceptual graphs. We emphasis the word "extended" here to highlight that in all these implementations, there have been several extensions to the standard CG theory. Table 1 highlights some of the more popular algorithmic as well as graphical modelling languages that have appeared in recent years. formal specification

executability

(ML)2 KARL OMOS FORKADS Model-K (van Harmelen and Balder, 1993) (Fensel, et. al., 1991) (Wetter, 1990) (Linster, 1993) (Voß and Karbach, 1993)

Figure 3: Modelling Languages for KADS

Methodology

KADS (Wielinga, Schreiber & Breuker, 1992) Component of Expertise (Steels, 1990) Generic Tasks (Chandrasekaran & Johnson, 1993) KADS (Wielinga, Schreiber & Breuker, 1992) COMMET (Steels, 1990)

DESIRE (Langevelde, et. al., 1992) KADS (Wielinga, Schreiber & Breuker, 1992) KADS (Wielinga, Schreiber & Breuker, 1992)

Modelling Language Algorithmic MODEL-K (Karbach and Voß, 1993) TroTelC (Vanwelkenhuysen et. al., 1990) TIPS (Punch & Chandrasekaran, 1993) LISA Graphical Modelling CG-DESIRE (Möller & Willems, 1995) [CG]->(ON)->[KADS] (Möller, 1995) MODEL-ECG (Lukose, 1995)

Table 1: Knowledge Engineering Methodologies and associated Modelling Languages One tends to beg the question "Why has there been a sudden increase in interest for the use of CG as a modelling language in knowledge engineering activities ?". Several arguments were put forward by the participants to justify the use of CG as a modelling language. Among them are the following: • CG is a representation scheme that can effectively represent both the "abstract" as well as the more "specific" representation of the Problem Solving Methods (PSMs) modelled by the knowledge engineer; and • CG together with ECG has been demonstrated in Lukose et. al. (1995) to be able to represent not only the abstract and specific view of the PSMs, but also that the final conceptual model is executable. What has resulted from the discussion as well as after analysing the three graphical implementation of modelling languages is that CG can be used as a uniform representation language for representing Task Models, Models of Cooperation, Expertise Model, and finally the Conceptual Model (for the KADS methodology in particular). But, one must not be mislead into believing that CG and ECS is all good and all encompassing representational scheme that solves all modelling problems. As outlined by Lukose in his concluding remark at KAW'95, there are still two main areas of research that is crucial for the liberal exploitation of the MODEL-ECS for modelling and prototyping. Firstly, the ability to handle conditional control structures, and loops (repeat loops, while loops, etc.). Secondly, the ability to handle refinements of the knowledge sources (i.e., or Actor Graphs in the MODEL-ECS term). Apart from this, there is certainly the issues of having an efficient implementation of a CG-processor to realise the rapid prototyping ability. 4.3. Modular Knowledge Base Modularity is a necessity for the development of large software systems. Today's knowledge base representations are often too complex and thus working with them makes engineering difficult. Additionally, the performance of operations on the knowledge base decreases with the size of a monolithic knowledge base. Problems usually arise, if we leave the stage of toy applications. Vicat, Ganascia and Busac (1995) stated at KAW'95 the following: "KADS did not make it possible to achieve the complete modelisation of our big industrial expertises, even with a home-made problem-solving method. The main reason was the lack of primitives to structure the expertise (as well at the problem-solving method level as at the domain level). So we have developed our own methodology with a computer environment, named CERISE, in order to achieve our modelisation process. The crucial notion we introduce in CERISE is the notion modularity. This notion makes it possible to structure properly the expertise by decomposing it into pieces called modules. It makes it possible also to deal with different levels of abstraction." Major aspects of modularity are information hiding, explicit definition of interfaces which enables more or less independent development of different modules and abstract data types which are modules consisting of data together with all operations working on it. The module concept should be adopted for knowledge bases, each module containing knowledge needed for solving a specific part of the overall problem. As small portions of knowledge in

modules are easier to survey, the effort for knowledge base construction is reduced and there are less undesired interferences. Some key problems arising in a modular CG theory were addressed by Möller at ICCS'94 in a project proposal. The work presented by Möller at KAW'95 was not a complete theory of modular CG knowledge bases, but a solution to implement KADS models in a modular way using CGs (Möller, 1995). The approach to modules was motivated by different functionalities which domain knowledge may have in a KADS model (i.e., static knowledge or inference knowledge). At least different modules for every layer and function were proposed. CGs already include the idea of modularity by allowing different canons and Möller added some 'programming' features for the transfer of graphs between canons and for using canons as problem solving modules. So the import and export between modules is realised by special actors, and modules perform operations by structural transformation according to a declarative description in CG. Control structure is given by explicitly stating goal and the assumed use of a theorem prover for CGs. Another approach to modularity and CGs was presented by Möller and Willems (1995). When reimplementing the formal specification language DESIRE using CGs, several requirements to CGs arose, which are not yet met by the current theory. While in the first approach the concept of modularisation is oriented at modules in imperative programming languages, the second approach introduces an idea of a module, that is more object-oriented. Modularity again was based on Sowa's canon. In Möller and Willems (1995) there was a unique view on concepts, contexts and canons. Modularity was realised by allowing hierarchical structured canons and inheritance between canons in the same way as there is inheritance along the type hierarchy in classical CG theory. In conclusion, modularity is a need for large applications and is necessary from a software engineering point of view, but it demands some extension to standard CGs.

5. Future Work On of the main limitation of the work on applications of CG for knowledge engineering and knowledge modelling presented at KAW'95 is the lack of sufficient evaluations of the systems and the extended CG formalisms. Thus, the main areas of future work to be carried out by the participants of the CG-Track are on the evaluation of their systems and formalism on well accepted benchmarks. The tasks are divided into two categories as shown below: • Evaluation of Knowledge Modelling using CG; and • Evaluation of Knowledge Acquisition using CG. In the area of evaluation of the knowledge modelling approaches using CG, the following attempts are currently under progress: (a) D. Lukose and colleagues at UNE (Australia) are evaluating the MODEL-ECS on the VT-Room Allocation and VT-Elevator Design problem domain. These problem domains are part of the Sisyphus project. At the time of writing this paper, work on modelling the Room Allocation System using MODEL-ECS is in progress. (b) R. Dieng and colleagues from INRIA (France) are investigating the use of CG for modelling autonomous agents (i.e., multi-ontology domain). The main evaluation being carried out by this group is in the sharing and use of the ontology in a multi-agent problem solving domain. The domain they have adopted for their evaluation purpose is the Traffic Accidents and Control domain (Dieng, 1995). In the area of evaluating knowledge acquisition using CG, there are currently three efforts in progress. These efforts are listed below: (a) G. Mineau from Université Laval (Canada) is specifically looking at the use of CG as a mediating representation scheme to enable the modelling of the expertise through negotiation. In effect, when building large systems, modular acquisition of knowledge permits incremental development and validation of the knowledge acquired so far. The integration of different knowledge modules must then be addressed. Different tools can help analyse the domain in order to facilitate this integration. When the modules come from different knowledge based systems, some negotiation can take place in order to establish a common agreement on the meaning of the conceptual structures which were used by both (Mineau, 1995).

(b) J-U. Möller from University of Hamburg (Germany), R. Kremer from University of Calgary (Canada) and D. Lukose from University of New England (Australia) are to investigate further the use of CG (i.e., extended CG formalism) to enable it to represent specifications, and to develop methodologies of using CG to enable the migration of specifications to performance. In a nutshell, this group is attempting to refine the use of CG to enable the representation of executable systems specifications. (c) G. Boy from EURISCO (France) is continuing his investigation of the use of conceptual structures to produce better explanations as to the design rationality associated with the model of expertise that is constructed using conventional modelling methodologies. It is anticipated that the above five groups will be able to present their results at the next KAW in Banff in 1996. One other area of work that is severely lacking is the comparative evaluation of the modelling tools based on CG with that of other graph formalisms. To conclude, in this paper, we attempted to outline in brief the efforts by members of the CG-Community to build knowledge engineering, modelling and acquisition tools and techniques to develop large knowledge-based systems. We outlined the limitations of CG as seen by the KA-Community, and attempted to identify where and how CG could make major contributions in system engineering. We also identified areas of research that are severely lacking. This document is in no way to be taken as a criticism of the work carried out by the CG-Community or the KACommunity. Its prime aim is to make explicit the problems faced by the KA-Community in adopting CG as a modelling and representation formalism for building knowledge-based systems.

6. Acknowledgments We firstly, would like to acknowledge the contributions of all the paper reviewers who have spend considerable time in reviewing the papers for the CG-Track at KAW'95. We thank them for their careful scrutinisation of the ideas presented, and for providing constructive suggestions to improve the quality of the papers. Secondly, we would like to extend our gratitude to the organisers of KAW'95, in particular Brian Gaines, Mark Musen, Mildred Shaw and Rob Kremer for all the help they have provided us to run the CG-Track at KAW'95. Finally, we would like to thank the organisers of ICCS'95 for enabling us to present this paper at ICCS'95.

7. References Chandrasekaran, B., and Johnson, T., (1993). Generic tasks and Tasks Structures: History, Critique and New Directions, in David, J.M., Krivine, J.P., and Simmons, R., (Eds.), Second Generation Expert Systems, Springer Verlag, Berlin, pp. 232-272. Dieng, R., (1995). Specifying a Cooperative System through Agent-Based Knowledge Acquisition, in Proceedings of the 9th Banff Knowledge Accquisition For Knowledge-Based Systems Workshop, Banff Conference Centre, Banff, Alberta, Canada, February 26 - March 3, 1995, Paper No: 20. Fensel, D., Angele, J., and Landes, D., (1991). Knowledge Representation and Acquisition Language (KARL), In Proceedings of the 11th International Workshop on Expert Systems and Their Applications (Volume: Tools and Techniques), Avignon, France, pp. 821-833. Van Harmelen, F., and Balder, J., (1993). (ML)2: A Formal Language for KADS Models of Expertise, In Schreiber, G., Wielinga, B., and Breuker, J., (Eds.), KADS: A Principles Approach to Knowledge-Based System Development, Academic Press, pp. 169-202. Karbach, W., and VoB, A., (1993). MODEL-K for prototyping and strategic reasoning at the knowledge level, in David, J.M., Krivine, J.P., and Simmons, R., (Eds.), Second Generation Expert Systems, Springer Verlag, Berlin, pp. 721-745.

Kremer, R., (1995). The Design of a Concept Mapping Environment for Knowledge Acquisition and Knowledge Representation, in Proceedings of the 9th Banff Knowledge Accquisition For Knowledge-Based Systems Workshop, Banff Conference Centre, Banff, Alberta, Canada, February 26 - March 3, 1995, Paper No: 23. Langevelde, I.A., van, Philipsen, A.W., and Treur, J., (1992). Formal specification of compositional architectures, in B. Neumann (ed.), Proceedings 10th European Conference on Artificial Intelligence, ECAI'92, John Wiley & Sons, Chichester, 1992, pp. 272-276. Lambiotte, J.G., Dansereau, D.F., Cross, D.R., Reynolds, S.B., (1984). Multirelational Semantic Maps. Educational Psychology Review, 1(4), pp. 331-367. Linster, M., (1993). Using OMOS to Represent KADS Conceptual Model, In Schreiber, G., Wielinga, B., and Breuker, J., (Eds.), KADS: A Principles Approach to Knowledge-Based System Development, Academic Press, pp. 221-246. Lukose, D., (1995). Using Executable Conceptual Structures for Modelling Expertise, in Proceedings of the 9th Banff Knowledge Accquisition For Knowledge-Based Systems Workshop, Banff Conference Centre, Banff, Alberta, Canada, February 26 - March 3, 1995, Paper No: 8. Lukose, D., Cross, T., Munday, C., and Sobora, F., (1995). Operational KADS Conceptual Model using Conceptual Graphs and Executable Conceptual Structures, Proceedings of the International Conference on Conceptual Structures (ICCS'95), USA. Martin, P., (1995). Knowledge Acquisition using Documents, Conceptual Graphs and a Semantically Structured Dictionary, in Proceedings of the 9th Banff Knowledge Accquisition For Knowledge-Based Systems Workshop, Banff Conference Centre, Banff, Alberta, Canada, February 26 - March 3, 1995, Paper No: 9. Mineau, G.W., (1995). Establishing a Semantic Basis: Toward the Integration of Vocabularies, in Proceedings of the 9th Banff Knowledge Accquisition For Knowledge-Based Systems Workshop, Banff Conference Centre, Banff, Alberta, Canada, February 26 - March 3, 1995, Paper No. 2. Möller, J-U., (1995). Operationalisation of KADS Models by using Conceptual Graph Modules, in Proceedings of the 9th Banff Knowledge Accquisition For Knowledge-Based Systems Workshop, Banff Conference Centre, Banff, Alberta, Canada, February 26 - March 3, 1995, Paper No: 10. Möller, J-U., and Willems, M., (1995). CG-DESIRE: Formal Specification Using Conceptual Graphs, in Proceedings of the 9th Banff Knowledge Accquisition For Knowledge-Based Systems Workshop, Banff Conference Centre, Banff, Alberta, Canada, February 26 - March 3, 1995, Paper No: 11. Nosek, J. T., and Roth, I., (1990). "A Comparison of Formal Knowledge Representation Schemes as Communication Tools: Predicate Logic vs. Sematic Networks." International Journal of Man-Machine Studies, 33, pp. 227-329. Punch, W.F., and Chandrasekaran, B., (1993). An Investigation of the Roles of Problem-Solving Methods in Diagnosis, in David, J.M., Krivine, J.P., and Simmons, R., (Eds.), Second Generation Expert Systems, Springer Verlag, Berlin, pp. 673-698. Schreiber, G., Wielinga, B., and Breuker, J. (1993). KADS: A Principled Approach to Knowledge-Based System Development, Academic Press, London. Shaw, M.L.G., and Gaines, B.R., (1995). Knowledge and Requirements Engineering, in Proceedings of the 9th Banff Knowledge Accquisition For Knowledge-Based Systems Workshop, Banff Conference Centre, Banff, Alberta, Canada, February 26 - March 3, 1995, Paper No: 44.

Sowa, J.F. (1984). Conceptual Structures: Information Processing in Mind and Machine, Addison Wesley, Reading, Mass., USA. Steels, L., (1990). Components of Expertise, AI Magazine, 11(2), pp. 29-49. Vanwelkenhuysen, J., and Rademakers, P., (1990). Mapping a Knowledge Level Analysis onto a Computational Framework, Proceedings of the 9th European Conference on Artificial Intelligence, London, Pitman Publishing, pp. 661-666. Vicat, C., Ganascia, J.-G., and Busac, A., (1995). Modularity in Knowledge Acquisition: a Step towards Reusability, in Proceedings of the 9th Banff Knowledge Accquisition For Knowledge-Based Systems Workshop, Banff Conference Centre, Banff, Alberta, Canada, February 26 - March 3, 1995, Paper No: 36. Voß, A., and Karbach, W., (1993). MODEL-K: Making KADS Run, In Schreiber, G., Wielinga, B., and Breuker, J., (Eds.), KADS: A Principles Approach to Knowledge-Based System Development, Academic Press, pp. 203-220. Wetter, T., (1990). First-order logic foundation of the KADS conceptual model. In Wielinga, B., Boose, J., Gaines, B., Schreiber, G., and van Someren, M., (Eds.), Current trends in knowledge acquisition, Amsterdam, The Netherlands, IOS Pres, pp. 356-375. Wielinga, B., Schreiber, A.T., and Breuker, J.A., (1992). KADS: A Modelling Approach to Knowledge Engineering, in The KADS Approach to Knowledge Engineering Special Issue, Knowledge Acquisition, 4(1), Academic Press, London. Zarri, G.P., (1994). A Glimpse of NKRL, the Narrative Knowledge Representation Language, in Working Notes of the AAAI Fall Symposium on Knowledge Representation for Natural Language Processing in Implemented Systems, American Association for Artificial Intelligence (AAAI), Menlo Park (CA) USA.