UML is the de-facto standard formalism for software design and analysis. To support the design of large-scale industrial applications, sophisticated CASE tools are available on the market, that provide a user-friendly environment for editing, storing, and accessing multiple UNIL diagrams. It would be highly desirable to equip such CASE tools with automated reasoning capabilities, such as those studied in Artificial Intelligence and, in particular, in Knowledge Representation and Reasoning. Such capabilities would allow to automatically detect relevant formal properties of UML diagrams, such as inconsistencies or redundancies. With regard to this issue, we consider UML class diagrams, which are one of the most important components of UML, and we address the problem of reasoning on such diagrams. We resort to several results developed in the field of Knowledge Representation and Reasoning, regarding Description Logics (DLs), a family of logics that admit decidable reasoning procedures. Our first contribution is to show that reasoning on UML class diagrams is EXPTIME-hard, even under restrictive assumptions; we prove this result by showing a polynomial reduction from reasoning in DLs. The second contribution consists in establishing EXPTIME-membership of reasoning on UML class diagrams, provided that the use of arbitrary OCL (first-order) constraints is disallowed. We get this result by using DLR(ifd), a very expressive EXPTIME-decidable DL that has been developed to capture typical features of conceptual and object-oriented data models. ne last contribution has a more practical flavor, and consists in a polynomial encoding of UML class diagrams in the DL ALCQI, which essentially is the most expressive DL supported by current state-of-the-art DL-based reasoning systems. Though less expressive than DLR(ifd), the DL ALC QI preserves enough semantics to keep reasoning about UML class diagrams sound and complete. Exploiting such an encoding, one can use current DL-based reasoning systems as core reasoning engines for a next generation of CASE tools, that are equipped with reasoning capabilities on UML class diagrams. (c) 2005 Elsevier B.V. All rights reserved

Abstract. The main focus of this paper is on automatic e-Service composition. We start by developing a framework in which the exported behavior of an e-Service is described in terms of its possible executions (execution trees). Then we specialize the framework to the case in which such exported behavior (i.e., the execution tree of the e-Service) is represented by a finite state machine. In this specific setting, we analyze the complexity of synthesizing a composition, and develop sound and complete algorithms to check the existence of a composition and to return one such a composition if one exists. To the best of our knowledge, our work is the first attempt to provide an algorithm for the automatic synthesis of e-Service composition, that is both proved to be correct, and has an associated computational complexity characterization.

No abstract

This paper addresses the issue of automatic service composition. We first develop a framework in which the exported behavior of a service is described in terms of a socalled execution tree, that is an abstraction for its possible executions. We then study the case in which such exported behavior (i.e., the execution tree of the service) can be represented by a finite state machine (i.e., finite state transition system). In this specific setting, we devise sound, complete and terminating techniques both to check for the existence of a composition, and to return a composition, if one exists. We also analyze the computational complexity of the proposed algorithms. Finally, we present an open source prototype tool, called ESC (E-Service Composer), that implements our composition technique. To the best of our knowledge, our work is the first attempt to provide a provably correct technique for the automatic synthesis of service composition, in a framework where the behavior of services is explicitly specified.

In this paper we study the issue of service composition, for services that export a representation of their behavior in the form of a finite deterministic transition system. In particular, given a specification of the target service requested by the client as a finite deterministic transition system, the problem we face is how we can exploit the computations of the available services for realizing the computations of the target service. While ways to tackle such a problem are known, in this paper we present a new technique that is based on the notion of simulation, which is still optimal from the computational complexity point. Notably, such a technique, opens up the possibility of devising composition in a "just-in-time" fashion. Indeed, we show that, by exploiting simulation, it is actually possible to implicitly compute all possible compositions at once, and delay the choice of the actual composition to run-time.