Semantic Composition of Business Processes using Armstrong’s Axioms

The Knowledge Engineering Review, Vol. 00:0, 1–24. c 2004, Cambridge University Press DOI: 10.1017/S000000000000000 Printed in the United Kingdom Semantic Composition of Business Processes using Armstrong’s Axioms DUYGU CELIK1 and ATILLA ELCI2 1 Computer Engineering Department, Eastern Mediterranean University, Gazimagusa, North Cyprus, Mersin 10, Turkey 2 Computer Engineering Department, Toros University, Mersin, Turkey E-mail: duygu.celik@emu.edu.tr, aelci@acm.org Abstract Lack of sufficient semantic description in the content of Web services makes it difficult to find and compose suitable Web services during analysis, search, and matching processes. Semantic Web Services are Web services that have been enhanced with formal semantic description which provides well-defined meaning. Due to insertion of semantics, meeting user demands will be made possible through logical deductions achieving resolutions automatically. We have developed an inference-based semantic business process composition agent (SCA) that employs inference techniques. The semantic composition agent system is responsible for the synthesis of new services from existing ones in a semi-automatic fashion. SCA System composes available OWL-S atomic processes utilizing Revised Armstrong’s Axioms (RAAs) in inferring functional dependencies. RAAs are embedded in the knowledge base ontologies of SCA System. Experiments show that the proposed SCA System produces process sequences as a composition plan that satisfies user’s requirement for a complex task. The novelty of the SCA System is that for the first time Armstrong’s Axioms are revised and used for semantic based planning and inferencing of Web services. 1 Introduction With contributions from Semantic Web technology, Web services are enhanced using rich description languages such as Web Ontology Language (OWL, 2004). Semantic Web Services (SWSs, McIlraith, 2001) are Web services which have been enhanced with formal semantic descriptions in Web Ontology Language for Web services (OWL-S, 2004). OWL-S is an OWL based Web services ontology providing Web service suppliers with a core set of markup languages that is designed for describing properties, functions, and access information for Web services in a computer-interpretable form. All structural information of Web services can be embedded through OWL-S ontology. It includes three complimentary models serving this purpose:Profile, Process, andGrounding . Profile model describes what function a service provides or operates. While process model is a functional description of how a service works, procedure ends with grounding model describing how to access the service. Inputs, Outputs, Preconditions, and Effects (I/O/P/E) are concepts of an atomic process in the OWL-S process model. Inputs and Outputs specify data transformation produced by the process. Inputs describe the information that is requested from a user/agent before executing a process. Outputs describe the information that a process produces after its execution. Preconditions are conditions that are imposed upon Inputs for a process prior to its invocation. An Effect can be defined as a proposition that will become true when the execution is completed. 2 d. celik and a. elci In this article, emphasis is on Web services composition utilizing atomic business processes. Web services composition addresses a situation where a client’s request cannot be met by a single available service; it can however be satisfied by suitably combining multiple existing services. Therefore, we concentrated on the process model of the OWL-S ontology for semantic annotation. The reason is that it provides good support for describing data and control constructs of individual Web services, with clear semantics for describing profile, process, and grounding models. Decomposition of composite processes lies outside the scope of the present study. It is assumed that all composite processes of SWSs have been already decomposed into atomic processes before planning task of the composition can be initiated. This paper proposes a composition model involving an inference-based semantic business process composition agent (SCA) for verifying compatibility and composition of OWL-S atomic business processes. The SCA System performs composition task in order to sequence execution of business processes in such an order that accomplishes a client’s complex process requirement. Framework of the SCA System was designed; a prototype was implemented and tested on a corpus of Semantic Web Services in order to demonstrate it. The rest of this paper is organized as follows: Section 2 introduces the proposed SCA System. Section 3 investigates the Ontology and Rule Knowledge bases used in SCA. In Section 4, OWL-S process model is introduced in order to gather useful metadata from descriptions of SWSs. While Section 5 presents the sample SWSs corpus used, Section 6 takes up the Revised Armstrong’s Axioms (RAAs) in more detail identifying how we obtained them. Section 7 describes design aspects of process inferencing through the RAAs and case studies. In Section 8, the Process Equivalency Task is described and discussed which concludes the composition task. Sections 9 and 10 are dedicated to related works and conclusions respectively. 2 The inference-based semantic business process composition agent (SCA) The proposed SCA System has five main parts which are as follows: translator , planner , inference engine, execution engine, and monitoring agent. The system has three ontology knowledge bases (Tasks-TKBO, Concepts (or Domain-CKBO) and Processes-PKBO), and one Rule Knowledge Base (RKB) that contains the Revised Armstrong’s Axioms. SCA composes OWL-S based atomic processes using a novel planning method through the Revised Armstrong’s Axioms (RAAs). The Armstrong’s Axioms (AAs) (or more precisely, Armstrong’s inference rules) are a set of axioms that are used to infer functional dependencies on a relational database. They were developed by William W. Armstrong in his paper titled Dependency Structures of Data Base Relationships (Armstrong,1974). We revised AAs in order to shorten inference chains while preserving the integrity to derive functional dependencies of the processes, and used in this work during the inferencing and planning phase. The novelty of the SCA System is that for the first time such a study revises the AAs and employs them in semantic based planning and inferencing of Web services. This article proposes embedding the AAs in ontologies for finding appropriate composition plans of OWL-S based atomic processes. The architecture of the SCA System is depicted in Figure 1; main parts of SCA are introduced below: • The Translator performs a parsing task of knowledge bases namely, translating all atomic tasks in TKBO, all atomic processes of SWSs (candidates) in PKBO and goal process of client into I/O/P/E form. The translator utilizes the Tasks, Concepts and Processes ontology KBs, and details translation from OWL-S process model to I/O/P/E form. According to I/O/P/E modeling, a given set of task instances in the TKBO and atomic processes in the PKBO (e.g. Pi ) are converted into the form Pi ≡Ii →Oi , where its inputs are Ii ≡Ii1 ∧Ii2 ∧. . . ∧Iik and its outputs are Oi ≡Oi1 ∧Oi2 ∧. . . ∧Oim . The logical expression of Pi ≡Ii →Oi determines that Oi is obtainable only if Ii is available. The linear implication operator (‘→’) asserts that, Ii is consumed and Oi is produced. Domain related atomic tasks in TKBO, candidate SWSs and goal process in I/O/P/E form are passed on to the planner. Semantic Composition of Business Processes using Armstrong’s Axioms • • • 3 The Planner is in the heart of the SCA System. It tries to find an execution sequence of processes using the predefined tasks (TKBO) and candidate SWSs (PKBO) while satisfying the requested complex goal process. In matching parameters, when the planner needs to find out similar concepts, it calls on the inference engine. The Inference Engine (IE) performs inferencing on the processes of candidate SWSs using the RAAs. A suitable RAA rule from the RKB is picked and then applied to a pair of task instances (or processes). If a new complex process is produced, it is then sent to the planner for checking its suitability. The inference engine and the planner are thus coordinated to work in alternating sequence in each iteration. In summary, there is a complex goal process G≡IG →OG , with IG ≡IG1 ∧IG2 ∧. . . ∧IGj inputs and OG ≡OG1 ∧OG2 ∧. . . ∧OGh outputs. Given a path, P, is planned by SCA, the question is whether P is canonically implied by G (PG) or not. To resolve this question, we used a process derivation task that employs the RAAs inference rules. Inferencing using the RAAs is taken up in Section 6. The Execution Engine (EE) executes the planned sequence of OWL-S based atomic processes. The sequence defined by the Planner and IE must meet the client’s goal. In this paper, it is assumed that all OWL-S based atomic processes in the planned sequence are implemented as individual SWSs and the executions of these atomic processes are triggered by the invocations of the SWSs through Grounding of OWL-S. Finally, the Monitoring Agent (MA) monitors proper execution of the atomic processes of the composite process during the execution stage. In the last two steps, the system initiates the execution of all the components/processes in the defined plan path. After the execution, the SCA serves the result to the client. Figure 1 Architecture of the SCA System 3 Knowledge base ontologies of the SCA system Semantic Web is an extension of the current Web where information has a well-defined meaning. This better enables cooperation between computers and people (T. B. Lee et al., 2001). Ontology, i.e., the conceptual language of the Semantic Web, is a specification of a conceptualization of a knowledge domain. It is a controlled vocabulary that formally describes objects and their relationships. As mentioned above, the SCA uses three ontology knowledge bases, namely, Tasks, 4 d. celik and a. elci Concepts (or Domain), and Processes knowledge bases. Effective detailing of the knowledge bases will help understanding mechanics of the SCA System. They are introduced below. 3.1 Task Knowledge Base Ontology (TKBO) TKBO is a common ontology that contains capability corresponding to functionality provided by Web services. TKBO provides an extensive ontology of functions or tasks. Using TKBO, Web services may be defined as instances of classes that represent their capability based on OWL-S descriptions on their service site. Furthermore, SCA System may use the TKBO during its stages for discovery, composition, and invocation of services. This is necessary in order to distinguish processes according to their functional semantics since the services may have the same inputs and outputs but have different functional semantics. The following ontology snippet presents an excerpt from the TKBO model. TKBO is used by a semantic Table 1 Beginning part of the TKBO <!—Datatype Properties for I/O/P/E Parameters of Tasks –> 1 <owl:DatatypeProperty rdf:ID=“Input Parameter”/> 2 <owl:DatatypeProperty rdf:ID=“Output Parameter”/> 3 <owl:DatatypeProperty rdf:ID=“Effect Parameter”/> 4 <owl:DatatypeProperty rdf:ID=“Precondition Parameter”/> 5 <owl:Class rdf:ID=“Tasks” /> 6 <owl:Class rdf:ID=“e Commerce Service”> 7 <rdfs:subClassOf rdf:resource=“#Tasks”/> 8 </owl:Class> 9 <owl:Class rdf:ID=“Information Service”> 10 <rdfs:subClassOf rdf:resource=“#e Commerce Service”/> 11 </owl:Class> 12 <owl:Class rdf:ID=“Buying Service”> 13 <rdfs:subClassOf rdf:resource=“#e Commerce Service”/> 14 </owl:Class> 15 <owl:Class rdf:ID=“Selling Service”> 16 <rdfs:subClassOf rdf:resource=“#e Commerce Service”/> 17 </owl:Class> 18 <owl:Class rdf:ID=“Book Buying”> 19 <rdfs:subClassOf rdf:resource=“#Buying Service”/> 20 <Input Parameter rdf:datatype=“&Concepts;ISBN”>ISBN</Input Parameter> 21 <Output Parameter rdf:datatype=“&Concepts;Price”>PriceOfBook</Output Parameter> 22 <Precondition Parameter rdf:datatype=“&xsd;anyURI”>BookInStock</Precondition Parameter> 23 </owl:Class> based SCA System for matching service capability during the inferencing and planning stage. In the TKBO, semantic task contexts of task instances are embedded by using the OWL semantic tags such as <owl:class>, <rdfs:subClassOf>, <owl:ObjectProperty>, and <owl:DatatypeProperty >. For example, the semantic task contexts in Table 1 are used to explain that the Tasks, e Commerce Service, Information Service, Buying Service, Selling Service, and Book Buying are as <owl:class> classes, which keeps semantic based descriptions for instances of tasks in e-commerce area. The line 5 declares that there is a class named Tasks using the tag <owl:class>, and the line 6 describes that there is another class named e Commerce Service which is a kind of Tasks using the tag <rdfs:subClassOf> at line 7. Other classes of the other tasks instances are described similarly. The lines 1–4 present defined <owl:DatatypeProperty> properties Input Parameter , Output Parameter , Precondition Parameter , and Effect Parameter . The lines 18-23 present a Book Buying task having an Input Parameter (at line 20) that specifies the association between the Book Buying task and the Input Parameter by <owl:DatatypeProperty>. The meaning of the association is that the Book Buying task contains only one input which is ISBN . All other output, precondition and effect parameters of the Book Buying task are described in the same format (lines 21-22; and there is no effect parameter). In this manner, various meanings related to the task can be described in the semantic task contexts. Details of inferencing and planning using <owl:ObjectProperty> are presented in Section 7. Semantic Composition of Business Processes using Armstrong’s Axioms 3.2 5 Concepts Knowledge Base Ontology (CKBO) CKBO is a rich ontology knowledge base that contains concepts of domains (of interest). The ontology keeps the classes/concepts of interested domain(s). The concepts in CKBO provide connection between I/O/P/E parameters of declared task instances in TKBO and those of OWLS based atomic processes in PKBO. The dataset of the OWL-S atomic processes (in PKBO) and concepts ontology file (CKBO) in a widely used test collection can be found on SemWebCentral Website1 . 3.3 Process Knowledge Base Ontologies (PKBO) PKBO is a repository that contains the OWL-S based atomic processes of the candidate SWSs in the domain of interest. As mentioned above, we used a test collection that is extensively used in the Semantic Web research studies. It is very possible that a semantic based discovery agent can find suitable SWSs related to client’s request. Discovery of SWSs possibly required also for composing a sequence of processes in order to meet client’s request is discussed in our previous work (Celik & Elci, 2008). Here it is assumed that the discovery task would have been performed before initiating the composition task of the SCA. Thus the system will be ready for a composition task since the discovery task had already returned a set of OWL-S atomic processes of related SWSs (called the set of candidate SWSs). In SCA, OWL-S files of atomic processes of candidate SWSs are collected in the PKBO. 3.4 Rule Knowledge Base (RKB) RKB keeps the predetermined inference rules, namely Revised Armstrong’s Axioms (RAAs), a set of axioms used to infer new processes from a set of available ones. 4 Semantics in the OWL-S process model In this section, we introduce semantic descriptions of Web services through OWL-S. An OWL-S Profile characterizes two aspects of service functionality: information transformation which is represented by Inputs and Outputs, and state change which is produced by an execution of a service. 1 <service:Service rdf:ID=”BookPrice”> 2 </service:Service> 3 <process:AtomicProcess rdf:ID=“BookPrice-Process”> 4 <process:hasInput rdf:resource=“#BookName”/> 5 <process:hasOutput rdf:resource=“#PriceOfBook”/> 6 <process:hasPrecondition> 7 8 9 <expr:SWRL-Condition rdf:ID=“BookInStock”> <expr:expressionLanguage rdf:resource=“http://www.daml.org/.../Expression.owl#SWRL”/> <expr:expressionBody rdf:parseType=“Literal”> 10 </expr:SWRL-Condition> 11 </process:hasPrecondition> 12 </process:AtomicProcess> For example, to complete a sale, a book-selling service may require the name of a book as input, and the fact that the book is in stock (the precondition). The result of the sale encompasses production of a receipt that confirms the proper execution of the transaction, transfer of ownership, shipment of the book, and reduction of stock (as effect). The above given OWLS fragment exemplifies a BookPrice SWS2 that contains an atomic BookPrice-Process. 1 2 http://projects.semwebcentral.org http://www.w3.org/Submission/OWL-S/ 6 d. celik and a. elci The process has one input “BookName”, output “PriceOfBook” and one precondition “BookInStock” (at lines 4, 5 and 7). Let’s take up a BookSearch SWS with a single atomic process called BookSearch-Process. The atomic service has only one input “BookTitle” and one output “Book” of parameter type Concepts.owl#Title and Concepts.owl#Book respectively. Here we give snippets of code for OWL-S of sample BookSearch SWS3 . 1 <service:Service rdf:ID=“BookSearch”> 2 <process:AtomicProcess rdf:ID=“BookSearch-Process”> 3 <process:hasInput rdf:resource=“#BookTitle”/> 4 <process:hasOutput rdf:resource=“#Book”/> 5 </process:AtomicProcess> 6 <process:Input rdf:ID=“BookTitle”> 7 8 9 <process:parameterType rdf:datatype=“http://..ontology/Concepts.owl#Title”/> <rdfs:label>Book Title</rdfs:label> </process:Input> 10 </service:Service> Each process:parameterType has a type specified using an URI. The type can be defined by the service provider as either a class/concept or a specific xmlDatatype, and the parameter must be associated with a concept in the domain ontology of the service. Let’s consider the OWL-S declarations of inputs “BookTitle” of BookSearch-Process and “BookName” of BookPrice-Process as given below. 1 <service:Service rdf:ID=“BookPrice”> 2 <process:AtomicProcess rdf:ID=“BookPrice-Process”> 3 4 5 <process:Input rdf: ID=“BookName”> <process:parameterType rdf:resource=“http://www.w3.org/2001/XMLSchema#string”/> </process:Input> 6 </service:Service> Clearly these inputs have the same meaning, but they are declared differently by their providers. Furthermore, the process:parameterType property of the first is defined as Concepts.owl#Title and of the second as XMLSchema#string . A service with the process:parameterType defined as string may be composed with any other service as any service can return a string as an output. This situation would make proper composition more difficult due to the availability of unrelated services because of inadequate semantic description. Unfortunately, the use of standard XMLSchema data types such as string, integer, double etc. in the properties of process:parameterType can lead to missed semantic matching of processes in the search of suitable processes of candidate SWSs during the constitution of the required composition plan. During planning phase, a semantic search agent will not be able to notice the equivalency of those processes from either process:parameterType property or rdf:ID (input-output) concepts. To solve this problem, we used the Concepts.owl (CKBO). Each parameter type of task instances (in TKBO) or processes (in the PKBO) indicates a class in the Concepts.owl instead of using XMLSchema data types. 5 Sample SWSs corpus used The data set of the OWL-S based atomic processes (in PKBO) and an ontology of concepts (CKBO) used in this paper can be found on SemWebCentral Website1 . The most commonly used test collection SWS-TC3 includes 241 OWL-S based SWSs. This test collection is selected since the average quality of the descriptions is somewhat better than other test collections. The 3 http://projects.semwebcentral.org/projects/sws-tc/ Semantic Composition of Business Processes using Armstrong’s Axioms 7 OWL-S descriptions of 241 different SWSs in the SWS-TC3 are analyzed in the Translator stage of the SCA, and some ontological data were extracted such as the Effects (I/O/P/E), parameter name and parameter type (as an ontological reference). Table 2 Seven atomic processes from the SWS-TC 1.1 with I/O/P/E parameters SWS Name Input AmazonBookPrice BookInformation<#Book> CurrencyConvertor InputAmount<#Price>, SourceCurrency<#Currency>, DestinationCurrency<#Currency> Getbookprice BookInfo<#Book> BookInStock BookInfo<#Book> BookPrice Book<#Book> Output BookPriceValue<#Price> OutputAmount<#Price> Precondition Effect NULL NULL NULL NULL BookPrice<#Price> ExistsInStock<#true-false> PriceOfBook<#Price> ResultCurrency<#Currency> NULL NULL NULL FindBookStore ISBN<#ISBN> BookSearch BookTitle<#Title> Bookstore<#Store>, BookPrice<#Price> Book<#Book> NULL NULL BookInStock <#truefalse> NULL NULL NULL NULL Table 2 depicts seven atomic processes of OWL-S based SWSs from the SWS-TC 1.13 with the information needed for the scope of this section. All of them have input and output concepts described in the form “rdf:ID<#process:parameterType>” and only one service contains a Precondition; no service has Effect. A possible scenario is that a user wants to find the price of a book by giving its title, and expects the price information in a specific currency such as the United States Dollars (USD). Assume that the goal task (G) is required by the client (G ≡ (BookTitle[Text]kInputCurrency[Currency]kDestinationCurrency[Currency])→BookPrice[Price]) where the “InputCurrency” is specified as Euro and “DestinationCurrency” is specified as USD by the user. We will continue with this scenario in the next section to show how RAAs are applied on OWL-S atomic processes. 6 Revised Armstrong’s Axioms (RAAs) Armstrong’s Inference Rules (also referred to as Armstrong’s Axioms-AAs) are a set of axioms used to infer functional dependencies (FDs) on a relational database. They were developed by William W. Armstrong in his paper titled Dependency Structures of Data Base Relationships (Armstrong, 1974). An inference axiom is a rule which states that if a relation satisfies certain FDs, it must also satisfy certain other FDs. There are seven axioms which are Reflexivity , Augmentation, Transitivity , Pseudo Transitivity , Additivity , Accumulation, and Projectivity as shown in Table 3. Five of them, namely, Transitivity , Pseudo Transitivity , Additivity , Projectivity , and Accumulation are applied exactly in the same fashion during the constitution of a composition plan by the Planner and IE of SCA. We tested and found them suitable for deriving the required process sequences for a composition. On the other hand, since the Reflexivity and Augmentation axioms applied in sequence performs like factorization; we combined them together in order to form a shorthand Pseudo Factorization axiom. By using these two rules separately by Planner of SCA System, the system is likely to generate many unsuitable derivative composition plans; perhaps even end up doing infinite iterations. The combined version for these two rules will not only eliminate unsuitable derivations, it will also reduce the complexity of composition. In addition, we renamed the Projectivity axiom as Dissection for the latter better expresses the intended operation. Table 3 displays AAs in the first column, corresponding RAAs (Revised Armstrong’s Axioms) in the second column. Let us assume that X, Y, Z, W, and T are classes/concepts of Input/Output parameters of an available process set and that the right arrow is the linear implication operator. Using example XkY→Z in the Table 3, we can understand that the concepts X and Y are taken as concurrent inputs (that is, XkY) while execution of the process, thus their order is not important. The outcome is the concept Z after execution. 8 d. celik and a. elci Table 3 Armstrong’s Axioms and Revised Armstrong’s Axioms. Armstrong’s Axioms 1. Reflexivity: A set of attributes X determines a subset Y of itself: X→Y if Y⊆X. 2. Augmentation: It allows enlarging the left-side of a FD or both side conventionally with one or more attributes. Formally, if X→Y then X||Z→Y||Z for any Z. 3. Transitivity: If we have functions f : X→Y and g : Y→Z then we have a function g O f : X→Z, where (g O f )(x) = g(f (x)). Formally, If {(X → Y) and (Y→Z)},then X→Z. 4. Pseudo transitivity: is a generalization of Transitivity. It is requires the entire right hand side of a FD appears as attribute(s) of the determinant of another FD. Formally, if {(X→Y) and (Y||Z→W)} then (X||Z→W). 5. Additivity: If there are two FDs with the same determinant on the left, it is possible to form a new FD that preserves the determinant and has as its right-hand side the union of the right-hand sides of the two FDs. Formally, if {(X→Y) and (X→Z)} then (X→Y||Z). 6. Accumulation: If there are two FDs with the complementary determinant, it is possible to form a new FD that preserves the determinant X and forms its right-hand side as the union of the right-hand sides of the two FDs except the complementary determinant Z. Formally, if {(X→Y||Z) and (Z→C||W)} then (X→Y||C||W). 7. Projectivity: If X determines Y and Z, then X determines Y, therefore it is possible to break each functional dependency X→Y down to X→Ai for i = 1..n where Y = {A1, . .An}. Formally, if (X→Y||Z) then X→Y and X→Z. Revised Armstrong’s Axioms 1. Pseudo factorization: If {(X||Y→Z), (T||Z→W)} and if (Z⊂T||Z and T≡X or T≡Y) then X||Y→W. 2. Transitivity: If {(X →Y) and (Y→ Z)} then (X→Z). 3. Pseudo transitivity: If {(X→Y) and (Y||Z→W)} then (X||Z→W). 4. Additivity: If {(X→Y) and (X→Z)} then (X→Y||Z). 5. Accumulation: If {(X→Y||Z) and (Z→T||W)} then (X→Y||T||W). 6. Dissection: If (X→Y||Z) then X→Y and X→Z. An important point of the revision is that, while combining Reflexivity and Augmentation axioms, we did not alter correctness and completeness of Armstrong’s Axioms. Therefore, the RAAs are equivalent transformations of AAs. A composition plan is associated with a control flow and a data flow of processes in the plan. A control flow addresses the task dependencies among a set of atomic processes. Here, the order of atomic processes is a crucial point. A pair of processes is called combinative if the output of one is equal to the input requirements of the other (transitive), or, if the input of one is equal to the input requirements of the other (additive). RAAs are applicable in structuring a control flow (as a workflow of atomic processes) among candidate processes. If we apply Transitivity then Pseudo Transitivity rules to the BookSearch.owl , BookPrice.owl and CurrencyConvertor.owl in the Table 2, the possible chain is: Pseudo[Transitivity[BookSearch◦BookPrice]◦CurrencyConvertor ]]. Additionally, the expected new process (named as P) after tracing of Planner and IE actions is: P≡[Title[Concepts.owl#Text]kDestinationCurrency[Concepts.owl#Currency]→OutputAmount[Concepts.owl#Price]] that results the P is canonically implied by G (PG). Inferencing is taken up next. Table 4 Revised Armstrong’s Axioms in the Tasks.owl (TKBO) <!– Object Properties of Tasks.Owl–> 1 <owl:ObjectProperty rdf:ID=“hasTransitivity”> 2 <rdf:type rdf:resource=“&owl;TransitiveProperty”/> 3 <rdfs:domain rdf:resource=“#Tasks”/> 4 <rdfs:range rdf:resource=“#Tasks”/> 5 </owl:ObjectProperty> 6 <owl:ObjectProperty rdf:ID=“hasPseudoFactorization”> 7 <rdf:type rdf:resource=“&owl;TransitiveProperty”/> 8 <rdfs:domain rdf:resource=“#Tasks”/> 9 <rdfs:range rdf:resource=“#Tasks”/> 10 </owl:ObjectProperty> 11 <owl:ObjectProperty rdf:ID=“hasPseudoTransitivity”> 12 <rdf:type rdf:resource=“&owl;TransitiveProperty”/> 13 <rdfs:domain rdf:resource=“#Tasks” /> 14 <rdfs:range rdf:resource=“#Tasks” /> 15 </owl:ObjectProperty> 16 17 18 19 20 21 22 23 24 25 26 27 28 29 <owl:ObjectProperty rdf:ID=“hasAdditivity”> <rdf:type rdf:resource=“&owl;UnionProperty”/> <rdfs:domain rdf:resource=“#Tasks”/> <rdfs:range rdf:resource=“#Tasks”/> </owl:ObjectProperty> <owl:ObjectProperty rdf:ID=“hasAccumulation”> <rdf:type rdf:resource=“&owl;TransitiveProperty”/> <rdfs:domain rdf:resource=“#Tasks”/> <rdfs:range rdf:resource=“#Tasks”/> </owl:ObjectProperty> <owl:ObjectProperty rdf:ID=“hasDissection”> <rdfs:domain rdf:resource=“#Tasks”/> <rdfs:range rdf:resource=“#Tasks”/> </owl:ObjectProperty> Semantic Composition of Business Processes using Armstrong’s Axioms 7 9 Inferencing in the SCA System Semantic task contexts are supported by the OWL formal semantics. Therefore, reasoning can be performed based on the semantically described task contexts. In order to do this, we employ the Task ontology (Tasks.owl-TKBO) for inference purpose. In this section, we present the details of inference through TKBO of the SCA System. OWL formal semantics can be used to define RAAs as object property characteristics to be used during the inference and planning stage. Thus hasTransitivity , hasPseudoFactorization, hasPseudoTransitivity , hasAdditivity , hasAccumulation and hasDissection are defined as <owl:ObjectProperty>. The RAAs rules are inserted into the Tasks ontology (TKBO) in order to describe task dependencies as displayed in the lines 1, 6, 11, 16, 21, and 26 in Table 4. Table 5 Four tasks of the Online Book Store Domain in the Tasks.owl (TKBO) 1 <owl:Class rdf:ID=“BookISBN-Task”> 2 <rdfs:subClassOf rdf:resource=“#Information Service”/> 3 <Input Parameter rdf:datatype=“&Concepts;Title”>Book Title</Input Parameter> 4 <Output Parameter rdf:datatype=“&Concepts;ISBN”>ISBN</Output Parameter> 5 <hasTransitivity rdf:resource=“&Tasks;BookPrice-Task”/> 6 <hasAdditivity rdf:resource=“&Tasks;BookSearch-Task”/> 7 </owl:Class> 8 <owl:Class rdf:ID=“BookPrice-Task”> 9 <rdfs:subClassOf rdf:resource=“#Information Service”/> 10 <Input Parameter rdf:datatype=“&Concepts;ISBN”>ISBN</Input Parameter> 11 <Output Parameter rdf:datatype=“&Concepts;Store”>Book Store</Output Parameter> 12 <Output Parameter rdf:datatype=“&Concepts;Price”>Price</Output Parameter> 13 <Output Parameter rdf:datatype=“&Concepts;Currency”>Result Currency</Output Parameter> 14 <hasPseudoTransitivity rdf:resource=“&Tasks;Currency Converter-Task”/> 15 </owl:Class> 16 <owl:Class rdf:ID=“Currency Converter-Task”> 17 <rdfs:subClassOf rdf:resource=“#Information Service”/> 18 <Input Parameter rdf:datatype=“&Concepts;Price”>Input Price</Input Parameter> 19 <Input Parameter rdf:datatype=“&Concepts;Currency”>Input Currency</Input Parameter> 20 < Input Parameter rdf:datatype=“&Concepts;Currency”>Output Currency</Output Parameter> 21 <Output Parameter rdf:datatype=“&Concepts;Price”>Output Price</Output Parameter> 22 </owl:Class> 23 <owl:Class rdf:ID=“BookSearch-Task”> 24 <rdfs:subClassOf rdf:resource=“#Information Service”/> 25 <Input Parameter rdf:datatype=“&Concepts;Title”>Title</Input Parameter> 26 <Output Parameter rdf:datatype=“&Concepts;Book”>BookDetails</Output Parameter> 27 <hasAdditivity rdf:resource=“&Tasks;BookISBN-Task”/> 28 </owl:Class> OWL formal semantics provide many property characteristics such as transitive, symmetric, functional , inverseOf , inverseFunctional etc. For instance, if a property P is specified as transitive then for any X, Y, and Z: P(X,Y) and P(Y,Z) implies P(X,Z). Kang et al. (2009) used the property characteristics during the reasoning of business process knowledge to provide an order among some semantic business processes for monitoring purpose. However, the SCA uses theRAAs to describe task dependencies semantically as a kind of OWL object property. In Table 4, the defined transitive-based properties (as shown in lines 2, 7, 12, and 22) are suitable to reason about the execution order of several tasks while planning. Additionally, union-based properties (as shown in the line 17) could be also suitable for additive-based operations among a set of tasks. To understand better the depth of inferencing in the SCA System, one will have to consider another similar example of Online Book Store domain. Four different task instances from TKBO: BookISBN-Task , BookPrice-Task , Currency Converter-Task and BookSearchTask are given in Table 5. The object property hasTransitivity is specified as transitive (line 1 & 2 in Table 4). In addition, if the BookISBN-Task is transitive with BookPriceTask then BookISBN-Task has to be performed before the BookPrice-Task . The tasks dependency knowledge is semantically described for these two task instances (BookISBN-Task 10 d. celik and a. elci & BookPrice-Task ) through <hasTransitivity> rule of RAAs in the semantic contexts of the task instance (BookISBN-Task ) in the Table 5 (line 5). The other task dependencies are described in the same fashion through RAAs in the Table 5. In this manner, various meanings related to the task can be described in the semantic contexts of task instances and their dependency knowledge that give us an opportunity to derive a new process named NewBookProcess from these two processes. Based on this transitive characteristic of the hasTransitivity , the resultant new task (NewBook-Process) is performable before any suitable task to continue the possible chain. Some of possible reasoning operations are formalized as below: TRANSITIVITY1[BookISBN-Task(Title→ISBN),BookPrice-Task(ISBN→Storek PricekCurrency)] implies [NewBook-Process (Title→StorekPricekCurrency)] (1) PSEUDOTRANSITIVITY1[NewBook-Process(Title→StorekPricekCurrency), Currency Converter-Task(CurrencykPricekCurrency→Price)] implies [AnotherBook-Process (TitlekCurrency→StorekPrice)] (2) PRODUCED NEW PROCESS (TitlekCurrency→StorekPrice) (3) (RESULTNODE): AnotherBook-Process The profile model of the resultant composition process (Formula 3) is given in Table 6. In the Table 6, two inputs (lines 2-7 and 8-13) and two outputs (lines 14-19 and 20-25) are defined with their parameter types by URLs pointing to the related concepts in the Concepts.owl (CKBO). In Table 7, a part of process model of the resultant composite process by SCA is given. The Table 6 Profile model of the returned composite process (AnotherBook-Process) 1 <tasks:AnotherBook-Task rdf:about= “AnotherBook-TaskProfile”> 2 <profile:hasInput> 3 <process:Input rdf:ID=“Title”> 4 <rdfs:label>Book Title</rdfs:label> 5 <process:parameterType rdf:datatype= “&Concepts;Title”/> 6 </process:Input> 7 </profile:hasInput> 8 <profile:hasInput> 9 <process:Input rdf:ID=“Currency”> 10 <rdfs:label>Output Currency</rdfs:label> 11 <process:parameterType rdf:datatype= “&Concepts;Currency”/> 12 </process:Input> 13 </profile:hasInput> 14 <profile:hasOutput> 15 <process:Output rdf:ID=“Store”> 16 <rdfs:label>Book Store</rdfs:label> 17 <process:parameterType rdf:datatype= “&Concepts;Store”/> 18 </process:Output> 19 </profile:hasOutput> 20 <profile:hasOutput> 21 <process:Output rdf:ID=“Price”> 22 <rdfs:label>Output Price</rdfs:label> 23 <process:parameterType rdf:datatype= “&Concepts; Price/> 24 </process:Output> 25 </profile:hasOutput> 26 </tasks: AnotherBook-Task> model contains semantic contexts of the knot points in the returned chain which are TRANSITIVITY1 (Formula 1), PSEUDOTRANSITIVITY1 (Formula 2), and RESULTNODE (Formula 3). The order is described as TRANSITIVITY1 , PSEUDOTRANSITIVITY1 and RESULTNODE which is given in lines 1-21 through <process:ControlConstructList>, <list:first>, <list:rest>, and so on. Three different tasks are used for the resultant composition plan: BookISBN-Task , BookPrice-Task , and Currency Converter-Task . The common parameter of the BookISBN-Task and BookPrice-Task is “ISBN”. ISBN is produced by BookISBN-Task and consumed by BookPrice-Task that is shown between lines 31-46 in Table 7. Common parameters of BookPrice-Task and Currency Converter-Task are “Input Currency” and “Input Price”. These produced by BookPrice-Task and consumed by Currency Converter-Task which are shown in lines 47-67 in Table 7. Finally, during the Execution and Monitoring stage, the SCA System uses grounding information (keeps the URLs of services) of those atomic processes to execute the composite process. The semantic context of the grounding information is given in lines 68-73 in the Table 7. Thus various new processes can be inferred based on the semantic contexts of task instances and their dependency Semantic Composition of Business Processes using Armstrong’s Axioms 11 Table 7 Process model of the returned composite process (AnotherBook-Process) 1 <process:CompositeProcess rdf:about= “#AnotherBook-Process”>. . . 2 <process:ControlConstructList> 3 <list:first> 4 <process:Perform rdf:nodeID= “TRANSITIVITY1”/> 5 </list:first> 6 <list:rest> 7 <process:ControlConstructList> 8 <list:first> 9 <process:Perform rdf:nodeID= “PSEUDOTRANSITIVITY1”/> 10 </list:first> 11 <list:rest> 12 <process:ControlConstructList> 13 <list:rest rdf:resource=“&list;#nil”/> 14 <list:first> 15 <process:Perform rdf:nodeID= “RESULTNODE”/> 16 </list:first> 17 </process:ControlConstructList> 18 </list:rest> 19 </process:ControlConstructList> 20 </list:rest> 21 </process:ControlConstructList>. . . 31 <process:Process rdf:ruleID= “PSEUDOTRANSITIVITY1”> 32 <process:process rdf:resource=“../services/ BookPrice.owl#BookPrice-Process”/> 33 <process:hasDataFrom> 34 <process:InputBinding> 35 <process:toParam rdf:resource=“../services/ BookPrice.owl#ISBN”/> 36 <process:valueSource> 37 <process:ValueOf> 38 <process:theVar rdf:resource=“../services/ BookISBN.owl#ISBN”/> 39 <process:fromProcess> 40 <process:Process rdf:ruleID= “TRANSITIVITY1”/> 41 </process:fromProcess> 42 </process:ValueOf> 43 </process:valueSource> 44 </process:InputBinding> 45 </process:hasDataFrom> 46 </process:Process> 22 <process:Process rdf:ruleID=“TRANSITIVITY1”>47 <process:Process rdf:ruleID=“RESULTNODE”> 23 <process:process rdf:resource=“../services/ 48 <process:process rdf:resource=“..services/ BookISBN.owl#BookISBN-Process”/> CurrencyConverter.owl#CurrencyConverterProcess”> 24 <process:hasDataFrom> 49 <process:hasDataFrom> 25 <process:InputBinding> 50 <process:InputBinding> 26 <process:toParam 51 <process:valueSource> rdf:resource=“../services/ 52 <process:ValueOf> BookISBN.owl#Title”/> 53 <process:fromProcess rdf:ruleID= 27 ... “PSEUDOTRANSITIVITY1”/> 28 </process:InputBinding> 54 <process:theVar rdf:resource=“../services/ 29 </process:hasDataFrom> BookPrice.owl#Price”/> 30 </process:Process> 55 </process:ValueOf> 56 </process:valueSource> 57 <process:toParam rdf:resource=“..services/ Currency Converter.owl#Input Price”/> 58 </process:InputBinding> 59 <process:InputBinding> 60 <process:valueSource> 61 <process:ValueOf> 62 <process:fromProcess rdf:ruleID= “PSEUDOTRANSITIVITY1”/> 63 <process:theVar rdf:resource=“../services/ BookPrice.owl#Currency”/> 64 </process:ValueOf> 65 </process:valueSource> 66 <process:toParam rdf:resource=“..services/ CurrencyConverter.owl#Input Currency”/> 67 </process:InputBinding> . . . 68 <grounding:WsdlGrounding rdf:about=“#AnotherBook-ProcessGrounding”> 69 <grounding:hasAtomicProcessGrounding rdf:resource=“. . . /Currency Converter.owl #Currency ConverterGrounding”/> 70 <grounding:hasAtomicProcessGrounding rdf:resource=“. . . /BookPrice.owl#BookPriceGrounding”/> 71 <grounding:hasAtomicProcessGrounding rdf:resource=“. . . /BookISBN.owl#BookISBNGrounding”/> 72 <service:supportedBy rdf:resource=“#AnotherBook-ProcessService”/> 73 </grounding:WsdlGrounding> knowledge in the Tasks ontology (TKBO). The system produces an OWL-S based ontology file of requested composite process. Matching of the tasks in the resultant plan and also tasks of the client goal will be checked by the Process Equivalency Task which is discussed next. 8 Process Equivalency Task (PET) The planner performs the Process Equivalency Task between the client goal process (G) and the newly derived composite process (P) in order to identify if the two processes have the same purpose or not. This is performed according to the algorithm depicted in Table 8. Let’s assume 12 d. celik and a. elci that the input and output parameters of processes G and P are indicated as G≡{Gi , Go } and P≡{Pi , Po }, let us say that: Gi ≡{BookTitle[Text], InputCurrency[Currency], OutputCurrency[Currency]} and Go ≡{BookPrice[Price]}. Pi ≡{Title[Text], SourceCurrency[Currency], DestinationCurrency[Currency]} and Po ≡{OutputAmount[Price]}. Then clearly, Gi ≡Pi and Go ≡Po , consequently, P is equivalent to G according to their parameter types that is given in brackets “[ ]”. In another case, if Gi ≡Pi , however, Go ≡{BookPrice[Price]} and Po≡{OutputAmount[Price], DestinationCurrency[Currency]}, that is, Go ⊂Po , then it can be stated that P subsumes process G. Producing extra outputs is acceptable, therefore it can be concluded that P is equivalent to G. In the latter case, the SCA System checks whether any unnecessary I/O is generated, and if so, stipulates where it can be ignored in the above example. Table 8 Process Equivalency Task 1 When Go≡Po then G≡P 3 When Go⊂Po then G≡P 4 When Go⊃Po then G¬ ≡P 5 6 9 When Gi≡Pi then 2 otherwise G¬≡P When Gi⊇Pi then 7 When Go≡Po then G≡P 8 When Go⊂Po then G≡P 9 When Go⊇Po then G¬ ≡P 10 otherwise G¬≡P 11 When Gi⊂Pi then G¬ ≡P Related Works In recent studies, the composition problem is solved by using a planner. A planner uses a list of participating candidate Web services (contains atomic or composite processes) and a complex goal (stated by the user in the form of a task description) in generating a composition plan. The most popular AI planning techniques are the Hierarchical Task Network (HTN) planner using Situation Calculus (SC) as discussed by Sirin et al. (2004); Event Calculus (EC) based composition as discussed by Aydın et al. (2006, 2008); Planning Domain Definition Language (PDDL) based composition as introduced by Yang et al. (2010); and Compositional/Process Algebra (PA) based composition as given by Hashemianet al. (2006). HTN planner (Sirin et al., 2004) uses a task decomposition approach, called the fragmentation process that divides complex tasks into smaller subtasks until it reaches atomic tasks that can be executed directly. The advantage of the HTN method is that it decreases the complexity of planning phase that may require many steps, however the mechanism of dividing high-level tasks is in itself difficult to execute accurately. The basic ontology of EC is very similar to that of SC. Aydin et al. (2006, 2008) contributed a valuable approach to the problem of composition of Web services by using the EC method. This work presented a method of translating the OWL-S ontology to EC events and actions. The main idea is to get a suitable composition plan with complex actions by using EC as an alternative approach to building agent technology, based on the notions of generic procedures and customizing user constraints. The Planning Domain Definition Language (PDDL) (McDermott et al., 1998) is widely documented as a standardized input for high-tech planners and used for composition of Web services. Consequently, the mapping process from DAML-S or OWL-S representations to PDDL Semantic Composition of Business Processes using Armstrong’s Axioms 13 is very user friendly and simple to operate because the ontology languages have been strongly influenced by PDDL and vice versa. Yang et al. (2010) proposed that the OWL-S description of SWSs can be translated into a description written in PDDL. Also they developed several key procedures of the translating algorithm for OWLS2PDDL and vice versa. Hashemian et al. (2006) represented the behavior and operations of a Web service using a simple Process Algebra (PA), called ‘Composition Algebra’. PA operators are used to find a solution for automatic composition from stateless components which had a simple two-step workflow: receiving inputs and then returning the corresponding outputs. They provided a forward chaining algorithm to find possible components for composition in order to achieve a requested behavior. However, the proposed approach is not modeled on Semantic Web, thus lacks semantics. Most researchers concentrated either on semi-automated or fully automated techniques for Web services composition, drawing inspiration particularly from AI planning and Process Calculi. However, these approaches are lexical in nature and can only return service composition upon user’s necessity description which lacks flexibility in meeting later change. Two important contributions of this present study are that the SCA takes advantage of its own TKBO, and RAAs based inferencing. Using TKBO, Web services can be defined as instances of classes by using OWL semantic tags that represent Web services capabilities based on their OWL-S descriptions. A domain-specific TKBO contains commonly used task instances for a specific domain (e.g., Online Book Selling/Buying, Traveling, or Car Selling/Buying, etc.), I/O/P/E concepts of the described task instances, and semantically described task dependencies through RAAs by using OWL tags (e.g.Table 5 contains four task instances of the Online Book Store Domain). Additionally, SCA keeps the semantic contexts of task dependencies belonging to the newly constituted composite task in the corresponding domain Tasks ontology (TKBO) for possible reuse. For example, Table 6 and Table 7 display Profile & Process models of the returned composite process (AnotherBookProcess). The technique saves time and effort whenever same composite task is requested or may be used to form more complex composite tasks later. Additionally, in order to select suitable tasks for the required composition, the SCA searches over lesser number of the related task instances that are in the interest domain TKBO instead of searching over a large number of candidate OWL-S (POKB) processes at first. After specifying the suitable task instances for newly constituted appropriate solution plan by Planner, the SCA selects same structured OWL-S atomic processes (a task instance is having same I/O/P/E with a candidate OWL-S atomic process) from candidate set by looking only the included task instances in the plan. After execution of the resultant plan, the semantic contexts of the newly produced composite task will have been embedded into the TKBO if the newly produced composite task was not produced and recorded before. Therefore, the SCA doesn’t require to search and parse the large set of candidate OWL-S processes, which makes the performance better compared to other solutions in this case. Although many proposed solutions employ Semantic Web technologies however, they do not take advantage of such a common TKBO. Moreover, the SCA has a different and extended matching mechanism since the matching task takes into consideration similarity and defines relations such as is a, synonym, or equivalentClass between I/O concepts of processes. Additionally, the process matching task considers both properties that are rdf:ID (matching of input- output) concepts and process:parameterType properties (see details in Section 4). Consequently, relevant combinative processes will not be missed in finding a composition plan. As mentioned above, the SCA System draws advantages from its OWL ontology knowledge bases due to their expressive nature and semantic richness. SCA uses the RAAs to further elaborate on such rich knowledge bases. In fact, AAs being created for the relational models, this may bring to one’s mind the question: How appropriate is to employ RAAs/AAs in connection with OWL ontologies. In order to address this issue, and relate AAs to OWL, let us study the ontology spectrum. Obrst (2003) developed an ontology spectrum as a framework for illustrating various information models relative to others in terms of their semantic richness. An abridged 14 d. celik and a. elci version of the Obrst ontology spectrum as depicted in Figure 2 lines up some existing mainline semantic languages or models by plotting them on a span from weak to strong semantics. Obrst says that “Weak semantics indicate the expression of very simple meaning while strong semantics indicate the expression of arbitrarily complex meaning. As one progresses up the spectrum, the domain semantics are based on logic, allowing the machine to make valid inferences and execute sound semantic constraints” (Obrst, 2003). All models of the given spectrum have an association with each other that correspond to semantic expressiveness and syntax; for instance: the Description Logics (DL) syntax can be used for a description of OWL ontology or knowledge base. A concept from DL is referred to as a class in OWL and a role from DL is referred to as a property in OWL. Furthermore, the Relational Model (RM) has a strong mathematical foundation. This makes it closer to the DL layer, which is the basis for many ontology languages, including OWL. In addition, tables in the RM are equivalent to ontology classes. The main advantage with respect to ER is that the relational model includes domains for the attributes (Abiteboul et al., 1995; Fagin, 1977; Motik et al., 2007; Rao et al., 2006). Higher level semantic models on the spectrum provide more expressiveness, semantic richness and complexity than those in the lower levels. On the other hand, while climbing from the bottom to the top, there will be no semantic loss. To the contrary, more powerful descriptions of functions, data and properties will be availed. The Armstrong’s Axioms are well known and widely used in inference rules in the area of the Relational models and Databases. Consequently, it is just to say that, Armstrong’s Axioms may as well be a suitable approach to derive tasks dependencies of a composition as used in Section 6 and Section 7 in relation to SWSs. Figure 2 Ontology spectrum: weak to strong semantics (after Obrst (2003)) 10 Conclusions Lack of semantic annotation parts, increasing number of Web Services on the Web, and syntactic-based search operations for current Web Services makes discovery and composition of appropriate Web Services challenging. This article presented an inference-based semantic business process composition agent (SCA) approach to perform automatic process composition of SWSs. The proposed SCA System has five main parts which are as follows: translator, planner, inference engine, execution engine, and monitoring agent. The system also has three ontology knowledge bases; Tasks-TKBO, Concepts (or Domains-CKBO) and Processes-PKBO, and one Rule knowledge base (RKB) that contains the Revised Armstrong’s Axioms -RAAs. SCA starts with a scheme to parse specifications of tasks instances in TKBO, interested OWL-S based atomic processes and goal task to I/O/P/E form, then uses RAAs in building a plannerinference engine cycle. A semantically-enriched algebraic rule-based planner was developed for use in composing atomic processes of candidate SWSs. Examples are given displaying practical uses of functional parts of the SCA System approach. A case study for generating composition plans were performed displaying the outcome using different OWL-S atomic processes selected from the widely-used SWS-TC 1.13 test collection. Semantic Composition of Business Processes using Armstrong’s Axioms 15 Acknowledgement This work was supported in full by the Eastern Mediterranean University Scientific Research Project BAP-A-07-20 Provision of SWSs through an Intelligent Semantic Web Service Finder . References Abiteboul, S., Hull, R. & Vianu, V. 1995. Foundations of Databases, Addison-Wesley, 0-201-53771-0. Armstrong, W. W. 1974. Dependency Structures of Data Base Relationships. Information Processing 74. North-Holland Pub. Co., 586-583. Aydin, O., Cicekli, N. K. & Cicekli, I. 2008. Automated Web Services Composition with the Event Calculus. Engineering Societies in the Agents World VIII (ESAW 2007), Lecture Notes in Computer Science, Springer Berlin / Heidelberg Press,0302-9743, 142-157. Aydin, O., Cicekli, N. K. & Cicekli, I. 2006. Towards Automated Web Service Composition with the Abductive Event Calculus. Proceedings of Applications of Logic Programming in the Semantic Web and Semantic Web Services (ALPSWS 2006), 103-104, Seattle, USA. Bergstra, J. A., Ponse, A. & Smolka, S. A. 2001. Handbook of Process Algebra. Elsevier. Berners-Lee, T., Hendler, J. & Lassila, O. 2001. The Semantic Web, Scientific American. Bonet, B. & Geffner, H. 1995. Planning as Heuristic Search: New Results. In Proceedings of the Fifth European Conference on Planning (ECP-99), 359-371. Celik, D. & Elci, A. 2008. Provision of Semantic Web Services through an Intelligent Semantic Web Service Finder. Multiagent and Grid Systems - An International Journal 4(3), 1574-1702, IOS Press, 315-334. Fagin, R. 1977. Functional dependencies in a relational data base and propositional logic. IBM Journal of Research and Development, 543-544. Forgy, C. L. 1991. Rete: a fast algorithm for the many pattern/many object pattern match problem. Expert systems: a software methodology for modern applications, 324-341. Hashemian, S. V. & Mavaddat, F. 2006. Composition Algebra: Process Composition Using Algebraic Rules, Third International Workshop on Formal Aspects of Component Software (FACS’06), Prague, Czech Republic. Hoffmann, J. & Nebel, B. 2001. The FF Planning System: Fast Plan Generation Through Heuristic Search. Journal of Artificial Intelligence Research 14, 253-302. Kang, D., Lee, S., Kim, K. & Lee, J. Y. 2009. An OWL-based semantic business process monitoring framework. Journal of Expert Systems with Applications 36(4), 0957-4174. McDermott, D. 1998. The Planning Domain Definition Language Manual. Yale Computer Science Report 1165 (CVC Report 980003). McIlraith, S. A., Son, T. C. & Zeng, H. 2001. Semantic Web Services. IEEE Intelligent Systems 16, 46–53. Motik, B., Horrocks, I. & Sattler, U. 2007. Bridging the Gap between OWL and Relational Databases. In Proceedings of the 16th international conference on World Wide Web, 807-816. Obrst, L. 2003. Ontologies for Semantically Interoperable Systems. Proceedings of the Twelfth International Conference on Information and Knowledge Management, 366-369. OWL. 2004. OWL Web Ontology Language overview: W3C Recommendation. http://www.w3.org/tr/owlfeatures/ accessed October 1, 2009. OWL-S. 2004. Semantic markup for Web services: W3C Recommendation. http://www.w3.org/submission/owl-s/ accessed October 1, 2009. Rao, J. & Su, X. 2005. A Survey of Automated Web Service Composition Methods. Lecture Notes in Computer Science 3387, 0302-9743 (Print) 1611-3349 (Online), 43–54. Sirin, E. & Parsia, B. 2004. Planning for Semantic Web Services. In Semantic Web Services Workshop at 3rd International Semantic Web Conference. Sirin, E., Parsia, B., Wu, D., Hendler, J. & Nau, D. 2004. HTN planning for Web service composition using SHOP2. Journal of Web Semantics, 1(4), 377-396. Yang, B. & Qin, Z. 2010. Composing semantic Web services with PDDL. Journal of Information Technology 9(1), 48-54.