The scenario shows how the Mars and Swan architectures interact by the use of actions and events. Different types of rules are presented: ECA rules, ACA rules and triggers. The overall concept is the event driven architecture. Interacting with the framework is strictly different from usual web services. Instead of calling a remote procedure of a web service, abstract definitions can be given.
Once the rules are defined and registered, the abstract action definitions can be sent to the domain nodes. The vocabulary for these actions is defined by the ontology of the application domain. For the user it is not necessary to know
how these actions are realised. Using the abstract vocabulary of the common domain ontology it is possible to say what should be done (for example sending an event travel:book-flight to the domain broker).
The application domain nodes as presented in the example have very limited capabilities, as it was not the intention to demonstrate a fully-fledged application node. Rather the idea is to show how the communication between Mars and Swanusing events and actions works and how abstract actions translate into knowledge base updates. This approach can be extended to more complex situations very easily, e.g. by defining behaviour for flight cancellations. This ease of extensibility is one of the strong points of this architecture. Furthermore, all process logic is put into rules. Along with a logical characterisation of the rules it is possible to reason about the effects of events in the application domain.
This is a broad field for further investigations.
In the following chapter, the concepts that were presented in this work are discussed and put into the context of related work.
Discussion
12.1 Limitations of DL Reasoning
Some of the limits of Description Logics have already been discussed in the context of OWL in Section3.7. In the following the limits of DL reasoning in real world applications are investigated.
The application domain that Description Logics were originally intended for was ontology engineering, that is to design, construct, and maintain large con-ceptual schemas [Hor98]. Later, with the advent of the Semantic Web, Descrip-tion Logics were chosen for the logical foundaDescrip-tion of the ontology descripDescrip-tion language OWL DL. OWL provides the designer of an ontology with axioms for the modelling of concepts, roles, and the relationships of individuals. The constructors and axioms of DLs were widely explored at that time. With the application of DL reasoning for the Semantic Web the power of that formalism could be tested with very heterogeneous applications. With regard to ontologies consisting of large TBoxes, DL reasoners indeed seem to be well suited [HO01].
But often applications have to handle queries over knowledge bases that are built from small and simple TBoxes, but also include large ABoxes. This is where DL reasoners reach their limits. The problem with ABox reasoning seems to arise not so much from the computational complexity of ABox reasoning, but from the fact that the number of individuals might be extremely large [HLTB04].
Many of the proposals that try to deal with the scalability problem of DL ontologies are (re-)using techniques from database research. Here, the problem of very large data sets was already explored intensively. But these findings cannot be reused in the world of DL without certain restrictions. It must not be forgotten that there is a gap between deductive databases and classical logical inference. Furthermore, the handling of individuals is strictly different: Equality of individuals can be inferred easily in DLs whereas the unique name assumption in databases prevents it. As individuals with multiple given names are a typical situation in the World Wide Web this is an important feature in DLs.
In [HLTB04] the authors use a relational database for the storage of ABox data in combination with a DL reasoner for TBox data. However, they had to put restrictions on the ABox such that only role-free instance data can be stored (e.g. A isa B). Hereby, the system is capable of dealing with very large ABoxes and allows for sound and complete answers to instance retrieval queries.
165
Another solution has been proposed with the Kaon2 project [MS06]. The authors refer to research in the field of deductive databases. They present an algorithm that reduces a SHIQ knowledge base KB to a disjunctive datalog programme DD(KB). This system turned out to perform well on knowledge bases with simple TBoxes and large ABoxes whereas the performance for com-plex TBox reasoning was in general worse compared to the performance of sophisticated DL reasoners like Pellet, Racer, or FaCT++. Also the pres-ence of equality expressions significantly influpres-ences the performance of Kaon2 badly.
In [MB08] a promising method for improved ABox reasoning was presented.
The authors completely separate ABox and TBox, the DL reasoner is used on the TBox exclusively. OWL axioms expressing knowledge about ABox data are translated into rules that are given, together with the ABox instances, to a rule engine. The authors claim that the rule engine is able to achieve the same deductions as the DL reasoner in considerably less time. Although the application of rule systems as a supplement to DL reasoning is not novel at all, the strict separation of DL reasoning for TBox and rule-based reasoning for the ABox is new.
There are no ABox optimisations so far in Swan. Therefore the aforemen-tioned restrictions have to be considered when ontologies with very large ABoxes are used. See also the discussion in Section12.4.