Reuse has long been a major goal of the knowledge engineering community. We present a case study of the reuse of constraint knowledge acquired for one problem solver, by two further problem solvers. For our analysis, we chose a well-known benchmark knowledge base (KB) system written in CLIPS, which was based on the propose and revise problem-solving method and which had a lift/elevator KB. The KB contained four components, including constraints and data tables, expressed in an ontology that reflects the propose and revise task structure. Sufficient trial data was extracted manually to demonstrate the approach on two alternative problem solvers: a spreadsheet (Excel) and a constraint logic solver (ECLiPSe). The next phase was to implement ExtrAKTor, which automated the process for the whole KB. Each KB that is processed results in a working system that is able to solve the corresponding configuration task (and not only for elevators). This is in contrast to earlier work, which produced abstract formulations of the problem-solving methods but which were unable to perform reuse of actual KBs. We subsequently used the ECLiPSe solver on some more demanding vertical transport configuration tasks. We found that we had to use a little-known propagation technique described by Le Provost and Wallace (1991). Further, our techniques did not use any heuristic "fix"' information, yet we successfully dealt with a "thrashing" problem that had been a key issue in the original vertical transit work. Consequently, we believe we have developed a widely usable approach for solving this class of parametric design problem, by applying novel constraint-based problem solvers to data and formulae stored in existing KBs.

It is over 20 years since the functional data model and functional programming languages were first introduced to the computing community. Although developed by separate research communities, recent work, presented in this book, suggests there is powerful synergy in their integration. As database technology emerges as central to yet more complex and demanding applications in areas such as bioinformatics, national security, criminal investigations and advanced engineering, more sophisticated approaches like those presented here, are needed. A tutorial introduction by the editors prepares the reader for the chapters that follow, written by leading researchers, including some of the early pioneers. They provide a comprehensive treatment showing how the functional approach provides for modeling, analyzis and optimization in databases, and also data integration and interoperation in heterogeneous environments. Several chapters deal with mathematical results on the transformation of expressions, fundamental to the functional approach. The book also aims to show how the approach relates to the Internet and current work on semistructured data, XML and RDF. The book presents a comprehensive view of the functional approach to data management, bringing together important material hitherto widely scattered, some new research, and a comprehensive set of references. It will serve as a valuable resource for researchers, faculty and graduate students, as well as those in industry responsible for new systems development.

This paper explores the solution of the VT Sisyphus II challenge using a Constraint Satisfaction Problem (CSP) paradigm and is an extension of the Ex-trAKTor work presented at EKAW 2006. ExtrAKTor takes a Protégé KB describing a propose and- revise (PnR) problem, including both constraints & fixes. Subsequently, it extracts and transforms these components so that they are directly usable by the ECLiPSe CSP toolkit to solve a range of configuration tasks. It was encouraging to note that (a) the solver coped very well with constraints involving real variables even when using a generalised propagation technique and (b) the techniques needed no “fix” information, yet successfully dealt with the “antagonistic constraints” and the associated “thrashing” problem that had been a key issue in the original Marcus, Stout & McDermott VT paper. Consequently, we believe this is a widely useable technique for automatically generating and then solving this class of constraint problems, when they are expressed as Protégé ontologies.

In this paper, we propose a Blackboard Architecture as a means for coordinating hybrid reasoning over the Semantic Web. We describe the components of traditional blackboard systems (Knowledge Sources, Blackboard, Controller) and then explain how we have enhanced these by incorporating some of the principles of the Semantic Web to pro- duce our Semantic Web Blackboard. Much of the framework is already in place to facilitate our research: the communication protocol (HTTP); the data representation medium (RDF); a rich expressive description language (OWL); and a method of writing rules (SWRL). We further enhance this by adding our own constraint based formalism (CIF/SWRL) into the mix. We provide an example walk-though of our test-bed system, the AKTive Workgroup Builder and Blackboard(AWB+B), illustrating the interaction and cooperation of the Knowledge Sources and providing some context as to how the solution is achieved. We conclude with the strengths and weaknesses of the architecture.

In this paper, we discuss the need for a hybrid reasoning approach to handing Semantic Web data and explain why we believe that the Blackboard Architecture is particularly suitable. We describe how we have utilised it for combining ontological inference, rules and constraint based reasoning within a Semantic Web context. After describing the metaphor on which the Blackboard Architecture is based we introduce the key components of the architecture: the blackboard Panels containing the solution space facts and problem related goals and sub-goals; the differing behaviours of the associated Knowledge Sources and how they interact with the blackboard; and, finally, the Controller and how it manages and focuses the problem solving effort. To help clarify, we use our test-bed system, the AKTiveWorkgroup Builder and Blackboard (AWB+B) to explain some of the issues and problems encountered when implementing a Semantic Web Blackboard System in Java, using Jena. We also discuss our reasons why we elected to use the Jena toolkit and explain its usage within several of the key components of our system.

In this paper we present a proposal for representing soft constraint satisfaction problems (CSPs) within the Semantic Web architecture. The proposal is motivated by the need for a service-providing agent in a virtual organisation to reason about its commitments as soft constraints. The three essential requirements addressed are: (1) the need to have constraints express commitments in terms of Semantic Web services, (2) the need to associate utility values with constraints, to reflect the relative importance of satisfying them, and (3) the need to make statements about which constraints are satisfied and violated by a given solution. The proposal builds upon previous work in defining a Semantic Web constraint interchange format (CIF), which itself builds on the proposed Semantic Web rule language (SWRL). The paper describes an ontology for representing soft CSPs and their solutions, allowing an agent’s set of commitments to be expressed as a collection of soft constraints. The ontology is an open interchange format for soft CSPs, allowing commitment to be communicated and exchanged among the members of a virtual organisation.

The ability to create reliable, scalable virtual organisations (VOs) on demand in a dynamic, open and competitive environment is one of the challenges that underlie Grid computing. In response, in the CONOISE-G project, we are developing an infrastructure to support robust and resilient virtual organisation formation and operation. Specifically, CONOISE-G provides mechanisms to assure effective operation of agent-based VOs in the face of disruptive and potentially malicious entities in dynamic, open and competitive environments. In this paper, we describe the CONOISE-G system, outline its use in VO formation and perturbation, and review current work on dealing with unreliable information sources.

Reuse has long been a major goal of the Knowledge Engineering community. The focus of this paper is the reuse of domain knowledge acquired for an initial problem solver, with a further problem solver. For our analysis we chose a knowledge base system written in CLIPS based on the propose-and-revise (PnR) problem solver, and which had a lift/elevator knowledge base (KB). Given the nature of the problem solver, the KB contained 4 components, namely an ontology, procedural statements which specify how the artifact, the lift, could be enhanced/modified, a set of constraints to be satisfied, and a set of fixes to be applied when constraint violations occurred. These 4 components were first extracted manually, and were used with both an Excel spreadsheet and a constraint problem solver (ECLiPSe) to solve a range of tasks. The next phase was to implement ExtrAKTor which extracts the same 4 knowledge sources virtually automatically from the CLIPS knowledge base (held by Protégé), and transforms these so that they are usable with a number of problem solvers. To date Excel & ECLiPSe have been selected, and again we have demonstrated that the resulting systems are able to solve a variety of lift configuration tasks. This is in contrast to earlier work which produced abstract formulations of the problem but which were unable to perform reuse of actual knowledge bases.

Customers in the future are likely to obtain their services from coalitions of service providers. These coalitions can be described as virtual organisations (VOs); they are groups of service providers that form relationships to service customers' demands on an ad-hoc basis. For a VO to be effective, it must be reliable and scalable, and, realistically, it must be created and maintained in a dynamic, open and competitive environment. The CONOISE-G project has focused on resolving the technology challenges that emerged from these requirements. Specifically, CONOISE-G provides mechanisms to assure effective operation of VOs in the face of failure, unexpected events and changing requirements in a dynamic, open and competitive environment. In this paper, we describe the CONOISE-G system, motivated by a scenario based on mobile service provision, outline its use in the context of VO formation and perturbation, and review current efforts to progress the work to deal with unreliable information sources.

In this paper, we discuss the need for a hybrid reasoning approach to handing Semantic Web (SW) data and explain why we believe that the Blackboard Architecture is particularly suitable. We describe how we have utilised it for coordinating a combination of ontological inference, rules and constraint based reasoning within a SW context.After describing the metaphor on which the Blackboard Architecture is based we introduce its key components: the blackboard Panels containing the solution space facts and problem related goals and sub-goals; the differing behaviours of the associated Knowledge Sources and how they interact with the blackboard; and, finally, the Controller and how it manages and focuses the problem solving effort.To help clarify, we use our test-bed system, the AKTive Workgroup Builder and Blackboard (AWB+B) to explain some of the issues and problems encountered when implementing a SW Blackboard System in a problem oriented context.

In this paper we present a proposal for representing soft CSPs within the Semantic Web architecture. The proposal is motivated by the need for a service-providing agent to reason about its commitments as soft constraints. The two essential requirements addressed are: the need to associate utility values with constraints, to reflect the relative importance of satisfying them, and the need to make statements about which constraints are satisfied and violated by a given solution. The proposal builds upon previous work in defining a Semantic Web Constraint Interchange Format (CIF), which itself builds on the proposed Semantic Web Rule Language (SWRL).The main contribution of this paper is a new ontology for representing soft CSPs; we also extend the previous form of CIF/SWRL. The soft CSP ontology is intended to be used with CIF/SWRL, but is also potentially usable with other constraint and rule representations.

Constraints are commonly used to maintain data integrity and consistency in databases. This ability to store constraint knowledge, however, can also be viewed as an attachment of instructions on how a data object should be used. In other words, data objects are annotated with declarative knowledge which can be transformed and processed. This abstract describes our work in Aberdeen on the fusion of knowledge in the form of integrity constraints in a distributed environment. We are particularly interested in the use of constraint logic programming techniques with off-the-shelf constraint solvers and distributed database queries. The objective is to construct an information system that solves application problems by combining declarative knowledge attached to data objects in a distributed environment. Unlike a conventional distributed database system where only database queries and data objects are transported, we also ship the constraints which are attached to the data. This is analogous to the use of footnotes and remarks in a product catalogue describing the restrictions on the use of specific components.

As new semantic web standards evolve to allow quantified rules in FOL, we need new ways to capture them from end users in RDFS(XML). We show how to do this against a graphic view of Entities, and their Relationships (associated or derived). This even allows inclusion of existential quantifiers in readable fashion. The captured constraint can be tested by generating queries to search for violations in stored data. The constraint can then be automatically revised to exclude specific cases picked out by the user, who is spared worries about proper syntax and boolean connectives.

One of the strangest paradoxes of the silicon era is the dichotomy between ’enjoyable’ recreational computer activities and ’mundane’ work-based computer operations. How can an activity as pointless as a computer game have so much appeal? The answer to this lies in the user interface, and not the functionality, of the program. Computer games rely heavily on an interface which is natural and enjoyable to use. We believe that an interface should appeal to the user, and to do so must capture the user's interest and imagination. To this end, we have been using high performance graphics to generate meaningful three dimensional representations for our graphical user interface. We propose new metaphors for both query construction and result representation.

The ability to create reliable and scalable virtual organisations (VOs) on demand in a dynamic, open and competitive environment is one of the major challenges that underlie Grid computing. In response, in the CONOISE-G project, we are developing an infrastructure to support robust and resilient virtual organisation formation and operation. Specifically, CONOISEG provides mechanisms to assure effective operation of agent-based VOs in the face of disruptive and potentially malicious entities in dynamic, open and competitive environments. In this paper, we describe the CONOISE-G system, outline its use in the context of VO formation and perturbation, and review current efforts to progress the work to deal with unreliable information sources.

A method is described for implementing a general database supporting objects, which is tightly coupled to Prolog. This provides the Prolog interpreter with database storage for its clauses. It also allows one to create and access from Prolog objects of arbitrary type such as frames with attached procedures. The interface from Prolog allows the full use of the computational and database facilities of the PS-Algol implementation Language, within the framework of an Abstract Data Type scheme, which is based on an implementation of modules in Prolog. The paper describes how evaluable predicates can be written in PS-Algol and made to backtrack, thus providing a neat symbiosis between the two languages.

We describe a modular compiler architecture that has been developed for a functional data model DBMS. The architecture allows compilers for new sub-languages to be constructed rapidly, by reusing the components of the existing compiler, and allows new semantics and code generation strategies to be defined for existing language constructs. This point is demonstrated by the construction of a new compiler for an integrity constraint language, which required only two new modules to be added to the system. The most significant advantage of our architecture, however, is that it allows the DBMS itself to use the individual compiler modules, opening up a host of possibilities for run-time manipulation of application code.

The P/FDM object-oriented database is based on the functional data model and has a modular design, allowing alternative kinds of object storage to be used. This is achieved by implementing a small set of basic data access and update routines for each kind of storage module. In this work, a relational database management system has been used to provide object storage, and we describe how the data access routines have been implemented. The principal query language used with P/FDM is Daplex, which is normally translated to Prolog, including calls to the basic data access routines. The query is optimised to minimise the expected number of calls. This gives very general method execution and pattern matching search. However, much better performance can be achieved for simpler data-intensive Daplex queries against a relational storage module by translating these to a single SQL statement. We describe a program called DAPSTRA which performs this translation quickly in a fashion transparent to the user, and compare performance.