1. 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, Algeria
Abstract: This paper proposes a constraint programming based approach to handle ontologies consistency, and more
precisely user-defined consistencies. In practice, ontologies consistency is not still well handled in the current software
environments. This is due to the algorithmic and language limitations of the tools developed to handle the consistency
constraints. The idea of this paper is to tackle this problem by exploiting constraint programming which is proved to be
efficient 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, 2008
1. Introduction holding both on reals and Herbrand space is very
difficult since there are no algorithmic connections
Ontologies have been widely adopted both in between logic and linear programming.
academic and industrial applications. They are Constraint programming overcomes this limitation
entities evolving continuously. One of the main by allowing several constraints to be expressed on
aspects to consider during this evolution process is to various domains. It uses existing mathematical
detect their consistencies. Consistency can be defined techniques to process general constraints with generic
as a set of constraints that should be verified. Below, methods. In other terms, constraint programming is
we 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 proposed
Here, we are concerned with user defined approach with an example. In section 4, we present
consistency. Ontology development environments user axioms classification developed in an empirical
such as Protégé [10] include tools based on first order study [5]. Section 5 introduces constraint
logic. For example Protégé Axiom Language (PAL) programming and more particularly the Constraint
for Protégé enables to express consistency axioms as Satisfaction Problems (CSP) notation and its generic
a 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 the
axioms templates in order to facilitate composing the classification presented in section 4. In section 7, we
user 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. Conclusion
programming techniques provide efficient algorithms and some perspectives conclude the paper.
which can be used to handle this problem. Except
Constraint Programming (CP), other techniques are
very specific. It is very difficult to process new 2. Motivation and Contribution
constraints with them. For example linear Ontologies are nowadays ubiquitous. Their number,
programming can process only linear constraints. their complexity and the domains they model are
Logic programming handles clauses in the Herbrand increasing considerably. Ontology management
space [5]. However the task of processing constraints systems should be developed to support the user.

2. 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 Tasks
knowledge embedded in various application domains. Assignment Problem
So, it is necessary to extend them to make easy the
expression and the treatment of other aspects of The above problem can be modeled with the
knowledge such as constraints. In fact, some following ontology as shown in Figure 1. We have
expressiveness issues have been considered by some two concepts: T whose instances are the tasks and P
works [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 P
constraints in real contexts. This complexity aspect is and T as respectively the domain and the range. It
particularly critical in dynamic industrial applications captures employee preferences. We represent it as
where 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 as
framework for studying combinatorial problems. It respectively the domain and the range. It represents
offers more general and powerful tools than those of the problem solution. With cardinality constraints, we
logic programming. associate the following user-defined axioms:
Concept : P
3. Tasks Assignment Problem
can-do Is-realized-by
In order to illustrate our approach, we consider a
tasks assignment problem. We have two sets: the
tasks T and the persons P. T is defined as T = {A, M, Concept : T
C, 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 of
which 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 Solution
Patrice realize respectively the tasks A, M, A, M, C, The solution we propose is based on constraint
O and D. programming. More precisely, we translate the above
ontology to a Constraint Satisfaction Problem (CSP)

3. A Constraint Programming Based Approach to Detect Ontology Inconsistencies 3
and use filtering techniques to reduce the search 5. Constraint Programming
space.
The CSP is defined as follows (for the details see Constraint Programming (CP) is a problem solving
the 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 CSP
4. 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) where
do 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)}, where
overcome 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 capture
these axioms. 5.1.1. Solving CSPs
However, it is pointed out [8] that these tools are
CSP solving techniques are organized according to
not 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 the
the complexity [7] of languages underlying these
search space induced by the CSP. Exploration
tools.
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 a
specific user interfaces that make easy axioms
single solution or cannot prove the non-existence of
expression without using these languages. Below we
solutions, then the values of the variables domain are
describe 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 has
significant existing ontologies and deriving templates
usually a weak polynomial complexity.
from user defined axioms. About twenty templates
More precisely [12], each constraint has a specific
that cover 85% of user defined axioms have been
filtering algorithm. It removes, from the domains of
abstracted 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 called
of 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 general
the blanks”. In Figure 2, we give an example of such
property of filtering algorithms. Below, we give an
templates [7].
informal introduction and some illustrations and we

4. 4 The International Arab Journal of Information Technology, Vol. 8, No. 1, January 2011
refer the reader to specialized references [1, 3] for Note that this definition is so general that it can
more 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 a
constraint Cj, this value cannot participate to a portion of constraints are added or removed at each
solution; so it must be removed. We say that the step i. (The approach described in section 7.2 can be
value v of the variable xi has no support in the modeled with a dynamic CSP where the changes
constraint Cj, or more commonly: we say that v is not model is known a priori. Indeed, the CSP Pi+1 results
arc-consistent. In opposite, a value v of xi, for which from the CSP Pi by reducing the domain Di of the
we 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 CSP
given above. We can notice that the value 1 for x has 6. CP Model for Ontologies Axioms
the support 2 in y in the constraint C1; in the same
way 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 CSP
value that must be removed with the arc-consistency framework. This translation allows efficient
property. The arc-consistency can be verified on algorithms developed in constraint programming to
various types of binary constraints (where each be used. The objective is to verify the user-defined
constraint holds on at most two variables) in a time constraints efficiently. We propose two schemes to
weakly 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 axioms
algorithms exist for specific constraints such as the presented in [8]. The others are detailed in the
constraint 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 role
filtering with the global consistency is naturally of
Ri.
exponential complexity. For example in the above
CSP we see that the values 1 and 2 for z cannot be For the role R, we consider the following
completed 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 are
y.
considered as the CSP variable xi.
Hence, the arc-consistency filtering leads to the
following domains D(x) = D(y) = {1, 2}, D(z) = {1, • Di = D(xi) = Range(R): The domain Di of the
2, 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 as
2, 3}. CSP constraints. We give below an example.
In the following sections, we detail how to use Example
filtering algorithms to detect ontology • Axiom: every instance of the class C must have a
inconsistencies. unique value for the role R.
• Corresponding CSP constraint: The axiom
5.2. Dynamic CSPs mentioned above can be expressed by the
constraint: Alldiff(x1, …, xn) [11].
The CSP presented above is static. Its different
components (e.g., variables, domains and constraints) Scheme2
do 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 are
to 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 the
Definition [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.

5. A Constraint Programming Based Approach to Detect Ontology Inconsistencies 5
Example 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 Architecture
Let be a CSP modeling axioms coming from the The proposed system contains the following
scheme 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 developed
1. 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 in
2. 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 user
Obviously, the complete approach is the ideal one as data flow. A feedback is returned to the user.
it detects all the inconsistencies. However, it is
computationally very expensive because of its NP- 8.1.2. The Process of Consistency Checking
Hard nature. Here, the enumeration is forced by the
guarantee 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 it
enables finding inconsistencies as the user fixes the User Input
ontology variables without, however, ensuring that Interface
these values lead to solutions. EZPAL Inconsistent
In the following, we propose architectures to values generator.
integrate CP in inconsistencies detection. In practice,
Axioms
we can use the complete approach if it is not Base Inconsistent
computationally very expensive; otherwise we opt for values base
the incomplete one.
Translato
Transformation
8. Consistent Handling of Changes Base
CSP
In this section we propose two approaches to support Constraints Consistency
the user in managing consistently the ontology checker
changes. These approaches go beyond the simple
detection of inconsistencies. They offer user means
Inconsistent
ensuring the ontology evolution towards a consistent
values
state. 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 an
interaction model between a user and a CP solver. Phase 1: the ultimate objective of this phase is to
This interaction leads to the final consistent ontology. generate inconsistent values that enable detection of

6. 6 The International Arab Journal of Information Technology, Vol. 8, No. 1, January 2011
inconsistent values in the user data flow introduced in 8.2.1. The Interaction Model
phase 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 formulated
data 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 following
The 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 time
8.2. Interactive Approach interaction.
2. Interaction between the user and the solver
We 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 user
conducting 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.

7. 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 are
considering this issue by studying the boundary upon Objects too Ontology Engineering Beyond the
which 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 Cultural
our framework as a Protégé plug-in. In fact, the Atlas Initiative, Workshop on Ontologies and
system 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, University
which are abstractions of constraints expressed in of Karlshue, 2004.
much significant ontologies belonging to various [15] Verfaillie G. and Jussien N., “Constraint
domains. Hence, the system applications range is Solving in Uncertain and Dynamic
large: bioinformatics, management, etc., It can be Environment a Survey,” Computer Journal of
plugged 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. 8 The International Arab Journal of Information Technology, Vol. 8, No. 1, January 2011
Axiom 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 class
Axiom 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 in
Axiom 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