• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
A constraint programming based approach to
 

A constraint programming based approach to

on

  • 118 views

 

Statistics

Views

Total Views
118
Views on SlideShare
118
Embed Views
0

Actions

Likes
0
Downloads
3
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    A constraint programming based approach to A constraint programming based approach to Document Transcript

    • The International Arab Journal of Information Technology, Vol. 8, No. 1, January 2011 1 A Constraint Programming Based Approach to Detect Ontology Inconsistencies Moussa Benaissa and Yahia Lebbah Faculté des Sciences, Université d’Oran Es-Senia, AlgeriaAbstract: This paper proposes a constraint programming based approach to handle ontologies consistency, and moreprecisely user-defined consistencies. In practice, ontologies consistency is not still well handled in the current softwareenvironments. This is due to the algorithmic and language limitations of the tools developed to handle the consistencyconstraints. The idea of this paper is to tackle this problem by exploiting constraint programming which is proved to beefficient and provides various techniques to handle many types of constraints on different domains.Keywords: Constraint programming, filtering, ontologies, consistency checking, ontology evolution. Received January 8, 2008; accepted May 17, 20081. Introduction holding both on reals and Herbrand space is very difficult since there are no algorithmic connectionsOntologies have been widely adopted both in between logic and linear programming.academic and industrial applications. They are Constraint programming overcomes this limitationentities evolving continuously. One of the main by allowing several constraints to be expressed onaspects to consider during this evolution process is to various domains. It uses existing mathematicaldetect their consistencies. Consistency can be defined techniques to process general constraints with genericas a set of constraints that should be verified. Below, methods. In other terms, constraint programming iswe distinguish three types of consistencies [6, 14]: not better than other techniques, but exploits and• Structural consistency: this consistency considers combines them to process general constraints for constraints required by the underlying model of which there are no specific techniques. the ontology and the representational language. This is exactly the purpose of this paper: how can• Logical consistency: this consistency considers we exploit constraint programming to handle user- logical constraints. Ontology must not contain defined consistency? We propose a constraint contradictory information. programming based framework for processing the• User-defined consistency: this consistency constraints presented in [5]. considers constraints defined by the user. The paper is organized as follows. We begin by motivating this work and illustrating the proposedHere, we are concerned with user defined approach with an example. In section 4, we presentconsistency. Ontology development environments user axioms classification developed in an empiricalsuch as Protégé [10] include tools based on first order study [5]. Section 5 introduces constraintlogic. For example Protégé Axiom Language (PAL) programming and more particularly the Constraintfor Protégé enables to express consistency axioms as Satisfaction Problems (CSP) notation and its generica set of axioms. The work described in [7] consists of algorithms. In section 6, we present our contribution.studying existing ontologies and proposing a set of It is a constraint programming model for theaxioms templates in order to facilitate composing the classification presented in section 4. In section 7, weuser constraints. Nevertheless, algorithmic issues of introduce two approaches to handle consistency.handling theses constraints are problematic. Next, in section 8, we provide two approaches to Operational research and constraint (logic) exploit the model elaborated in section 6. Conclusionprogramming techniques provide efficient algorithms and some perspectives conclude the paper.which can be used to handle this problem. ExceptConstraint Programming (CP), other techniques arevery specific. It is very difficult to process new 2. Motivation and Contributionconstraints with them. For example linear Ontologies are nowadays ubiquitous. Their number,programming can process only linear constraints. their complexity and the domains they model areLogic programming handles clauses in the Herbrand increasing considerably. Ontology managementspace [5]. However the task of processing constraints systems should be developed to support the user.
    • 2 The International Arab Journal of Information Technology, Vol. 8, No. 1, January 2011 Ontology languages cannot capture all the 3.1. Ontological Modeling of the Tasksknowledge embedded in various application domains. Assignment ProblemSo, it is necessary to extend them to make easy theexpression and the treatment of other aspects of The above problem can be modeled with theknowledge such as constraints. In fact, some following ontology as shown in Figure 1. We haveexpressiveness issues have been considered by some two concepts: T whose instances are the tasks and Pworks [7], but, to our knowledge, there are no whose instances are enterprise employees.efficient systems for handling large ontologies with We have two slots: The slot can-do: this slot has Pconstraints in real contexts. This complexity aspect is and T as respectively the domain and the range. Itparticularly critical in dynamic industrial applications captures employee preferences. We represent it aswhere system performance is required. follows: Our contribution consists in adopting constraint Can-do ={(Pierre, A), (Pierre, M), (Pierre, C),programming as the framework to process ontology (Michel, M), (Michel, C), (Michel, D), (Corinne, A),constraints. This is a natural extension to the current (Corinne, M), (Julie, A),(Julie, M), (Bernard, A),trend which uses logic programming to handle (Bernard, M), (Bernard, C), (Jean, O), (Jean, D),ontology constraints. Actually, constraint (Patrice,O) ,(Patrice, D)}.programming is recognized as the appropriate The slot is-realized-by: This slot has T and P asframework for studying combinatorial problems. It respectively the domain and the range. It representsoffers more general and powerful tools than those of the problem solution. With cardinality constraints, welogic programming. associate the following user-defined axioms: Concept : P3. Tasks Assignment Problem can-do Is-realized-byIn order to illustrate our approach, we consider atasks assignment problem. We have two sets: thetasks T and the persons P. T is defined as T = {A, M, Concept : TC, O, D}; A for Administration, M for Maintenance,C for Commercial, O for Conception, and D for Figure 1. Ontology model.Development. The instances of P are the set {Pierre,Michel, Corinne, Julie, Bernard, Jean, Patrice} The value A, of the class T, has a number ofwhich denotes the enterprise employees. occurrences ranging from 1 to 2 within the slot is- We aim to assign tasks to persons so that the realized-by. And with the same manner:following constraints are verified: 1. The value M ranges from 1 to 3.• The employee must execute at least one task. 2. The value C ranges from 1 to 1.• The employee cannot execute more than one task. 3. The value O ranges from 1 to 2.• The number of assignments of some task should 4. The value D ranges from 1 to 5. be greater than some minimal value and lower We can abstract the above axioms by the following than some maximal value. For example A[1,2] template: the value ___ of class __ has a minimal means that the task A is affected to at least one number of occurrences equal to __ and a maximal person and to at most two persons. The number of occurrences equal to __ for the slot __. cardinalities constraints for the different tasks are A[1, 2], M[1, 3], C[1, 1], O[1, 2], and D[1, 5]. 3.2. The Problem Let be the following preferences:• Pierre prefers the tasks A, M and C. Let us suppose that some changes occur in this• Michel prefers the tasks D, M and C. environment by introducing new data (e.g., new employees, new tasks, or new constraints on• Corinne prefers the tasks A and M. employee preferences). It is necessary to maintain• Julie prefers the tasks A and M. ontology consistency after these changes. Obviously,• Bernard prefers the tasks A, M and C. this task is hard to realize manually. The manager• Jean prefers the tasks O and D. may not find easily the solution. The question is: how• Patrice prefers the tasks O and D. can we help the manager?A solution that verifies the above constraints is:Pierre, Michel, Corinne, Julie, Bernard, Jean, 3.3. The Proposed SolutionPatrice realize respectively the tasks A, M, A, M, C, The solution we propose is based on constraintO and D. programming. More precisely, we translate the above ontology to a Constraint Satisfaction Problem (CSP)
    • A Constraint Programming Based Approach to Detect Ontology Inconsistencies 3and use filtering techniques to reduce the search 5. Constraint Programmingspace. The CSP is defined as follows (for the details see Constraint Programming (CP) is a problem solvingthe following sections): environment exploiting various techniques coming from artificial intelligence, and operational research.• The persons are denoted as variables. It has been successfully applied to many problems in• The slot can-do defines variables domains. various domains such as planning and scheduling. It• The axioms template defined above can be is particularly efficient to solve combinatorial modeled with global constraints such as Global problems. Cardinality Constraint (GCC) [12]. The filtering Within CP, a specific framework called Constraint algorithm proposed in [11] determines the set of Satisfaction Problem (CSP) is defined. Below we all inconsistent values with GCC. This reduces the present briefly this framework and we recommend search space and makes easy finding a consistent the specialized references for further details [1, 3]. solution. 5.1. Definition of CSP4. User Axioms Classification Formally, a CSP P is defined as a triple (X, D, C)The constructs of ontology languages such as where:Ontology Web Language (OWL), though they cover • X a set of n variables x1,…, xn.the global definition of ontological knowledge base, • D a set of finite domains D(x1), …, D(xn) wheredo not allow the expression of some constraints D(xi) is the domain of the variable xi.between different ontology components. • C = {C1, ..., Cm} a set of constraints defined on Every instance of class__ appears at least once in slot __ for some variables. A constraint Ci is defined on a any instance of class __. subset of variables. A solution is an assignment of Example: Every student has at least one advisor. values to the variables such that all the constraints Every instance of Class Student appears at least once in slot advice: Class Professor for any instance of Class Professor. are satisfied. • For example, let be the following CSP: Figure 2. Example of a template. X = {x, y, z} D = {D(x), D(y), D(z)} where For example, constraints on roles values of the D(x) = D(y) = {1, 2}, D(z) = {1, 2, 3, 4}.same class instances cannot be expressed. To C = {C1(x, y), C2(y, z), C3(x, z)}, whereovercome this deficiency and help the users, ontology C1(x, y): x ≠ y,development environments such as Protégé [10] C2(y, z): y ≠ z,include tools, generally based on first order logic C3(x, z) : x + 1 ≥ z.such as PAL (Protégé Axiom Language), to capturethese axioms. 5.1.1. Solving CSPs However, it is pointed out [8] that these tools are CSP solving techniques are organized according tonot exploited and only few ontologies contain user the following algorithmic components: filtering,defined axioms. The reason behind this weakness is exploration and enumeration. Filtering reduces thethe complexity [7] of languages underlying these search space induced by the CSP. Explorationtools. explores intelligently the search space. Let be some To solve this problem, some works [7, 13] suggest CSP. If filtering cannot reduce the domains to aspecific user interfaces that make easy axioms single solution or cannot prove the non-existence ofexpression without using these languages. Below we solutions, then the values of the variables domain aredescribe briefly the approach proposed in [7] on enumerated.which we have elaborated our contribution. The exponential complexity of this solving process The approach described in [7] consists of studying is due essentially to enumeration. Filtering hassignificant existing ontologies and deriving templates usually a weak polynomial complexity.from user defined axioms. About twenty templates More precisely [12], each constraint has a specificthat cover 85% of user defined axioms have been filtering algorithm. It removes, from the domains ofabstracted in this study. constraints variables, all the values for which some An environment has been developed as a plug-in constraint cannot be satisfied. These values are calledof the protégé environment. It consists in an interface non-locally consistent.that allows the users to compose axioms by “filling in Arc-consistence [9] is the most used generalthe blanks”. In Figure 2, we give an example of such property of filtering algorithms. Below, we give antemplates [7]. informal introduction and some illustrations and we
    • 4 The International Arab Journal of Information Technology, Vol. 8, No. 1, January 2011refer the reader to specialized references [1, 3] for Note that this definition is so general that it canmore details. consider any CSP. It is the case when Csi are all When a value v of some variable xi violates a constraints of Pi-1. In fact, we suppose that only aconstraint Cj, this value cannot participate to a portion of constraints are added or removed at eachsolution; so it must be removed. We say that the step i. (The approach described in section 7.2 can bevalue v of the variable xi has no support in the modeled with a dynamic CSP where the changesconstraint Cj, or more commonly: we say that v is not model is known a priori. Indeed, the CSP Pi+1 resultsarc-consistent. In opposite, a value v of xi, for which from the CSP Pi by reducing the domain Di of thewe can find values in the other variables of the variable xi to a single value vi.)constraint Cj, is called arc-consistent. Let be the CSPgiven above. We can notice that the value 1 for x has 6. CP Model for Ontologies Axiomsthe support 2 in y in the constraint C1; in the sameway for 2. However, in C3, the value 4 for z has not a We show how the axioms templates elaborated in [7]support in C3, and then it is removed. It is the unique can be translated to constraints within the CSPvalue that must be removed with the arc-consistency framework. This translation allows efficientproperty. The arc-consistency can be verified on algorithms developed in constraint programming tovarious types of binary constraints (where each be used. The objective is to verify the user-definedconstraint holds on at most two variables) in a time constraints efficiently. We propose two schemes toweakly polynomial. There does not exist an efficient translate axioms to CSP constraints [2].global algorithm for n-ary constraints; however Below, we give some translations of some axiomsalgorithms exist for specific constraints such as the presented in [8]. The others are detailed in theconstraint of difference x1 ≠ x2 ≠ … ≠ xn. appendix section. If a value v of some variable xi leads to a solution Scheme 1: let be the class C. We note:for all constraints, we say that this value is globally • I1, …, In: The instances of class C.consistent, otherwise it is removed. Reaching the • R1, …, Rm: The roles associated to the class C.global consistency of some value is NP-complete. So, • Range(Ri): The set of values associated to the rolefiltering with the global consistency is naturally of Ri.exponential complexity. For example in the aboveCSP we see that the values 1 and 2 for z cannot be For the role R, we consider the followingcompleted in x and y to form a solution, so they are correspondence:removed. However the value 3 finds 2 in x and 1 in • xi corresponds to Ii, i=1...n: the instances Ii arey. considered as the CSP variable xi. Hence, the arc-consistency filtering leads to thefollowing domains D(x) = D(y) = {1, 2}, D(z) = {1, • Di = D(xi) = Range(R): The domain Di of the2, 3}. And the global consistence filtering leads to the variable xi is equal to the range of R.following domains D(x) = D(y) = {1, 2}, D(z) = {1, The user defined axioms can then be expressed as2, 3}. CSP constraints. We give below an example. In the following sections, we detail how to use Examplefiltering algorithms to detect ontology • Axiom: every instance of the class C must have ainconsistencies. unique value for the role R. • Corresponding CSP constraint: The axiom5.2. Dynamic CSPs mentioned above can be expressed by the constraint: Alldiff(x1, …, xn) [11].The CSP presented above is static. Its differentcomponents (e.g., variables, domains and constraints) Scheme2do not change during solving. Nevertheless, in Let be some class C.practice [15], this assumption is not usually verified, • I1, …, In: The instances of class C.particularly when we are confronted to dynamic • R1, …, Rm: The roles associated to the class C.problems. We consider the following correspondence: The dynamic CSP model [4] has been introduced • xi corresponds to Ri, i=1,..., m: the roles Ri areto manage the changes occurring during solving. considered as CSP variable xi.Below, we give a formal definition of dynamic CSPs. • Di = D(xi) = Range(Ri): the domain D(xi) of theDefinition [15], a Dynamic CSP (DCSP) is a variable xi is equal to the range of Ri.sequence (P1, P2, …, Pn) where for each i ∈ 1 .. n:• Pi = (X, D, Ci) denotes a CSP. The user defined axioms can then be expressed as the CSP constraints. We give below an example.• Cai denotes a set of added constraints.• Csi denotes a set of removed constraints.• Csi ⊆ Ci-1 and Ci = Ci-1 + Cai - Csi.
    • A Constraint Programming Based Approach to Detect Ontology Inconsistencies 5Example 8.1. Systematic Approach• Axiom: for every instance of the class C the roles This approach consists in generating, a priori, all Ri and Rj cannot have the same value. inconsistent values with ontology constraints. This• Corresponding CSP constraint: The axiom set will be exploited to analyze the user input. Below, mentioned above can be expressed by the we describe the system architecture and the constraint xi ≠ xj. inconsistency checking process.7. Processing the Constraints 8.1.1. System ArchitectureLet be a CSP modeling axioms coming from the The proposed system contains the followingscheme of some ontology. In order to detect components as shown in Figure 3.inconsistent values we propose two approaches: 1. The EZPAL interface: this interface is developed1. An incomplete approach: in this approach, the by [7] as a plug-in in the Protégé editor. It allows filtering algorithms associated to the constraints the user introducing his axioms simply by are executed iteratively until all constraints are instantiating predefined templates. The axioms are locally consistent. This process detects and then stored in axioms base. computes all values of the variables that are 2. The translator: this component translates the locally inconsistent with each constraint axioms in CSP Constraints. It uses the separately. Obviously, this procedure does not transformation base and generates the CSP detect the global inconsistencies, i.e. the constraints. inconsistencies concerning all the constraints 3. Inconsistent values generator: this component simultaneously. executes a set of filtering algorithms developed in2. A complete approach: in this approach we proceed constraint programming. It generates all the with two phases. The first phase consists in inconsistent values with CSP constraints generated applying a global solving algorithm to find all by the translator. solutions. The second one examines the solutions 4. Inconsistency checker: this component uses the set and detects the globally inconsistent values. inconsistent values base generated above and generates all the inconsistent values in the userObviously, the complete approach is the ideal one as data flow. A feedback is returned to the user.it detects all the inconsistencies. However, it iscomputationally very expensive because of its NP- 8.1.2. The Process of Consistency CheckingHard nature. Here, the enumeration is forced by theguarantee that all values lead to solutions. The process of consistency checking proposed here The incomplete approach, due to its low can be divided into two phases as shown in Figure 3.complexity, can be a reasonable approach as itenables finding inconsistencies as the user fixes the User Inputontology variables without, however, ensuring that Interfacethese values lead to solutions. EZPAL Inconsistent In the following, we propose architectures to values generator.integrate CP in inconsistencies detection. In practice, Axiomswe can use the complete approach if it is not Base Inconsistentcomputationally very expensive; otherwise we opt for values basethe incomplete one. Translato Transformation8. Consistent Handling of Changes Base CSPIn this section we propose two approaches to support Constraints Consistencythe user in managing consistently the ontology checkerchanges. These approaches go beyond the simpledetection of inconsistencies. They offer user means Inconsistentensuring the ontology evolution towards a consistent valuesstate. In the first approach, qualified with systematic,we describe the system architecture. For the second Figure 3. Specification of the environment.approach, qualified with interactive, we propose aninteraction model between a user and a CP solver. Phase 1: the ultimate objective of this phase is toThis interaction leads to the final consistent ontology. generate inconsistent values that enable detection of
    • 6 The International Arab Journal of Information Technology, Vol. 8, No. 1, January 2011inconsistent values in the user data flow introduced in 8.2.1. The Interaction Modelphase 2. This phase can be divided into two steps: Let be a CSP of n variables, the interaction model• Step 1: CSP constraints generation. The user consists of a succession of n cycles. Each cycle composes his axioms by instantiating appropriate consists of two successive phases described below. templates. He uses the EZPAL interface [7]. Then, Phase 1: the user sends a message to the solver. these axioms are transformed into CSP constraints This message consists of a request. The purpose of by the translator. the request is the computation of all values of xi• Step 2: inconsistent values generation. The values domain, Di, that are consistent with the constraint C. that violate the CSP constraints, developed in the At this level the request embodies the following previous step, are generated. At this level, the information: filtering algorithms generate efficiently, a priori, • The domains D1, …, Di-1 reduced to values v1, …, all the values inconsistent with CSP constraints vi-1 determined in previous cycles. generated in step 1 above. • Di, …, Dn as defined in the initial CSP.Phase 2: The ultimate objective of this phase is to Phase 2: The solver sends a message to the user,detect the inconsistent values introduced in the user which consists in an answer to the request formulateddata flow. This phase can be divided into two steps: in Phase 1. The solver computes the set Ei (the set of• Step 1: formulation of the user request. The user all values of the variable xi belonging to Di that are request is assumed here to be of high complexity, consistent with the constraint C) which is transmitted in the sense that it contains a significant amount of to the user. data: • In Phase 1 of cycle 1, the CSP transmitted is the• The different classes to be modified. initial one.• For every class, the different instances values for • The end of interaction occurs when the user sends different roles. This information can be new, for an end message to the solver. instance, when adding instances or updating • At the end of each cycle, the user selects a value data. from the set returned by the solver and restarts the• Step 2: Inconsistency detection. The inconsistency following cycle. checker detects all the inconsistent values introduced in the user data flow in step 1 of phase 2 mentioned above. For this purpose, it uses the 8.3. Comparison inconsistent values base. The interactive approach has the followingThe inconsistent values set are then returned to the advantages:user as a system feedback. 1. The performance of filtering algorithms developed in constraint programming enables a real time8.2. Interactive Approach interaction. 2. Interaction between the user and the solverWe give the interaction model between the user and a converges to a consistent ontology.CP solver. This interaction has the particularity of 3. The interaction model makes easy to the userconducting to a final consistent state as shown in selecting the affected value.Figure 4. User Solver In the other hand, the systematic approach has the ({x1,…,xn}, {D(x1),…,D(xn)}, C) advantage of reducing the search space to only consistent values. This allows the user managing E1 consistently the ontology changes. However, this approach requires also user intervention. ({x1,…,xn}, {D(x1)={v1},D(x2),…,D(xn)}, C) 9. Conclusions and Perspectives Ei In this paper we showed that constraint programming ({x1,…,xn}, {D(x1)={v1},…,D(xi),={vi},…,,D(xn)}, C) can really serve ontologies consistency management. More precisely, filtering algorithms developed in constraint programming can contribute efficiently to En the ontology user defined consistency checking. We Dialogue end. proposed a translation model of axioms to constraints which is the core of an environment for supporting Figure 4 . Dialogue model. the user in managing consistently the ontology changes.
    • A Constraint Programming Based Approach to Detect Ontology Inconsistencies 7 Large CSPs (with many variables), however, Habilitation à Diriger des Recherches,should be generated by the system. This is the main Université de Nice Sophia Antipolis, 2004.limit of the approach presented here. We are [13] Staab S. and Maedeche A., “Axioms areconsidering this issue by studying the boundary upon Objects too Ontology Engineering Beyond thewhich the dialogue model will be hardly practicable. Modelling of Concepts and Relations,” in The first perspective of this work is to implement Proceedings of The 14th Electronic Culturalour framework as a Protégé plug-in. In fact, the Atlas Initiative, Workshop on Ontologies andsystem is under development. The second perspective Problem Solving Methods, Berlin, pp. 159-163,is to consider more general axioms not mentioned in 2000.[7]. [14] Stojanovic L., “Methods and Tools for The system presented here is built upon axioms Ontology Evolution,” PHD Thesis, Universitywhich are abstractions of constraints expressed in of Karlshue, 2004.much significant ontologies belonging to various [15] Verfaillie G. and Jussien N., “Constraintdomains. Hence, the system applications range is Solving in Uncertain and Dynamiclarge: bioinformatics, management, etc., It can be Environment a Survey,” Computer Journal ofplugged in every ontology management system. Constraints, vol. 10, no. 3, pp. 253-281, 2005.References[1] Apt K., Principles of Constraint Programming, Moussa Benaissa received his Cambridge University Press, 2003. engineering degree and his Master[2] Beldiceanu N., Carlson M., Demassey S., and degree in computer science from Petit T., “Global Constraints Catalog: Past, the University of Es-Senia Oran, Present and Future,” Computer Journal of Algeria, in 1988 and 1992, Constraints, vol. 12, no. 1, pp. 21-62, 2007. respectively. He is actually a[3] Dechter R., Constraint Processing, Morgan lecturer at University of Oran Es- Kaufmann Press, 2003. Senia. His research interest includes e-learning,[4] Dechter R. and Dechter A., “Belief ontologies, and constraint programming. Maintenance in Dynamic Constraint Networks,” in Proceedings of 7th National Yahia Lebbah received his Conference on Artificial Intelligence, USA, pp. engineering degree in 1995 from 37-42, 1988. the University of Es-Senia Oran,[5] Fages J., Programmation Logique et Par Algeria, and his MS degree in 1996, Contraintes, Ellipses Presse, 1996. from the University of Paris 13, and[6] Haase P. and Stojanovic L., “Consistent PhD degree in 1999 from Ecole des Evolution of OWL Ontologies,” Lecture Notes Mines de Nantes, France. All in Computer Science, 2005. degrees are in computer science. He is currently a[7] Hou J., Musen A., and Noy F., “EZPAL: professor in the Computer Science Department at the Environment for Composing Constraint University of Es-Senia Oran, Algeria. Axioms by Instantiating Templates,” International Journal of Human Computer Studies, vol. 62, no. 5, pp. 578-596, 2005. Appendix[8] Hou J., Noy F., and Musen A., “A Template- C denotes some class. I denotes an instance. R Based Approach Toward Acquisition of Logical denotes a slot. Sentences,” in Proceedings of the Conference Axiom 1. Every instance of class C must have a of Intelligent Information Processing unique value in slot R. Montréal, Canada, pp. 25-28, 2002. Constraint: ∀ I1, I2 ∈ C, R(I1) ≠ R(I2).[9] Mackworth A., “Consistency in Networks of Axiom 2. For every instance of class C, slots Ri and Relations,” Computer Journal of Artificial Rj cannot have the same value. Intelligence, vol. 8, no. 1, pp. 99-118, 1997.[10] The Protégé Project, http://protege.stanford.edu. Constraint: ∀ I ∈ C, Ri(I) ≠ Rj.[11] Régin C., “A Filtering Algorithm for Axiom 3. At least one instance of class C contains Constraints of Difference Constraint value v in slot R. Satisfaction Problems,” in Proceedings of Constraint: ∃ I ∈ C, v ∈ R(I). Association for the Advancement of Artificial Axiom 4. If an instance of class C contains value v1 Intelligence, USA, pp. 362-367, 1994. in slot Ri it must contain value v2 in slot Rj.[12] Régin C., “Modélisation et Contraintes Constraint: ∀ I ∈ C, v ∈ Ri(I) ⇒ v2 ∈ Rj(I). Globales en Programmation Par Contraintes,”
    • 8 The International Arab Journal of Information Technology, Vol. 8, No. 1, January 2011Axiom 5. Every instance of class C1 appears at least contains I2 in slot Rj of class C3. once in slot R of any instance of Class C2. Constraint: ∀ I1 ∈ C1, Ri(I1) = I2 ⇒ ∃ I3 ∈ C3, I2 Constraint: ∀ I1 ∈ C1, I1 ∈ R(C2). ∈ Rj(I3).Axiom 6. For every instance of class C, value of slot Axiom 18. For every instance I1 of class C1, if Ri is > (or =, <), than the value of slot Rj. the value of slot Ri is an instance I2 of class C2, Constraint: ∀ I ∈ C, Ri(I) op Rj(I) where op ∈ then there is an instance I3 of class C3 that {>, =, <}. contain I1 in slot R1 and I2 in slot R2.Axiom 7. For every instance of class C, slot Ri and Constraint: ∀ I1 ∈ C1, Ri(I1) = I2 ⇒ ∃I3 ∈ C3, slot Rj must have instances of the same class. Rj(I3) = I1, R2(I3) = I2. Constraint: ∀ I ∈ C, ∃ C1, Ri(I) ∈ C1 and Rj(I) ∈ Axiom 19. For every instance I1 of class C1, if C1. the value of slot Ri has an instance I2 of classAxiom 8. For every instance I1 of class C1, there C2, then slot R1 of I1 has value > (or =,<) than must be an instance I2 of class C2 which contains value of slot R2 of I2. I1 in R. Constraint: ∀ I1 ∈ C1, Ri(I1) = I2 ⇒ R1(I1) op Constraint: ∀ I1 ∈ C1, ∃ I2 ∈ C2, I1 ∈ R(I2). R2(I2) where op ∈ {>, = >}.Axiom 9. Every instance of class C that shares the Axiom 20. If an instance I1 of class C1 has same value in slot Ri can not (resp. must) have instance I2 of class C2 in slot R1 of I1 and I2 of identical values in Rj. class C2 has instance I3 of class C3 in slot R2 of I2 Constraint: ∀ I1, I2 ∈ C, Ri(I1) = Ri(I2) ⇒ Rj(I1) then I3 must (resp. cannot) have I1 in slot R3. ≠ Rj(I2) (resp. ∀ I1, I2 ∈ C, Ri(I1) = Ri(I2) ⇒ Constraint: R1(I1) = I2 and R2(I2) = I3 ⇒ R3(I3) = Rj(I1) = Rj(I2)). I1 (resp. R2(I2) = I3 ⇒ R3(I3) ≠ I1).Axiom 10. For every instance of class C1, value Axiom 21. For every instance I1 of class C1, if of slot Ri must also be a value of slot Rj of an the value of slot R1 has an instance I2 of class C2, instance of class C2. then if slot R1 of I1 has value v1 slot R2 of I2 has Constraint: ∀ I1 ∈ C1, ∃ I2 ∈ C2, Ri(I1) = Rj(I2). value v2.Axiom 11. For every instances of class C slot Ri Constraint: ∀ I1 ∈ C1, Ri(I1) = I2 ⇒ (R1(I1) = v1 cannot contain both instances of class C2 and ⇒ R2(I2) = v2). class C3. Axiom 22. Every instance I1 of class C1 which Constraint: ∀ I ∈ C, R(I) ∉ C2 ∩ C3. contains value v in slot R1 must have values inAxiom 12. For every instance I1 of class C1 if the slot R2 which are instances of class C2. value of slot Ri is an instance I2 of class C2, they Constraint: ∀ I1 ∈ C1, v ∈ R1(I1) ⇒ R2(I1) ∈ C2. must share the same value in slot Rj for I1 and slot Rk for I2. Constraint: ∀ I1 ∈ C1, Ri(I1) = I2 ⇒ Rj(I1) = Rk(I2).Axiom 13. For every instance I1 of class C1 slot Ri must have values that are instances of classes specified by slot Rj of class C2. Constraint: ∀ I1 ∈ C1, Ri(I1) ∈ Rj(C2).Axiom 14. If an instance I1 of class C1 has slot Ri that contains value v then I2 of class C2 cannot (resp. must) contain I1 in slot Rj. Constraint: ∀ I1 ∈ C1, Ri(I1) = I2 ⇒ I1 ∉ Rj(I2) (resp. ∀ I1 ∈ C1, Ri(I1) = I2 ⇒ I1 ∈ Rj(I2)).Axiom 15. Every instance of class C1, which has a value in slot Ri > (or =, <) than every (resp. at least one) value of slot Rj of class C2. Constraint: ∀ I1 ∈ C1, ∀ I2 ∈ C2, Ri(I1) op Rj(I2) (resp. ∀ I1 ∈ C1, ∃ I2 ∈ C2, Ri(I1) op Rj(I2)) where op ∈ {>, =, <}.Axiom 16. For every instance I1 of class C1, if the value of slot Ri has an instance I2 of class C2, I2 must have value v in slot Rj. Constraint: ∀ I1 ∈ C1, Ri(I1) = I2 ⇒ Rj(I1) = v.Axiom 17. For every instance I1 of class C1, if the value of slot Ri has an instance I2 of class C2, then there is an instance I3 of class C3 that