Planning with Incomplete Information

Planning is a natural domain of application for frameworks of reasoning about actions and change. In this paper we study how one such framework, the Language E, can form the basis for planning under (possibly) incomplete information. We define two types of plans: weak and safe plans, and propose a planner, called the E-Planner, which is often able to extend an initial weak plan into a safe plan even though the (explicit) information available is incomplete, e.g. for cases where the initial state is not completely known. The E-Planner is based upon a reformulation of the Language E in argumentation terms and a natural proof theory resulting from the reformulation. It uses an extension of this proof theory by means of abduction for the generation of plans and adopts argumentation-based techniques for extending weak plans into safe plans. We provide representative examples illustrating the behaviour of the E-Planner, in particular for cases where the status of fluents is incompletely known.Comment: Proceedings of the 8th International Workshop on Non-Monotonic Reasoning, April 9-11, 2000, Breckenridge, Colorad

A Temporal Abductive Diagnostic Process for Runtime Properties Violations

Monitoring the operation of complex softare systems at runtime can detect violations of certain properties of interest but cannot always provide diagnostic information which is significant for understanding the cause of the violation and the adoption of appropriate countermeasures against it. In this paper, we describe a process for diagnosing runtime violations of security and dependability properties that we have developed as part of a general runtime monitoring framework that is based on Event Calculus. The diagnosis generation process is based on a combination of abductive, temporal and evidential reasoning over violations of system properties

Towards Formal Verification of Web Service Composition

http://www.springerlink.com/Web services composition is an emerging paradigm for enabling application integration within and across organizational boundaries. Current Web services composition proposals, such as BPML, WSBPEL, WSCI, and OWL-S, provide solutions for describing the control and data flows in Web service composition. However, such proposals remain at the descriptive level, without providing any kind of mechanisms or tool support for analysis and verification. Therefore, there is a growing interest for the verification techniques which enable designers to test and repair design errors even before actual running of the service, or allow designers to detect erroneous properties and formally verify whether the service process design does have certain desired properties. In this paper, we propose to verify Web services composition using an event driven approach. We assume Web services that are coordinated by a composition process expressed in WSBPEL and we use Event Calculus to specify the properties and requirements to be monitored

Web Service Mining and Verification of Properties: An approach based on Event Calculus

http://www.springerlink.com/Web services are becoming more and more complex, involving numerous interacting business objects within complex distributed processes. In order to fully explore Web service business opportunities, while ensuring a correct and reliable execution, analyzing and tracking Web services interactions will enable them to be well understood and controlled. The work described in this paper is a contribution to these issues for Web services based process applications. This article describes a novel way of applying process mining techniques to Web services logs in order to enable ''Web service intelligence''. Our work attempts to apply Web service log-based analysis and process mining techniques in order to provide semantical knowledge about the context of and the reasons for discrepancies between process models and related instances

Diagnosis and Threat Detection Capabilities of the SERENITY Monitoring Framework

The SERENITY monitoring framework offers mechanisms for diagnosing the causes of violations of security and dependability (S&D) properties and detecting potential violations of such properties, called “threats”. Diagnostic information and threat detection are often necessary for deciding what an appropriate reaction to a violation is and taking pre-emptive actions against predicted violations, respectively. In this chapter, we describe the mechanisms of the SERENITY monitoring framework which generate diagnostic information for violations of S&D properties and detecting threats

Multi-agent planning using an abductive : event calculus

Temporal reasoning within distributed Artificial Intelligence Systems is faced with the problem of concurrent streams of action. Well known, logic-based systems using the SITUATION CALCULUS solve the frame problem in a purely linear manner. Recent research, however, has revealed that the EVENT CALCULUS under the abduction principle is capable of nonlinear planning. In this report, we present a planning service module which incorporates this approach into a constraint logic framework and even allows a notion of strong nonlinearity. The work includes the axiomatisation of appropriate versions of the EVENT CALCULUS, the development of a suitably sound and complete proof procedure that supports abduction and the implementation of both of these layers on the constraint platform OZ. We demonstrate prototypically how this module, EVE, can be integrated into an existing multi-agent architecture and evaluate the behaviour of such agents within an application domain, the loading dock scenario

Diagnosing runtime violations of security and dependability properties

Monitoring the preservation of security and dependability (S&D) properties of complex software systems is widely accepted as a necessity. Basic monitoring can detect violations but does not always provide sufficient information for deciding what the appropriate response to a violation is. Such decisions often require additional diagnostic information that explains why a violation has occurred and can, therefore, indicate what would be an appropriate response action to it. In this thesis, we describe a diagnostic procedure for generating explanations of violations of S&D properties developed as extension of a runtime monitoring framewoek, called EVEREST. The procedure is based on a combination of abductive and evidential reasoning about violations of S&D properties which are expressed in Event Calculus

Temporal reasoning with Abductive Event Calculus

. We present the SLDNFA procedure, which integrates two important nonmonotonic paradigms, negation as failure and abduction. The main difference between SLDNFA and existing approaches is the improved treatment of non-ground abductive goals. We present an extension for temporal reasoning based on Abductive Event Calculus. We show the power of the approach by applying it to planning and solving wellknown temporal reasoning problems. Interestingly, the procedure generates partial plans; the order of events is left unspecified when they do not interfere.

The CIFF Proof Procedure for Abductive Logic Programming with Constraints: Definition, Implementation and a Web Application

Abduction has found broad application as a powerful tool for hypothetical reasoning with incomplete knowledge, which can be handled by labeling some pieces of information as abducibles, i.e. as possible hypotheses that can be assumed to hold, provided that they are consistent with the given knowledge base. Attempts to make the abductive reasoning an effective computational tool gave rise to Abductive Logic Programming (ALP) which combines abduction with standard logic programming. A number of so-called proof procedures for ALP have been proposed in the literature, e.g. the IFF procedure, the Kakas and Mancarella procedure and the SLDNFA procedure, which rely upon extensions of different semantics for logic programming. ALP has also been integrated with Constraint Logic Programming (CLP), in order to combine abductive reasoning with an arithmetic tool for constraint solving. In recent years, many proof procedures for abductive logic programming with constraints have been proposed, including ACLP and the A-System which have been applied to many fields, e.g. multi-agent systems, scheduling, integration of information. This dissertation describes the development of a new abductive proof procedure with constraints, namely the CIFF proof procedure. The description is both at the theoretical level, giving a formal definition and a soundness result with respect to the three-valued completion semantics, and at the implementative level with the implemented CIFF System 4.0 as a Prolog meta-interpreter. The main contributions of the CIFF proof procedure are the advances in the expressiveness of the framework with respect to other frameworks for abductive logic programming with constraints, and the overall computational performances of the implemented system. The second part of the dissertation presents a novel application of the CIFF proof procedure as the computational engine of a tool, the CIFFWEB system, for checking and (possibly) repairing faulty web sites. Indeed, the exponential growth of the WWW raises the question of maintaining and automatically repairing web sites, in particular when the designers of these sites require them to exhibit certain properties at both structural and data level. The capability of maintaining and repairing web sites is also important to ensure the success of the Semantic Web vision. As the Semantic Web relies upon the definition and the maintenance of consistent data schemas (XML/XMLSchema, RDF/RDFSchema, OWL and so on), tools for reasoning over such schemas (and possibly extending the reasoning to multiple web pages) show great promise. The CIFFWEB system is such a tool which allows to verify and to repair XML web sites instances, against sets of requirements which have to be fulfilled, through abductive reasoning. We define an expressive characterization of rules for checking and repairing web sites' errors and we do a formal mapping of a fragment of a well known XML query language, namely Xcerpt, to abductive logic programs suitable to fed as input to the CIFF proof procedure. Finally, the CIFF proof procedure detects the errors and possibly suggests modifications to the XML instances to repair them. The soundness of this process is directly inherited from the soundness of CIFF