The DR-Prolog Tool Suite for Defeasible Reasoning and Proof Explanation in the Semantic Web

Transcription

1 The DR-Prolog Tool Suite for Defeasible Reasoning and Proof Explanation in the Semantic Web Antonis Bikakis 1,2, Constantinos Papatheodorou 2, and Grigoris Antoniou 1,2 1 Institute of Computer Science, FO.R.T.H., Heraklion, Greece 2 Computer Science Department of University of Crete, Greece bikakis@ics.forth.gr, cpapath@csd.uoc.gr, antoniou@ics.forth.gr Abstract. In this work we present the design and general architecture of DR-Prolog, a system for defeasible reasoning and proof explanation in the Semantic Web, and the implementation of three different tools that constitute the DR-Prolog Tool Suite: (a) the DR-Prolog API; (b) the DR- Prolog Web application; and (c) the DR-Prolog desktop application. DR- Prolog supports reasoning with Defeasible Logic theories and ontological knowledge in RDF(S) and OWL, is compatible with RuleML, and enables extracting meaningful proof explanations for the answers it computes. 1 Introduction The development of the Semantic Web proceeds in steps, each step building a layer on top of another. At present, the highest layer that has reached sufficient maturity is the ontology layer in the form of the description logic-based language OWL [1]. The next step will be the logic and proof layers. The implementation of these two layers will allow the user to state any logical principles, and permit the computer to infer new knowledge by applying these principles on the existing data. Rule systems appear to lie in the mainstream of such activities. Most studies on the integration of rules and ontologies in the Semantic Web have been based on monotonic logics. Some prominent approaches are: (a) the Description Logic Programs proposed in [2]; (b) the integration of Description Logics and Datalog rules, followed in [3,4]; (c) the F-logic based rule language TRIPLE [5]; and (d) the Semantic Web Rules Language (SWRL [6]), which extends OWL-DL with Horn-style rules. Approaches based on non-monotonic logics, on the other hand, constitute another interesting solution, as they offer more expressive capabilities and are closer to commonsense reasoning. Four recently developed non-monotonic rule systems are: (a) DR-Prolog [7], which stands in the core of the tools that we describe in this paper; (b) DR-DEVICE [8], a defeasible reasoning system for the Web, which is implemented in Jess and integrates well with RuleML and RDF; (c) SweetJess [9], which implements defeasible reasoning through the use of situated courteous logic programs; and (d) dlvhex [10], which integrates rules and ontologies using answer-set semantics. J. Darzentas et al. (Eds.): SETN 2008, LNAI 5138, pp , c Springer-Verlag Berlin Heidelberg 2008

2 346 A. Bikakis, C. Papatheodorou, and G. Antoniou This paper describes the integration of the DR-Prolog defeasible reasoning engine described in [7] with the Prolog-based proof explanation service, presented in [11], in three different implementations that constitute the DR-Prolog Tool Suite: (a) the DR-Prolog API; (b) the DR-Prolog web application; and (c) the DR-Prolog desktop application. The main features of the system are: 1. It is based on Prolog. The core of the system consists of a well-studied translation of defeasible knowledge into logic programs under Well-Founded Well-Founded, Kunen and Answer-Set Semantics [12]. 2. It accepts both strict (monotonic) and defeasible (non-monotonic) rules and uses priorities between competing rules to resolve potential conflicts. 3. It is compatible with RuleML [13], the main standardization effort for rules on the Semantic Web. 4. It can reason with RDF, RDF Schema and (parts) of OWL ontologies. 5. It automatically generates an explanation for every answer it computes in a formal and meaningful representation. 2 DR-Prolog Architecture The DR-Prolog architecture consists of seven main modules, which exchange information with each other or with the user in the way depicted in Figure 1. Fig. 1. DR-Prolog Architecture

3 The DR-Prolog Tool Suite for Defeasible Reasoning 347 RDF-OWL Parser. The role of this module is to download ontology (RDF(S), OWL) documents from a given URL, parse the documents, and translate the ontology triples into logical facts of the form: Predicate(Subject,Object). The module also contains a set of Prolog rules that capture the semantics of RDFS constructs and of some of OWL constructs. A detailed description of these rules is available at [7]. For the implementation of the parser, we used the SWI- Prolog RDF library, which we enriched with a couple of functions that aim at properly handling the namespaces and forming the triples in the desirable format. DL Parser. The DL Parser is responsible for parsing the rule theories imported by the user and encoded in the syntax of Defeasible Logic, checking for their validity, notifying the user about possible errors, and translating the DL theories into the native DR-Prolog syntax, as this is described in [7]. RuleML Parser. Its rule is to parse RuleML DL theories, check their validity and notify the user about possible errors, and translate them into DR-Prolog syntax. RuleML theories may contain factual knowledge, rules and queries. The module is implemented using XSL Transformation along with a second processing level for tasks such as the extraction of queries from the RuleML document. Query Parser. The Query Parser undertakes the user query and proof requests. It identifies the type of request, checks if the query is valid, notifies the user about possible errors, and translates it into a valid Prolog query. Theory Loader. This module imports the Prolog files created by the RDF- OWL Parser, the DL-Parser, and the RuleML Parser, and dispatches them to the Prolog engine, along with a Prolog metaprogram that simulates the proof theory of Defeasible Logic. The user can select between two variants of DL - ambiguity blocking and ambiguity propagating. Both variants and the corresponding metaprograms are described in detail in [7]. Prolog Engine. In the core of the system stands a Prolog engine that compiles the Prolog files dispatched by the Theory Loader, and computes answers to the user queries, returning the answer to the user and its trace to the Proof Module. For the implementation of the engine, we used the XSB logic programming system, as it supports well-founded semantics of logic programs through the use of tabled predicates and its negation (sk not) operator. Proof Module. This module is responsible for generating meaningful and wellformed proof explanations to the user. It processes the trace of the answer computed by the Prolog engine by cutting out redundant information, and returns a tree-like sequence of rules that explains how the computed answer derives from the imported theory and data. [11] contains a more detailed description of the design and functionality of this module.

4 348 A. Bikakis, C. Papatheodorou, and G. Antoniou 3 Implementation 3.1 DR-Prolog API DR-Prolog API is a Java Library, which enables integrating the DR-Prolog functionality in defeasible reasoning based AI applications. It provides two types of functions: (a) functions that handle the underlying communication with the central Prolog engine; and (b) utility functions that enable writing DR Prolog programs. For the back-end communication mentioned above, DR-Prolog API in turn uses the Interprolog API ( / Interprolog). This is an open-source Java front-end that supports various Prolog engines including SWI and XSB. It provides access to Prolog engines over TCP/IP sockets and launches Prolog processes in the background, outside the Java Virtual Machine. In the DR-Prolog API, Interprolog is used as follows: In the RDF-OWL Parser it is used to launch SWI in order to translate the ontology data into Prolog clauses. In the Theory Loader, it initiates the Prolog engine and consults the Prolog theory and data files along with the appropriate DL metaprogram. It fully implements the XSB Prolog Engine functionality. The utility functions implement the functionality of the four parsers of the system, the Proof module, and some extra functionality (e.g. initializing various DR-Prolog parameters, downloading files from given URLs etc.). The following java code demonstrates the use of the API through a very simple scenario. In this scenario, we initiate DR-Prolog, define a DL theory, which contains a single defeasible rule (r: a b) and issue a query about b. import drprolog.*; public class HelloDrPrologWorld { public static void main(string[] args){ prologapi DREngine = new prologapi("/xsb/bin","amb_metaprogram.p", true); DREngine.quickLoadDLTheory("r: a => b. "); String answer = DREngine.executePrologQuery("b", false); DREngine.shutdownPrologEngine(); } } DR-Prolog API, as well as detailed documentation describing the use of the API and the available functions, and some sample programs are available at the DR-Prolog web site ( bikakis/dr-prolog). 3.2 DR-Prolog Web Application The DR-Prolog Web interface is a server-client application based on the Model View Controller (MVC) architecture (slightly modified, though, in order to suit the needs of its multiple-layered nature). It enables different web users to simultaneously interact with the DR-Prolog reasoning engine. The Web Application is implemented on top of the DR-Prolog API. The interface is a JSP page, which provides access to the DR-Prolog functionality.

5 The DR-Prolog Tool Suite for Defeasible Reasoning 349 Users start sessions, which are uniquely identified by the server, to support simultaneous accesses. The server keeps track of the user-uploaded files by saving them to individually created folders for each session and maintaining the required references in vectors. All user requests are routed through the jsp interface to the controller servlet. After validating the request and depending on the contact code passed on to the controller, a decision is made and control is dispatched to the appropriate servlet implementing the requested function. The system responses are then placed in Java Bean objects (Model), and finally forwarded to the appropriate Jsp page for presentation (View). In case an error occurs at any level, control flow stops and user is redirected to a jsp error page, which provides the user with an error description, the point of occurrence and possibly a solution to the problem. The remaining servlets implement the functionality of DR-Prolog. Most of them are wrapper functions of their respective DR-Prolog API functions, which are called with parameters that are acquired through user submitted forms. The uploadhandler servlet unifies the functionality of all parsers. It uploads the theory/data files submitted by the user through forms, and depending on their format, it calls the appropriate parser of the DR-Prolog API. If no errors are encountered, it updates the appropriate user session objects and vectors containing the newly created parsed file paths. The drtheory servlet is responsible for: (a) session creation and deletion; (b) file management; (c) implementing the functionality of the Query Parser. When a query or proof request is made, after validating the query, drtheory forwards execution control to drpmachine The drpmachine servlet implements the Theory Loader, the Prolog Engine and the Proof module. Specifically, it calls the appropriate DR-Prolog API functions in order to: (a) load the user theory and data files and queries to the Prolog Engine; (b) construct the proof explanation; and (c) return the answers to the user. The urlfiledownloader servlet undertakes downloading files from given URLs. 3.3 DR-Prolog Desktop Application The DR-Prolog Desktop Application is a single-user application, which implements the functionality of DR-Prolog. Comparing to the DR-Prolog Web Application, it merely provides some extra text-editing type of operations, such as (quick) creating, saving and loading Theory files. It has been implemented around the DR-Prolog API. In fact, there is a direct, one-to-one mapping of DR- Prolog API functions to application buttons. To be able to use this application, a user must download: (a) The DR-Prolog.zip file containing a java executable (DR-Prolog.jar) and some library files, from the DR-Prolog web site; (b) the XSB Prolog engine from and (c) the SWI-Prolog engine from

6 350 A. Bikakis, C. Papatheodorou, and G. Antoniou 4 Conclusion In this paper, we presented the DR-Prolog Tool Suite; a suite of tools that implement the functionality of DR-Prolog. All tools have been built according to the DR-Prolog architecture, presented in Section 2, and provide defeasible reasoning capabilities on DL theories and ontology data encoded in various formats including a RuleML representation for DL theories, and the RDF syntax for ontology data. In the future, we plan to (a) test the usability of the tools through user evaluation; (b) integrate the modal and deontic extensions of Defeasible Logic, described in [14]; (c) extend the tools with verbal and visual proof explanations; and (d) integrate the DR-Prolog API in defeasible reasoning applications for brokering, bargaining, automated agent negotiation and mobile computing. References 1. McGuinness, D.L., van Harmelen, F.: OWL Web Ontology Language Overview W3C Recommendation (2004), 2. Grosof, B.N., Horrocks, I., Volz, R., Decker, S.: Description logic programs: combining logic programs with description logic. In: WWW, pp (2003) 3. Levy, A.Y., Rousset, M.C.: Combining Horn rules and description logics in CARIN. Artificial Intelligence 104(1-2), (1998) 4. Rosati, R.: On the decidability and complexity of integrating ontologies and rules. WSJ 3(1), (2005) 5. Sintek, M., Decker, S.: TRIPLE - A Query, Inference, and Transformation Language for the Semantic Web. In: Horrocks, I., Hendler, J. (eds.) ISWC LNCS, vol. 2342, pp Springer, Heidelberg (2002) 6. Horrocks, I., Patel-Schneider, P.F.: A proposal for an OWL Rules Language. In: WWW 2004: Proceedings of the 13th international conference on World Wide Web, pp ACM Press, New York (2004) 7. Antoniou, G., Bikakis, A.: DR-Prolog: A System for Defeasible Reasoning with Rules and Ontologies on the Semantic Web. IEEE Transactions on Knowledge and Data Engineering 19(2), (2006) 8. Bassiliades, N., Antoniou, G., Vlahavas, I.P.: DR-DEVICE: A Defeasible Logic System for the Semantic Web. In: Ohlbach, H.J., Schaffert, S. (eds.) PPSWR LNCS, vol. 3208, pp Springer, Heidelberg (2004) 9. Grosof, B.N., Gandhe, M.D., Finin, T.W.: SweetJess: Translating DAMLRuleML to JESS. In: RuleML (2002) 10. Eiter, T., Ianni, G., Schindlauer, R., Tompits, H.: dlvhex: A System for Integrating Multiple Semantics in an Answer-Set Programming Framework. In: WLP, pp (2006) 11. Antoniou, G., Bikakis, A., Dimaresis, N., Genetzakis, M., Georgalis, G., Governatori, G., Karouzaki, E., Kazepis, N., Kosmadakis, D., Kritsotakis, M., Lilis, G., Papadogiannakis, A., Pediaditis, P., Terzakis, C., Theodosaki, R., Zeginis, D.: Proof explanation for a nonmonotonic semantic web rules language. Data and Knowledge Engineering 64(3), (2008)

7 The DR-Prolog Tool Suite for Defeasible Reasoning Antoniou, G., Billington, D., Governatori, G., Maher, M.J.: Embedding defeasible logic into logic programming. Theory Pract. Log. Program 6(6), (2006) 13. RuleML: The RuleML Initiative website (2006), Antoniou, G., Dimaresis, N., Governatori, G.: A system for modal and deontic defeasible reasoning. In: Orgun, M.A., Thornton, J. (eds.) AI LNCS (LNAI), vol. 4830, pp Springer, Heidelberg (2007)