A NEW APPROACH TO AUTOMATIC WEB SERVICES COMPOSION

by

Luong Viet Phong

A thesis proposal submitted in partial fulfillment of the requirements for the degree of
Master of Engineering.

Examination Committee: Prof. Vilas Wuwongse (Chairman)

Nationality: Vietnam
Previous Degree: Bachelor of Information Technology
Ho Chi Minh University of Technology
Ho Chi Minh city, Vietnam

Asian Institute of Technology

School of Advanced Technology
Thailand
August 2005

i
 TABLE OF CONTENTS

1 INTRODUCTION......................................................................................................................... ................1
1.1 Background............................................................................................................................... .........1
1.2 Problem Statement.......................................................................................................... ...................1
1.3 Objectives................................................................................................................... .......................2
1.4 Scope................................................................................................................................... ..............2
2 LITERATURE REVIEW....................................................................................................................... ..........3
2.1 Industrial efforts...................................................................................................................... ............3
2.2 Academic efforts......................................................................................................... .......................4
2.2.1 Semantic Web Service Language............................................................................ ..................5
2.2.2 Automatic Web Service Composition..................................................................... ....................8
2.2.3 Current problems................................................................................................ .....................10
3 METHODOLOGY................................................................................................................ ......................12
4 REFERENCE.......................................................................................................................... ...................15

ii
 1 INTRODUCTION

1.1 Background
Web Service is one of the most interesting technologies in recent years. Web
Service is a software application identified by a URI, whose interfaces and binding are
capable of being defined, described and discovered by XML artifacts and supports direct
interactions with other software applications using XML based messages via Internet-
based protocols [1]. Informally, Web Service is a software component that can be accessed
through the Internet. It is language independent and platform independent. For example, a
software component written on .Net framework can call or communicate with a Web
Service written in Java language and deployed on Linux platform. This may provide the
flexibility for the developers and increase the collaboration among the service providers.
Due to these properties, Web Service has appealed to software community. Within the
development of Web Service, service oriented architecture has been developed rapidly and
been used in wide ranges of information technology applications. The applications are built
by assembling appropriated services. Thus the description, discovery, matching,
composition and execution of Web services are key actions when building services and
service-oriented applications.
Exploiting Web Service has many benefits. Thus the amount of Web services is
increasing rapidly. Many companies and organizations have just implemented their core
business and outsourced other application services over the Internet. More enterprises have
collaborated with others to offer valued-added integrated services by combining existing
Web services. In addition, the user requirements and the changing of business environment
are more complicated. A single Web services may not satisfy the user need. Thus many pre
existing Web services may have to be composed to create novel functionalities. Moreover,
the composite Web services can increase re-using and extension of Web services in
development. Therefore, Web service composition is a potential area. It has been one of
major streams in researches about Web Service.

1.2 Problem Statement

In general, Web service composition is the ability of one business to provide value-
added services through composition of basic Web services, possibly offered by different
companies. Because of its potential, there are many researches about it in both industry and
academic environment. The first effort is in industrial world. Numerous Web Service
composition languages are created by many giants in software industry, such as IBM,
Microsoft, BEA, etc. These enterprises are trying to propose their languages as the
standard for composing Web Services. On the other hand, the academic researches have
concentrated on Semantic Web Service. Semantic Web Service Language and Automatic
Web Service Composition are two important streams in these researches. The first stream
focuses on creating an expressive and powerful language to add more semantic into the
description of Web Service. The second stream tries to automate the composite processes
as much as possible. The majority of researches conducted have fallen into realm of
workflow composition or AI planning [2]. In some aspects, workflow composition can be
similar to AI planning. The work items can be considered as the steps in the plans. The
flow among work items can be considered as the combination or the order of steps in the
plan. Consequently, the workflow composition may be a particular case of the AI planning.
The main AI planning techniques that have been used are situation calculus, theorem
proving, ruled based, hierarchical task network (HTN). However, these techniques have
problems when applying to Automatic Web Service Composition. For instance, there are

1
mismatches between the semantic service description languages and AI planners. The
planners use the closed world assumption. In contrast, the semantic description languages
have opened world semantic. Thus the planners cannot understand all the semantic in the
service descriptions. In addition, the AI planners have limited reasoning capabilities.
Furthermore, there are many other problems such as search space, non-deterministic
behaviors of the services, incomplete information, etc.

1.3 Objectives
The objective of this proposal is to propose a new approach to automatic Web
Service composition. The approach is based on document generation using equivalent
document transformation rules. WSML will be used to express Web Service, user request,
constraints and preference. All transformation rules are described by XET language. The
final results are service composition descriptions. These descriptions are documents in
terms of BPEL4WS.
In addition to the new approach, a new framework which is used to implement the
proposed approach is also introduced. The framework will have the following features:
• Encoding the user request, constraints and preference into expressive language
• Combining user information with service descriptions, business model and domain
ontology as inputs for transformation engine.
• Applying the proposed method to generate the service composition description
documents.
To evaluate the effectiveness and efficiency of the new approach and new
framework, the will be compared with some current AI planning solutions for automatic
Web Services composition, such as rule-based, and theorem proving.
1.4 Scope
There are many research topics in Web Service composition, especially automatic
Web Service. For example, service discovery, service matching, composite service
evaluation, composite service invocation are related fields. However, the thesis focuses on
the automatic composition process with the given set of Web Services. The new approach
is proposed to generate the composition description automatically.
In addition, there are two assumptions in the composition processes. The first one is
the processes do not have to communicate with the information providing Web Services to
obtain information. The second assumption is the composition processes take place at the
executable business process level.
The following contents of the proposal are organized into two sections. Section II
will review some work in automatic Web Service composition and discuss the existing
problems. Section III consists of three parts. Firstly, part one describes general idea of the
new method and how the current obstacles can be improved. Secondly, the proposed
framework is introduced and discussed. Finally, part three discusses about the intended
technologies that will be used in the new method.

2
 2 LITERATURE REVIEW
The Web Service composition has the interest from both industrial world and
academic environment. The software enterprises have tried to create the Web Service
Composition Language that can be executed by their application servers or middle wares.
On the other hand, the academic researchers concentrate on Semantic Web Service. The
two main streams are Semantic Web Service Language and Automatic Web Service
Composition.

2.1 Industrial efforts

In industry, orchestration and choreography are two terms for describing
collaboration of Web services. Orchestration describes how web services can interact with
each other at the message level, including the business logic and execution order of the
interactions. Choreography tracks the sequence of messages that may involve multiple
parties and multiple sources, including customers, suppliers and partners. Orchestration
differs from choreography in it describes the message flow among services controlled by
single service. Choreography is at a higher level of collaboration and more collaborative in
nature. In addition, Web services may be considered as processes. There are two types of
processes when considering about Web services, executable process and abstract process.
Executable process models the behaviour of participants in a specific business interaction,
essentially modelling a private workflow. It is similar to orchestration. In the other hand,
abstract process specifies the public message exchange between parties. It is similar to
choreography.
The industrial efforts focus on developing the Web service composition language.
When the composition script written in Web service composition language is generated, the
application servers or middleware, such as Microsoft Biz Talk Server or IBM WebSphere,
can execute the script to perform the desired tasks. The application servers play a role as
mediators in collaboration among Web services. However, there are many proposals of
standard in industrial efforts. Every player tries to develop and recommend its language as
standard. BPEL4WS, BPML, WSCI and WS-CDL are having most interest and advantages
than other languages.
BPEL4WS stands for Business Process Execution Language for Web Services. It is
developed by IBM, Microsoft and BEA. It was merged from XLANG of Microsoft and
WSFL of IBM. BPEL4WS was on top of WSDL. It models the behaviour of Web service
in a business process interaction. The language has control logic to coordinate Web service.
In addition, it supports the long transaction. The first working draft of this language was
released in April 2004 by OASIS BPEL TC [21].
The second interested language is BPML (Business Process Management
Language). It is also developed by Sun, SAP, Intalio, and BEA. BPML is the meta-
language for describing business process. It comprises basic activities such as sending,
receiving, and invoking services. This language also provides structured activities such as
conditional choices, sequential and parallel activities, joins, and looping. However there is
no further development on BPML since its last release in November 2002 [21].
The third interested language is WSCI, developed by Sun, SAP, Intalio and BEA.
WSCI is abbreviated from Web Service Chorography Interface. It describes the messages
between web services that participate in a collaborative exchange. The language supports
message correlation, sequencing rules, exception handling, transactions, and dynamic
collaboration. However, it does not address the definition of executable business processes.
WSCI was submitted to W3C in August 2002. Thereafter, Web Service Choreography

3
Working group, established by W3C, develop a new language based on WSCI
specification, WS-CDL. WS-CDL is an XML specification for long-lived and peer-to-peer
collaboration among Web Services participants. This language is purely for abstract
business process specification. The first working draft of WS-CDL was released in April
2004.
In comparison, BPEL4WS is suitable to model executable process and abstract
process. In contrast, WS-CDL is just suitable to model abstract process and BPML is
suitable to model executable process. Although BPEL4WS has some advantages in support
Web Services composition such as modeling the execution control, spawn off process and
synchronization, and event handling, BPEL4WS may equal to WS-CDL combining with
BPML informally [21], [3]. In addition, BPEL4WS and WS-CDL are developed by two
major standard organizations, OASIS and W3C respectively. However, BPEL4WS has
gained widest support from the industry. Most major software vendors have BPEL4WS
supported in their products, such as IBM, Microsoft, etc. [21].

Figure 1: Web service composition languages comparison [3].

Consequently, the giants in software industry try to create the Web Service
Composition Language and propose their languages as the standard. These languages aim
to describe the composition descriptions with logic constructs, such as condition, and
loops, and the extended features, such as exception handling or transaction management.
However, the efforts may focus on the execution phase of the composition process. The
composition descriptions are generated manually. It needs human interactions during the
design phase of the composition process.

2.2 Academic efforts

There are two main streams in academic researches about Web Service
Composition, Semantic Web Service Language and automatic Web Service composition.

4
2.2.1 Semantic Web Service Language
The first stream tries to add semantic to the descriptions of Web Services by
creating the expressive and powerful language. Current Web Services are based on the core
technologies such as SOAP, WSDL, and UDDI. These technologies have limited semantic
to advance tasks on the Web Service, such as discovery, matching or composition. The
Web Services are described by WSDL currently. WSDL just describes the syntactical
interface of a Web service and XML based message streams are used to communicate with
Web services. However, this information is not enough to reason and perform advanced
task on services. For example, to describe the service providing the add function, the
service description may describe inputs and outputs in the following form: Int x Int  Int.
It means that the service need two integer number as inputs and it will produce and integer
number as output. This description may be similar to the multiply function. Thus it is
difficult to distinguish the differences between two services when comparing, selecting or
performing some tasks automatically by software agents. In order to provide more
semantic to service description, precondition and effect of service should be added.
Preconditions are conditions required for service execution. Effects are conditions or states
that hold after service execution. For instance, in course registration service, the
preconditions may be that one course has some prerequisite courses and the students have
to pass these prerequisite courses to register the new course. The effects of this service may
be the state that students have registered the course. As a result, the current WSDL may
lack of the semantic in describing the Web service. The services have to be described in the
machine-readable form to carry out tasks automatically. Therefore, many researchers
develop methods to describe the semantic and pragmatic aspects of Web services. Adding
more semantic to Web service description will increase the reasoning capabilities and
automatic composition of Web service. The majority of researches concentrate on creating
the language that can have more expressive power and reasoning mechanism in service
description.
The first interested language in semantic web service currently is OWL – S
(formerly DAML – S). OWL – S define the ontology for services. The most important
goal for OWL – S is to establish a framework within which service descriptions are made
and shared. OWL – S is expected to enable following activities: automatic Web service
discovery, automatic Web service invocation, automatic Web service composition and
interoperation. The class Service is at the top ontology of services. It has properties, such
as presents, describedBy, and supports. The classes ServiceProfile, ServiceModel, and
ServiceGrounding are the respective ranges of those properties. Firstly, the property
presents describe what the service does and what the service require of the users, or other
agents, and provide for them. Secondly, the property describedBy provides information
about how service works. This describes what happens when the service is carried out.
Finally, the property support specifies how the service works or how to access the service,
such as the communication protocols, port numbers, etc. [4].
However, OWL-S has some limitations. The first one is the unclear meaning of the
description elements. This may lead to the misinterpretation and incompatible models. The
second limitation is the lack of expressiveness of the specification languages. OWL-DL is
used to express ontology of service concepts in OWL-S. But OWL-DL has to trade off
expressiveness for decidability. Thus the semantic of some aspects in OWL-S process
ontology cannot be defined in OWL-DL. In addition, using other specification languages,
such as SWRL, DRS, and KIF, also has some shortcomings. For instance, the combination
with SWRL or DRS may lead to inherent undecidability. The KIF syntax is also not
integrated in OWL-S. Therefore, there are two efforts which try to develop standardized

5
ways of conceptualizing and organizing the semantic information about services and
develop a language for the declarative specification of this semantic information.
The first effort is Semantic Web Service Ontology and Semantic Web Service
Language. This is done by Semantic Web Service Committee of Semantic Web Service
Initiative. The Semantic Web Services Ontology (SWSO) represents a conceptual model
for Web Service description and a formal characterization of that model. This
characterization is given in first order logic. It is called FLOWS, First Order Logic
Ontology for Web Services. In addition, the axioms from FLOWS have been
systematically translated into SWSL-Rules language with an avoidable weakening of some
axioms. The resulting ontology, which relies on logic programming semantic, is called
ROWS, Rules Ontology for Web Services [24].
More precisely, FLOWS is an axiomatized ontology of service concepts, which
provides the conceptual framework for describing and reasoning about services. The goal
of FLOWS is to enable reasoning about the semantics underlying Web services, and how
they interact with each other and with the real world. The FLOWS model provides
infrastructure for representing messages between services. FLOWS also provides
constructs for modeling the internal processing of Web services. FLOWS has many
intuitions and improvement from OWL-S. Following the high-level structure of OWL-S,
FLOWS has three major components: Service Descriptors, Process Model, and Grounding.
In the formal ontology, these three elements are associated with services by representing a
formal service as a conceptual object, and using relations to associate specific artifacts with
the service. A primary difference between FLOWS and OWL-S is the expressive power of
the underlying language. FLOWS is based on first-order logic, which means that it can
express considerably more than can be expressed using OWL-DL. A second difference is
that FLOWS strives to explicitly model more aspects of Web services than OWL-S.
FLOWS is able to model process models using a variety of different paradigms and model
data flow between services [25].
Semantic Web Service Language (SWSL) is a logic-based language for specifying
formal characterizations of Web service concepts and descriptions of individual services. It
includes two sublanguages: SWSL-FOL, a full first-order logic language, which is used to
specify the service ontology (SWSO), and SWSL-Rules, a rule-based sublanguage, which
can be used both as a specification and an implementation language. As a language, SWSL
is domain-independent and does not include any constructs specific to services.
More specifically, SWSL is a general-purpose logical language, with certain
features to make it usable with the basic languages and infrastructure of the Web. These
features include URIs, integration of XML built-in types, and XML-compatible namespace
and import mechanisms. SWSL includes two layers of expressiveness: SWSL-FOL and
SWSL-Rules. SWSL-FOL is a first-order logic, extended with features from HiLog and the
frame syntax of F-logic. SWSL-Rules is a full-featured logic programming (LP) language,
which includes a novel combination of features from Courteous logic programs, HiLog,
and F-logic [26].
The second effort is Web Service Modeling Ontology and Web Service Modeling
Language. It is under the development of DERI. WSMO provides an overall framework
for Semantic Web Service in order to support automated Web Service discovery,
composition, and execution. WSMO has two major design principles [22].
• Principle of maximal de-coupling: all WSMO components are specified
autonomously, independent of connection or interoperability with other
components.

6
 • Principle of strong mediation: the connection and interplay between different
components are managed by mediators which can resolve possible occurring
heterogeneities.
WSMO has four major components: Ontologies, Goals, Web Services, and
Mediators.
• Ontologies define terminology and formal semantic for describing the other
elements in WSMO. They provide concepts and relationships among the set of
concepts which are defined and agreed upon by communities of users. An ontology
consists of non-functional properties, imported ontologies, and the definition of
concepts, relations, axioms, functions, and instance of the ontology.
• Goals describe user requests that are resolved by executing a Web Service. The
requests are expressed as logical expression in WSMO on basis of domain
ontologies. They contains non-functional properties, imported ontologies,
mediators used, post conditions and effects.
• Web Services component provides the semantic description of Web Services,
including their functional and non-functional properties, as well as other aspects
relevant for interoperating with them.
• Mediators are connectors that resolve the heterogeneity problems in order to enable
interoperation between heterogeneous parties.

GOALS

ONTOLOGIES WEB SERVICES

MEDIATORS
Figure 2: The core components of WSMO [22], [23].
Web Service Modeling Language (WSML) is a language framework for Semantic
Web Service, based on conceptual model of WSMO. WSML has different variants which
are based on different formalisms, namely Description Logic, First Order Logic, and Logic
Programming [23].
• WSML-Core: this language is defined by the intersection of Description Logic and
Horn Logic. It has the least expressive power in the WSML family. Thus it has the
most preferable computational characteristic. The main features of the language are
the support for modeling classes, attributes, binary relations and instances. It also
supports class hierarchies and relation hierarchies. This language is fully compliant
with a subset of OWL.
• WSML-DL: this is an extension of WSML-Core, which captures the Description
Logic SHOIN(D). It can be seen as an alternative syntax for OWL-DL, based on
the WSMO conceptual model.
• WSML-Flight: this is an extension of WSML-Core in the direction of Logic
Programming. WSML-Flight has a rich set of modeling primitives for modeling
different aspects of attributes, such as value constraints and integrity constraints.

7
 Furthermore, WSML-Flight incorporates a fully-fledged rule language, while still
allowing efficient decidable reasoning. To be more precise, WSML-Flight allows
writing down any Datalog rule, extended with inequality and (locally) stratified
negation. WSML-Flight is based on OWL-Flight.
• WSML-Rules: it extends WSML−Flight to a fully-fledged Logic Programming
language, including function symbols. WSML−Rule no longer restricts the use of
variables in logical expressions.
• WSML-Full: this language unifies all WSML variants under a common First-Order
umbrella with non-monotonic extensions which allow capturing non-monotonic
negation of WSML-Rule. The syntax for WSML-Full is in fact as the basic syntax
for WSMO.

2.2.2 Automatic Web Service Composition

The second research stream is automatic Web Service composition. In this stream,
the majority of researches propose to apply the AI planning techniques to automate
composition process. The general planning problems can be described by the five-tupple
(S, S0, G, A, Г) [2].
• S: set of possible states of the world
• S0: the initial states, S0 ⊂ S
• G: goal states, G ⊂ S
• A: set of actions
• Г: translation relation which specify the world will change from the state S 1 to the
state S2 after executing the action A, (Г ⊆ S x A x S)
The plan is the sequence of actions that can change the world from the initial state
S0 to the goal states G. The description of the planning problems shows that the AI
planning is suitable to solve the automatic Web Service composition problems. A Web
Service can be considered as an action. Г may be used to describe the preconditions and
effects of a Web Service. G is the desired goal or the requests of the users. S0 is the initial
conditions of the users. Thus the composition description is the generated plan that
archives the desired goals.
There are many AI planning techniques are applied into automatic Web Service
composition. The main four of them are situation calculus, theorem proving, hierarchical
task network, and rule based.
First, the situation calculus planning was proposed by Sheila McIlraith and Tran
Cao Son [5]. This solution implemented in Golog programming language built on top of
situation calculus. In situation calculus, the do(a, s) function is defined as the map a
situation s and action a to a new situation. A situation calculus theory D comprises
domain-independent foundational axioms of the situation calculus, Σ; accessibility axioms
for K (special fluent knowledge to deal with sensing actions), K init; successor state axioms,
Dss; action precondition axioms, Dap; axioms describing the initial situation, DSo; unique
names axioms for actions, Duna; domain closure axioms for actions, Dca. The problem that
has to be solved is defined as following: “Given a domain theory D and a Golog program
δ, find a sequence of execution a so that D╞ Do(δ, S0, do(a , S0)) ”. Do(δ, S0, do(a ,
S0)) has the meaning that the program δ will start at the situation S0 and legally terminate at
do(a , S0) where do(a , S0) stands for do(an, do(an-1,…do(a1,do(a0,S0))))). The steps of
automatic Web Service composition in situation calculus planning are following:
• Creating the generic procedures
• Translating service description in DALM-S and requests into situation calculus

8
 • Customizing the appropriated generic procedure
• Generating and executing the a sequence of requests to Web Services to perform
the desired tasks
Second, Jinghai Rao, Peep Küngas and Mihhail Matskin recommended using
theorem proving technique [6]. It is based on the Propositional Linear Logic (LL). LL is a
refinement of the classical logic. It was claimed that LL was useful as a declarative
language and inference system. This logic has the expressive power to describe functional
and non-functional attributes of the Web Services. The intuition of adopting theorem
proving in automatic Web Service Composition is described as following:
• Translate service specification (DAML - S) into LL extralogical axioms
• Translate service request into the form of theorem to be proven
• Prove the specified theorem using the LL inference rules
• If the theorem is proven, extract the process model from the completed proof
generated by the LL theorem prover
• Otherwise, request should be re – formulated or existent service specification
should be modified
The third used technique is hierarchical task network (HTN) [7, 8]. The basic idea
is to create plan by task decomposition. The complex tasks are decomposed into smaller
and smaller subtasks until the primitive tasks that can be executed directly are found. Thus
this is suitable to Web Service composition. The desired Web Services, which is often
complex, are decomposed until the primitive Web Services are found. The current
implementation is SHOP2 (Simple Hierarchical Ordered Planner). SHOP2 is the domain
independent HTN planning system. One difference between SHOP2 and most other HTN
planning systems is that SHOP2 plans for tasks in the same order that they will later be
executed. Planning for tasks in the order that those tasks will be performed makes it
possible to know the current state of the world at each step in the planning process, which
makes it possible for SHOP2’s precondition-evaluation mechanism to incorporate
significant inference, reasoning power and the ability to call external programs. This makes
SHOP2 ideal as a basis for integrating planning with external information sources. The
following steps are implemented in SHOP2 to generate the composite plan.
• Encoding OWL-S process models as SHOP2 domain
• Encoding OWL-S Web Services Composition Problem as SHOP2 Planning
Problem
• Generating plan by SHOP2 algorithm
• Converting the SHOP2 plan to OWL plan. The final result is the sequence of Web
Service calls, which are subsequently executed.
Finally, Shankar R. Ponnekanti and Armando Fox implemented rule based planning
in SWORLD, developer toolkit for Web Service composition [9]. This toolkit used its own
way to describe the Web Service. Entity relationship model is employed to specify the
services. Services are modelled by the preconditions and effects. For each service, a rule is
defined that the effects are archived if the proconditions are true. The composite services
are also specified by the initial states and final states. Then the composite plan is generated
by the rule engine. However, the authors agured that the ruled based chaining in SWORLD
can sometimes generate the uncertain results.
Consequently, the four methods mentioned above apply different techniques to
automate the composite process. Each method has a new contribution to this research area.
However, there are still many obstacles that need to be solved. These problems will be
discussed in the next subsection.

9
After doing survey on researches in Web Service Composition, Jinghai Rao and Xiaomeng
Su have come up with a general framework for composing Web Service [2]. This
framework may appear in the methods mentioned above and the others.

INTERNAL SPECIFICATION
EXTERNAL SPECIFICATION PROCESS
TRANSLATOR
GENERATOR
PROCESSES

SERVICE REQUESTERS PROCESSES SERVICE SPECIFICATION

RESULT

SERVICE SPECIFICATION
SERVICE
EXECUTION REPOSITORY
EVALUATOR
ENGINE A PROCESS

SERVICE PROVIDER

Figure 3: General Web Service composition framework [2].

In the framework, there are two participants, service requesters and service
providers. Service providers offer and publish the services to the service repository. The
service requesters are people who consume the service of the service providers. The
translators translate between the external languages used by the participants and the
internal languages that are compatible with the process generator. The process generator
will generate the composition plan that composes the existing services in the service
repository to satisfy the specific requests. If more than one plan is generated, the evaluator
will evaluate all the plans. The most reasonable plan is proposed to be executed.
Thereafter, the execution engine will perform the composition plan and return the results to
the service requesters. The proposed framework can be the general framework for many
composition methods in automatic Web Service composition. In comparison, the AI
planning methods in automatic Web Service composition may adopt the framework similar
to this framework. The process generator plays the role as the AI planner.

2.2.3 Current problems

AI planning is suitable for automating Web Service composition. However, there
are many problems when applying AI planning techniques to this area.
First, the AI planners use the closed world assumption with negation as failure [10].
This means that a statement or a predicate can only have one value, truth or falsity. A
statement can be assumed to be true on the basis of failure to prove it. For example, to
prove a predicate P that is true in a knowledge base K, people often prove that the union
between K and negation of P is inconsistent. In contrast, the advanced web service
description languages have open world semantic. For instance, the statement that is not
true in OWL – S can be not false. This difference creates a mismatch between the planners
and the service description languages.
Second, the AI planners have limited reasoning capabilities. Most of planners
employ their own languages to express the domain information, such as preconditions and
effects of Web Services, desired goals, constraints, and user preference. But these logics
have less expressiveness than current ontology languages, OWL and OWL – S. Therefore,
Planning Domain Description Language (PDDL) was created to provide more expressive

10
power when describing the planning problems and many planners have been changing their
input forms to be compatible with PDDL. The service descriptions in OWL-S and other
information in OWL will be translated into PDDL before being processed by the AI
planners. However, this language still has many disadvantages, such as closed world
assumption, non-XML format, etc. Thus the semantic of problem descriptions may be lost
during the translation.
Third, the information in Web Service world may be incomplete. The composition
process sometimes has to inquire information from the outside environment. Thus the
information providing services are necessary occasionally. On the other hand, the planners
assume that they have all information about the world. It is also the gap when applying AI
planning to the Web Service composition.
The fourth obstacle is the non-deterministic behaviors of the Web Service. The
service may fail during the execution or it may produce the uncertain results. The service
can also return the new object that is undefined in result.
In addition, search space to find the plan is also the problem. For example, in the theorem
proving method, since the amount of available services and the size of the ontology models
are huge, it is necessary to reduce the search space during problem solving [6].
Finally, the last two problems that should be considered are about the complex
services and business models. Most of planners deal with the primitive services. However,
the complex services, which have been composed by planners, can be considered as the
new primitive services. This increases the reuse of composed service and may decrease the
planning time. Moreover, the business models that specify the relationships among
multiple services should be participated in the planning processes. This may help to
increase the precision of the generated plans.
In conclusion, AI planning is suitable approach to solve automatic Web Service
composition. However, there are several disadvantages when applying AI planning to this
research area. Thus the next section will describe general idea of the new method for
automating Web Service composition and how the current obstacles can be improved. In
addition, a new Web Service composition framework is proposed and discussed. The
technology for new method is also introduced.

11
 3 METHODOLOGY
Equivalent Transformation (ET) invented by Prof. Kiyoshi Akama of Hokkaido
University is a new computational paradigm which is based on semantic preserving
transformations. A given declarative description is transformed successively and
equivalently into a simpler description until a description in which answers can be directly
or easily obtained is reached. Based on Equivalent Transformation, the proposal proposes a
new approach to automatic Web Service composition. The idea of new approach is to
employ XML document transformation which is based on Equivalent Transformation to
generate the composition plan of Web Services automatically.
More precisely, the user requests or desired goals, constraints, preference and the
given service descriptions are expressed by a powerful language, such as WSML. This
information and the business process models will be combined into one XML formatted
document that describes the domain problem to be solved. In addition, the ET rules, which
have to satisfy the semantic preserved condition, are defined. Thereafter, a transformation
mechanism will transform this XML document to generate the composition description
documents in which the desired goals are archived. The final results are expressed in term
of Web Service composition languages, such as BPEL4WS.
With this new approach, the problems of exploiting AI planning may be overcome.
First, the domain problems are described in the powerful languages which have opened
semantic. These languages can express fully the main semantic of problems. This may
increase the precision of the solutions. Second, the computation and reasoning are done
directly on the description languages. The input information does not have to translate into
another forms such as PDDL. Thus the meaning of the descriptions will not be lost during
the translation. The reasoning capabilites also increase because of doing reasoning on the
expressiveness languages. Third, the transformation engine does not have to have complete
information about the Web Service world during the transformation process. It can obtain
information from the information providing services since that is necessary. The fourth
obstacle can be solved by adding the exception handlers in form of ET rules. This may
make the composition process more flexible and automatic. In addition, the solutions may
be implied in the problem description. The transformation engine just transforms the
problems until the solutions are reached. It does not have to search for the solutions. As a
result, the search space problem can be overcome. Moreover, the business models can be
participated as the service composition templates when creating the problem descriptions.
It helps to increase the accuracy of the generated composition descriptions. Finally, due to
employing the expressiveness and powerful languages to describe the domain problems
such as desired goals, constraints, user preference, etc, the complex services that are
already composed can be considered as primitive services in the transformation process.
This increases the reuse of services and decreases the computation time.
In addition to the new approach to automatic Web Service composition, the
proposal also proposes a new Web service composition framework in which the new
approach will be implemented. This framework is based on the framework of Jinghai Rao
and Xiaomeng Su [2], mentioned in section 2.2.2.

12
 SERVICE SPECIFICATION SERVICE DOMAIN
BUSINESS
REPOSITORY ONTOLOGY
MODELS
(WSML) (WSML)

SERVICE PROVIDERS

USER REQUESTS
CONSTRAINTS
PREFERENCE ET RULES
ET RULE
TRANSFORMATION ENGINE
REPOSITORY
(XET)

SERVICE REQUESTERS COMPOSITION DESCRIPTIONS

(BEPL4WS)

Figure 4: Web Service composition framework for BPEL4WS document generation approach

The framework has two participants, service providers and service requesters. The
framework also has main component, transformation engine. The transformation engine
takes service descriptions, business models, user requests, constraints and preference,
which are expressed by an expressive language, as inputs. Thereafter, it transforms this
information until the composition description documents are generated. The semantic will
be preserved during the transformation process. The transformation engine can also do
reasoning on the problem description if it is necessary. In addition, the framework consists
of main repositories: service repository, business models repository, domain ontology, and
ET rule repository. First, the service repository contains the descriptions of the primitive
Web Services. The descriptions of complex Web Services, which are already composed,
are also stored in this repository. Second, the business models repository stores the
business models that are necessary for the problem domain in form of BPEL4WS
templates. Third, domain ontology consists of the ontology about the problem domain.
Finally, the ET rule repository stores all the equivalent transformation rules that the
transformation engine uses to produce the solutions.
The intended technologies will be used to implement the framework‘s prototype are
WSMO\WSML, BPEL, XET [11], and Java technology.
Firstly, WSMO has a clear separation among four major components: ontology,
goals, Web Services and mediators. As a result, it is compatible to apply to the proposed
framework. For example, ontology, goals, and Web Services can be used to express domain
ontology, user request and constrains, and Web Service description respectively. In
addition, WSML has strong expressiveness and formalization for semantic Web Service
and semantic web. Thus WSMO\WSML is suitable to express information in repositories
and user requests.
Secondly, BPEL has some advantages than other Web Service composition
languages, such as modeling the execution control, spawn off process and synchronization,
and event handling. It also has the widest acceptance in industry. Therefore, BPEL is
employed to describe the final results of the framework.

13
 Thirdly, the main rationale of the new approach is document generation using
equivalent document transformation rules. As a result, XET is a suitable for expressing all
the transformation rules.
Finally, because all the documents using in the framework are in XML format and
Java has many components for XML processing, the transformation engine will be
programmed in Java language. In addition, some necessary user interfaces will be
implemented in Web based using Java technology.
The thesis will be done in two semesters. The following table depicts the detail
work and time.

Work detail Estimated time

9 10 11 12 1 2 3 4
Design the approach detail
Formalize the approach
Design the framework components
Implement the components
Test, fix bugs and evaluation
Collect documents and edit thesis report

In conclusion, equivalent document transformation is proposed to apply to

automatic Web Service composition. It may be a new approach in this research area. A new
framework for implementing this new approach is also proposed. In order to implement the
framework’s prototype, the following main technologies will be employed, namely
WSMO\WSML, BPEL, XET, and Java technology

14
 4 REFERENCE
1. Heather Kreger (2001), Web Services Conceptual Architecture (WSCA 1.0), IBM
Software Group.
2. Jinghai Rao and Xiaomeng Su (2004), A Survey of Automated Web Service
Composition Methods
3. Chris Peltz(2003), Web Services Orchestration. A review of emerging technologies,
tools and standards, Hewllett Packard White Paper, January 2003.
4. David Martin, Mark Burstein, Jerry Hobbs, Ora Lassila, Drew McDermott, Sheila
McIlraith, et al, OWL-S: Semantic Markup for Web Services, DARPA Agent
Markup Language web site: http://www.daml.org.
5. Sheila McIlraith and Tran Cao Son (2002), Adapting Golog for Composition of
Semantic Web Services, In Proceedings of the Eighth International Conference on
Knowledge Representation and Reasoning.
6. Jinghai Rao, Peep Küngas and Mihhail Matskin, Logic-based Web Services
Composition: from Service Description to Process Model, In Proceedings of the
2004 International Conference on Web Services, San Diego, USA, July 2004.
7. Evren Sirin, Bijan Parsia, Dan Wu, James Hendler, and Dana Nau. HTN planning
for web service composition using SHOP2. Journal of Web Semantics, 1(4):377-
396, 2004.
8. Dan Wu, Bijan Parsia, Evren Sirin, James Hendler, and Dana Nau, Automating
DAML-S Web Services Composition Using SHOP2, In Workshop on Planning for
Web Services, Trento, Italy, June 2003.
9. S. R. Ponnekanti and A. Fox, SWORD: A developer toolkit for Web service
composition, In Proceedings of the 11th World Wide Web Conference, Honolulu,
HI, USA, 2002.
10. Evren Sirin and Bijan Parsia, Planning for semantic web services. In Semantic Web
Services Workshop at 3rd International Semantic Web Conference
(ISWC2004),2004.
11. Wattanapailin V. (2000). A Declarative Programming Language with XML,
Master’s Thesis, Computer Science and Information Management Program, Asian
Institute of Technology, Thailand.
12. Chutiporn Anutariya (2001), XML declarative description, Dissertation, Computer
Science and Information Management Program, Asian Institute of Technology,
Thailand
13. Joachim Peer, A PDDL Based Tool A PDDL Based Tool for Automatic Web Service
Composition
14. Biplav Srivastava and Jana Koehler, Web Service Composition – Current Solutions
and Open Problems
15. Sheng Huang, Xiaoling Wang, Aoying Zhou, Efficient Web Service Composition
Based on Syntactical Matching
16. Nikola Milanovic and Miroslaw Malek, Current Solutions for Web Service
Composition
17. D. Fensel and C. Bussler, Web service modeling framework
18. Joachim Peer, Towards Automatic Web Service Composition using AI Planning
Techniques
19. McIlraith, S. and Fadel, R., Planning with Complex Actions'. In Proceedings of the
Ninth International Workshop on Non-Monotonic Reasoning (NMR2002), pages
356-364, April, 2002

15
20. Chris Peltz(2003), Web Service Orchestration and Choreography, A look at WSCI
and BPEL4WS, Hewllett Packard White Paper, July 2003.
21. Cheng Yushi, Lee Eng Wah, Dilip Kumar Limbu, Web Services Composition – An
overview of standards. Synthesis 2004 Journal, Information Technology Standards
Committee, An Industry Partnership Supported by SPRING Singapore & IDA,
2004.
22. Ioan Toma,Michael Stollberg, Jos de Bruijn, Axel Polleres, Rub´en Lara, Semantic
Web Fred – Language Evaluation and Comparison, Draft 2, DERI August 2004.
23. Rub’en Lara, Axel Polleres, Holger Lausen, Dumitru Roman, Jos de Bruijn, and
Dieter Fensel, A Conceptual Comparison between WSMO and OWL-S, Final
Draft, DERI April 2005.
24. Steve Battle, Abraham Bernstein, Harold Boley, et, Semantic Web Services
Framework (SWSF) Overview, version 1.0, the Semantic Web Services Language
Committee of the Semantic Web Services Initiative, May 2005.
25. Steve Battle, Abraham Bernstein, Harold Boley, et, Semantic Web Service
Ontology, version 1.0, May 2005.
26. Steve Battle, Abraham Bernstein, Harold Boley, et, Semantic Web Service
Language, version 1.0, May 2005.

16