Abstract
Abstract
Full implementation of the Semantic Web requires widespread availability of (fuzzy) ontologies. In this paper, we develop a complete approach and an automated tool for formalizing fuzzy object-oriented database (FOOD) models using fuzzy ontologies (i.e., constructing fuzzy ontologies from FOOD models), and investigate how to apply the constructed fuzzy ontologies to reason on FOOD models. Firstly, we propose a complete formal definition of FOOD models, which considers most features of FOOD models. On this basis, we propose an approach for constructing fuzzy ontologies from FOOD models. The approach can transform FOOD models (including schema and object instance information) into fuzzy ontologies. We also give full proof of correctness of the construction approach, and provide a full construction example. Furthermore, we implement a prototype tool called FOOD2FOnto, which can automatically construct fuzzy ontologies from FOOD models. Some tests demonstrate that our approach actually works. Finally, the constructed fuzzy ontologies are used to reason on the FOOD models, and some reasoning rules and a reasoning example are provided.
Introduction
Full implementation of the Semantic Web requires widespread availability of ontologies. Therefore, how to construct ontologies has become a key technology to enable the Semantic Web. Driven by this need, many methods and tools have been developed to construct ontologies from some data sources, such as textual data, dictionaries, knowledge bases, XML, and databases (see [14] for surveys).
However, the classical ontology construction approaches were not sufficient for handling imprecise and uncertain information that is commonly found in real-world applications, such as the Semantic Web, information systems, and databases [16, 25]. Correspondingly, great efforts on constructions of fuzzy ontologies have been made in recent years. There have been some strategies for constructing fuzzy ontologies from some data sources (e.g., uncertainty data [24], and fuzzy databases [7, 32]). It can be found that constructions of fuzzy ontologies from fuzzy database models (such as fuzzy ER/EER models [17, 29], fuzzy UML models [28, 31], and fuzzy relational database models [7, 32]) have increasingly received attentions, since researches of fuzzy databases have been developed over the past thirty years and tremendous gain is hereby accomplished in this area (see [16] for an overview). In particular, with the development of fuzzy database modeling, it has been proved that the classical database models (such as ER/EER models, relational models, and UML models) and their extensions of fuzziness do not satisfy the need of handling complex objects with imprecision and uncertainty, and thus fuzzy object-oriented database (FOOD) models were developed and applied in data and knowledge intensive applications such as CAD/CAM, multimedia, and expert systems [1, 34]. Therefore, this type of data source is too valuable to be neglected for fuzzy ontology development. On one hand, constructing fuzzy ontologies from FOOD models may facilitate the development of fuzzy ontologies in the Semantic Web. On the other hand, constructing fuzzy ontologies from FOOD models may provide a way for intelligently handling some issues of FOOD models. For example, some reasoning problems of a FOOD model may be checked by the reasoning ability of the constructed fuzzy ontology instead of checking them by hand.
In this paper, we investigate how to formalize FOOD models using fuzzy ontologies. In general, the paper makes the following main contributions:
The remainder of this paper is organized as follows. Section 2 introduces some preliminaries. Section 3 investigates how to construct fuzzy ontologies from FOOD models. Section 4 investigates how to reason on the FOOD models. Section 5 introduces related work. Section 6 shows conclusions.
Preliminaries
In this section, we briefly report some preliminaries on fuzzy ontologies and FOOD models.
Fuzzy ontologies
A fuzzy ontology is usually represented by fuzzy OWL language [8, 26], which is a fuzzy extension of the W3C recommendation standard ontology language OWL. The semantics for fuzzy OWL is given by a fuzzy interpretation FI = (Δ FI, Δ D , • FI, • D) based on the interpretation of the fuzzy description logic f-SHOIN(D) (please refer to [8, 26] in detail). A fuzzy ontology formulated in fuzzy OWL language is called fuzzy OWL ontology [29, 32].
FID
0 = FCID
0 ∪ FIID
0 ∪ FDRID
0 ∪ FDPID
0 ∪ FOPID
0 is a set of identifiers partitioned into: a subset FCID
0 of fuzzy class identifiers; a subset FIID
0 of individual identifiers; a subset FDRID
0 of fuzzy data range identifiers; a subset FDPID
0 of fuzzy datatype property identifiers; and a subset FOPID
0 of fuzzy object property identifiers;
FAxiom
0 is a set of fuzzy OWL axioms defined over FID
0 partitioned into: a subset of fuzzy class/property axioms, used to represent fuzzy ontology structure information FOS; and a subset of fuzzy individual axioms, used to represent fuzzy ontology instance information FOI.
In brief, a fuzzy OWL ontology FO is formally a set of fuzzy OWL axioms defined over some identifiers. We say that a fuzzy interpretation FI is a model of FO iff it satisfies all axioms in FO.
FOOD models
The fuzzy object-oriented database (FOOD) model [4–6, 33] is a fuzzy extension of the traditional object-oriented database model, and some notions such as objects, classes, and hierarchies of classes are extended under fuzzy information environment [35]:
Fuzzy objects: An object is fuzzy because of a lack of information. Formally, an object is fuzzy one if at least one of its attribute values is a fuzzy value.
Fuzzy classes: The domains of some attributes of a class are fuzzy and thus a fuzzy class is formed. In this case, an object belongs to the class with a membership degree of [0, 1]. Fuzzy inheritance hierarchies: In a FOOD model, a inheritance relationship may be fuzzy. In other words, a class is a subclass of another class with a membership degree of [0, 1]. Further, several inheritances can be grouped together to form a class hierarchy. Two optional constraints disjoint and complete can be enforced on a class hierarchy. The disjoint constraint means that all the subclasses in the class hierarchy are disjoint, and the complete constraint means that the union of subclasses completely covers the superclass in the class hierarchy. Moreover, to model kinds of real-world situations, it is often necessary to add more complex constraints to FOOD models, such as cardinality constraints and inverse attributes (see Section 3.1).
Construction of fuzzy ontologies from FOOD models
In this section we propose an approach and implement a tool for constructing fuzzy ontologies from fuzzy object-oriented database (FOOD) models.
Formalization of Fuzzy Object-Oriented Database (FOOD) models
In the following we propose a formal definition and a semantic interpretation method of fuzzy object-oriented database (FOOD) models, so as to establish correspondences between FOOD models and fuzzy ontologies. Based on the definitions of (fuzzy) object-oriented database models [10, 33], we further consider the extensional class and the fuzziness at subclass/superclass level, include the schema and object instance information in the formal definition simultaneously, add and modify some expressions for accurately representing the domain information in FOOD models. In general, our formal definition (i.e., Definition 2) considers structural and dynamic aspects of FOOD models, and contains the major notions of fuzzy objects, fuzzy classes, fuzzy inheritance hierarchies, and other constraints (e.g., the disjoint and complete constraints on class hierarchies and the cardinality constraints on associations).
FOODFS = (FOFS, FDFS, FCFS, FAFS, FPFS) consists of a set of object identities, attribute domains, classes, attributes, and class declarations, where: FOFS is a set of objects FO; each object is characterized by a unique object identity (OID); FDFS is a set of domains FD, which includes crisp and fuzzy domains. For example, the domain of the fuzzy attribute “FUZZY age” is a fuzzy domain fdom1 = {young, middle, old}. Similarly, the domain of the fuzzy attribute “FUZZY seniority” is a fuzzy domain fdom2 = {veryshort, short, middle, long, verylong}. FCFS is a set of classes FC; FAFS is a set of attributes FA; each attribute FA is associated with a domain FD, and a fuzzy keyword FUZZY may appear in front of an attribute indicating it is a fuzzy attribute; FPFS is a set of class declarations. For each class FC ∈ FCFS, FPFS contains a declaration:
Class FC is-a FC s up/β type-is FT,
FT denotes a schema type expression built according to the following syntax:
FT → {FO1/μ 1, FO2/μ 2, … , FOn/μ n} End |
Union FC1 … FCq (disjoint, complete) End |
Record FA1: FT1, … , FAk: FTk, μ: Real, f (P1, … , Pm): R End
where FT i is one of the following cases (where i ∈ {1 … k}):
FTi → FDi|
Set-of FCi/η
i [(m1, n1), (m2, n2)]. FOODFO is a set of object declarations FPFO representing values of attributes of objects. For each object FO ∈ FOFS, FPFO contains a declaration:
Object FO belong-to FC/μ
has-value [FA1 : FD1, FA2 : FD2…] End.
The Definition 2 can be illustrated as follows: The is-a part, which is optional, denotes a class FC is a subclass of another class FCsup with a membership degree β ∈ [0, 1]; The type-is part specifies the structure of a class FC through a type expression FT; The expression {FO1/μ
1, FO2/μ
2, … , FOn/μ
n} denotes that FC is an extensional class defined by a list of its object instances {FO1/μ
1, FO2/μ
2, … , FOn/μ
n}, and each object FO
i
belongs to the class FC with a membership degree of μ
i ∈ [0, 1]; The Union … End part denotes a class hierarchy; The Record … End part denotes that a fuzzy class FC is defined by a set of attributes; an additional attribute μ
i ∈ [0, 1] is used to represent the membership degree of an object belonging to the class FC; f (P
1, … , P
m): R represents a method, where f is the name of the method, P
1, … , P
m are types of m parameters, and R is the type of the result; The Set-of part (i.e., Class FC type-is Record FAi: Set-of FCi/η
i [(m
1, n
1) , (m
2, n
2)] End) denotes an association relationship between classes FC and FCi by an attribute FAi; η
i ∈ [0, 1] denotes the association occurs in classes FC and FCi with a membership degree of η
i; [(m
1, n
1) , (m
2, n
2)] specifies that each object instance of a class can participate at least m
i times and at most n
i times to the association; The belong-to part denotes that an object FO belongs to a fuzzy class FC with a membership degree of μ ∈ [0, 1]; The has-value part denotes values of attributes of the object FO, and the attributes are defined in the fuzzy class FC that the object belongs to.
The following Fig. 1 gives the formal representation of a FOOD model FOOD1.
Being similar to the semantics of (fuzzy) object-oriented database models [10, 30], the semantics of a FOOD model can be given by fuzzy database states (i.e., sets of object instances), namely, by specifying which fuzzy database state (e.g., the object information) is consistent with the schema structure of the FOOD model (e.g., the schema information).
A set FV
FJ = FD
FJ ∪ FO
FJ ∪ FR
FJ ∪ FS
FJ of fuzzy values is inductively defined as follows:
, where FDi is a crisp or fuzzy domain as mentioned in the previous sections;
FO
FJ = {FO1/μ
1, … , FOn/μ
n}, where FOi is an object associated with a membership degree μ
i;
FR
FJ is a set of record values. A record value is denoted by [FA1 : FV
1, … , FAk : FV
k], where FAi is an attribute, FV
i
∈ FV
FJ
, i ∈ {1, … , k};
FS
FJ is a set of set-values. A set-value is denoted by {FV
1, … , FV
k}, where FV
i ∈ FV
FJ, i ∈ {1, … , k}. A function π
FJ maps a class to a set of its objects, i.e., assigns to each class FC a subset of FO
FJ. A function ρ
FJ maps an object to values of its attributes. A function •FJ maps each type expression FT in Definition 2 to a set FT
FJ in such a way that: If FT is a class FC, then FT
FJ = FC
FJ = π
FJ (FC); If FT is a record type Record … End (resp. a set type Set-of …), then FT
FJ is a set of record values FR
FJ (resp. a set of set-values FS
FJ); If FT is a union type Union FC1, …, FC
q
(disjoint, complete) End, then it follows and , where i, j ∈ {1, …, q}, and i ≠ j.
Furthermore, if for each class declaration Class FC is-a FCsup/β type-is FT in a FOOD model, the fuzzy database state FJ defined above satisfies conditions: (i) ∀FO ∈ π FJ (FC), , i.e., ; (ii) ρ FJ (FC FJ) ⊆ FT FJ, then FJ is considered as an interpretation of the FOOD model.
Construction of Fuzzy Ontologies from FOOD Models
In this section we propose a formal approach for constructing fuzzy ontologies from FOOD models, including some construction rules, a construction example, and the proof of correctness of the approach.
Construction approach
The following Definition 4 proposes a complete approach for constructing fuzzy ontologies from FOOD models. Giving a FOOD model FOOD = (FOODFS, FOODFO) = (FOFS, FDFS, FCFS, FAFS, FPFS, FPFO), starting with the constructions of identifiers of fuzzy classes, fuzzy properties and fuzzy individuals from the sets of symbols FOFS, FDFS, FCFS and FAFS, the Definition 4 further creates a set of axioms from the class and individual declarations FPFS and FPFO in the FOOD model.
The correctness of the construction approach
Based on the similar ideas in [10, 31], in this section we prove the correctness of the construction approach proposed in Section 3.2.1.
α
FS from a database state to a model of φ(FOOD) such that: For each database state F J for FOOD, there is α
FS (FJ) which is a model of φ(FOOD);
β
FS from a model of φ(FOOD) to a database state such that: For each model F I of φ(FOOD), there is β
FS (FI) which is a database state for FOOD.
The domain elements Δ
αFS(FJ) of a fuzzy interpretation α
FS (FJ) of φ(FOOD) are constituted by the values of the fuzzy database state FJ, i.e., FV
FJ in Definition 3. The fuzzy ontology identifier set FID
0 of φ(FOOD) in Definition 4 is defined as follows: (φ (X)) αFS(FJ) = X
FJ, where X ∈ FT (FT is a type expressive); For each fuzzy class declaration Class FC type-is Record FA1 : FD1, … , FA
k
: FD
k
End, we have , where i = 1, … , k; For each fuzzy class declaration Class FC1 type-is Record FA: Set-of FC2 End, we have .
Further, we prove α FS (FJ) is a model of φ(FOOD), i.e., prove α FS (FJ) satisfies each axiom of FAxiom0 of φ(FOOD) in Definition 4. Note that, the fuzzy axioms of FAxiom0 can be partitioned into several main cases:
Note that, the two parts are a mutually inverse process, and the proof of the second part, which can be treated analogously according to the first part, is omitted here. Moreover, the correctness of the transformation at instance level can be ensured by the correctness of the transformation at structure level.
A construction example
Prototype construction tool
Following the proposed approach in Section 3.2, we developed a prototype construction tool called FOOD2FOnto, which can automatically construct fuzzy ontologies from FOOD models. Note that, the tool FOOD2FOnto is based on the initial tool FOOD2FOWL in the previous work [33]. Comparing to FOOD2FOWL [33], the tool FOOD2FOnto in this paper can further transformed some new features of FOOD models (such as extensional classes, methods of objects, disjoint and complete constraints, and cardinality constraints) into fuzzy ontologies.
FOOD2FOnto includes input module, parse module, transformation module, and output module: The input module inputs a FOOD model file represented in the formal definition of Definition 2. The parse module uses the regular expression to parse the FOOD model file, and stores the parsed results as Java classes. The transformation module transforms the parsed results into a fuzzy ontology according to the proposed approach in Section 3.2.1. The output module produces the resulting fuzzy ontology.
We carried out construction experiments of some FOOD models using the implemented tool FOOD2FOnto, with a PC (CPU P4/3.0GHz, RAM 3.0GB and Windows XP system). The sizes of the FOOD models range from 0 to 1000. Case studies show that our approach is feasible and the tool is efficient. Figure 3 shows the execution time, where the preprocessing denotes the operations of parsing and extracting elements of FOOD models.
Here we provide an example of FOOD2FOnto. Figure 4 is the screen snapshot of FOOD2FOnto tool running one of case studies, which displays the construction procedure of a fuzzy ontology from the FOOD model in Fig. 1 (the details have also been shown in Section 3.2.3). In Fig. 4, the formalized FOOD model, the parsed results, and the constructed fuzzy ontology are displayed in the left, middle and right areas, respectively.
So far, on the basis of the proposed approach and the implemented tool, fuzzy ontologies can be constructed from FOOD models, which may facilitate the development of fuzzy ontologies. Moreover, constructions of fuzzy ontologies from FOOD models mean that the information in FOOD models can be represented using the knowledge representation technique. As a result, it is possible to take advantage of the associated reasoning techniques of fuzzy ontologies to reason on FOOD models. As we have known, using conventional techniques in reasoning on database models would mean to manually check reasoning tasks of database models (e.g., whether a fuzzy class is satisfiable or whether a fuzzy class is a subclass of another fuzzy class). Using knowledge representation techniques, reasoning on database models may be done more effectively or automatically (this has been pointed out in [10, 31], and they stated that it is useful to reason on database models such as fuzzy ER models and fuzzy UML models with knowledge representation techniques). On this basis, in the following section we focus on how to reason on FOOD models based on the constructed fuzzy ontologies.
Fuzzy ontologies for reasoning on FOOD models
Based on the similar ideas in [17, 31] (where the authors discussed how to apply fuzzy ontologies for reasoning on fuzzy ER/EER models, fuzzy relational database models, and fuzzy UML models), in this section, we focus on investigating how to reason on FOOD models: Firstly, we introduce some familiar reasoning tasks of FOOD models and give their formal definitions. Based on the classical/fuzzy object-oriented database models [10, 30], in this paper several reasoning problems (e.g., disjointness and instance retrieval) are added and some reasoning problems (e.g., consistency and sub/super) are redefined and studied in depth. Moreover, the fuzziness of different levels in FOOD models (e.g., the object/class level and the subclass/superclass level) are fully considered; Then, we propose approaches for reasoning on FOOD models with fuzzy ontologies.
Reasoning problems of FOOD models
Similarly to the classical/fuzzy database models (such as ER/EER models, UML models, object-oriented database models, and relational database models [10, 31]), the familiar reasoning problems considered in FOOD models include consistency, satisfiability, sub/super, equivalence, disjointness, redundancy, and instance retrieval.
Comments: (a) In object-oriented database models, two classes are equivalent if they denote the same set of object instances. (b) In FOOD models, however, an object may belong to a fuzzy class with membership degree of μ ∈ (0, 1], and thus two fuzzy classes may have same objects with same/different membership degrees. In this case, the notion of equivalent classes should be extended under fuzzy environment [30]. For the first case in Definition 8, when two fuzzy classes have same objects with same membership degrees, they are strictly equivalent. In this case, one of two fuzzy classes can be removed and replaced by another. For the second case, assuming that there is an object FO belonging to two fuzzy classes FC1 and FC2 with different membership degrees u FC1 (FO) ∈ (0, 1] and u FC2 (FO) ∈ (0, 1]. At this moment, which one in FC1 and FC2 is the class of object FO depends on the following cases: if u FC1 (FO) ≤ u FC2 (FO), then FC2 is considered as the class of object FO and we say FC2 fuzzily includes FC1, else FC1 is considered as the class of object FO. Correspondingly, the fuzzy class which is included by another fuzzy class is removed, and the fuzzy class which includes the removed fuzzy class is retained.
Applying the constructed fuzzy ontologies for reasoning on FOOD models
In this section we propose approaches for reasoning on FOOD models with the constructed fuzzy ontologies. The following theorems can reduce the reasoning of a FOOD model to the reasoning of the constructed fuzzy ontology, so that the reasoning tasks of the FOOD model mentioned in Section 4.1 may be checked by detecting the reasoning problems of the fuzzy ontology constructed from the FOOD model. As we have known, the reasoning problems of fuzzy ontologies can be automatically checked by the existing fuzzy ontology reasoner DeLorean [2].
From transformations of FOOD models to fuzzy ontologies in Section 3, it is shown that Theorems 2–8 are the straightforward consequences of Theorem 1 and Definitions 4–11, and thus the proofs of Theorems 2–8 are omitted here since the limit of space.
Related work
We mainly focus on introducing the approaches of constructing fuzzy ontologies from fuzzy database models, which are closely related to our work.
Firstly, constructing fuzzy ontologies from fuzzy database models has received much attention. The fuzzy ontology construction approaches from fuzzy ER/EER models were developed in [17, 29]. How to construct fuzzy ontologies from fuzzy UML models was studied in [28, 31]. The work in [7] transformed fuzzy relational models into fuzzy ontologies. Also, the work in [19] presented an ontology for representing the fuzzy information of a fuzzy relational database. All the works mentioned above did not discuss fuzzy object-oriented database models.
Secondly, there are several approaches for establishing correspondences between fuzzy description logics and fuzzy database models such as fuzzy object-oriented database models [30], and fuzzy UML models [18], where fuzzy description logics are used to reason on these models. In particular, there are several major differences between the current paper and [30]: first, in the formalization aspect of FOOD models, comparing to [30], in this paper we further consider the extensional class and the fuzziness at subclass/superclass level in FOOD models, include both the schema and the object instance information in the formal definition of FOOD models simultaneously, and modify and add some expressions to the formal definition of FOOD models for accurately representing the domain information in FOOD models; Second, the approach for constructing fuzzy ontologies from FOOD models proposed in this paper is really different from the approach for representing and reasoning on FOOD models with a fuzzy description logic mentioned in [30]; Third, comparing to [30], in this paper, several reasoning problems of FOOD models (e.g., disjointness and instance retrieval) are added and some reasoning problems (e.g., consistency and sub/super) are redefined and studied in depth, and also the fuzziness of different levels in FOOD models (e.g., object/class level and subclass/superclass level) are fully considered.
Thirdly, how to construct fuzzy ontologies from FOOD models was initially studied in [33]. The current paper differs from [33] in three major aspects: (i) Regarding the formalization problem of FOOD models, this paper proposes a more complete formal definition of FOOD models, where this paper further considers some features of FOOD models (e.g., the extensional classes, the fuzziness at sub/super level, the dynamic aspects of objects, the disjoint and complete constraints on class hierarchies, and the cardinality constraints on associations), includes the schema and the object instance information in the formal definition simultaneously, and modifies and adds some expressions for accurately representing the domain knowledge in FOOD models; this paper gives the semantic interpretation method of FOOD models; (ii) Regarding the construction of fuzzy ontologies from FOOD models, first, this paper proposes a complete fuzzy ontology construction approach, which considers most features of FOOD models as mentioned above, all of these were not discussed in [33]; Second, the complete proof of correctness of the construction approach is given in this paper but missed in [33]; Third, the prototype construction tool is developed in this paper, and the tool can further transformed some new features of FOOD models into fuzzy ontologies. (iii) Regarding the problem of reasoning on FOOD models with the constructed fuzzy ontologies, how to reason on FOOD models with the constructed fuzzy ontologies were not discussed in [33]. In this paper, we give the complete formal definitions of reasoning problems of FOOD models and propose the reasoning methods.
To our best knowledge, there is no complete report on formalizing and reasoning on fuzzy object-oriented database models using fuzzy ontologies.
Conclusions and future works
We proposed a complete approach and developed an automated tool for constructing fuzzy ontologies from fuzzy object-oriented database (FOOD) models, and further used the constructed fuzzy ontologies to reason on the FOOD models. Firstly, we proposed a complete formal definition of FOOD models and gave the semantic interpretation method of FOOD models. On this basis, we proposed an approach for constructing fuzzy ontologies from FOOD models, which can transform FOOD models (including the schema and object instance information) into fuzzy ontologies at both schema and instance levels. Also, we proved the correctness of the construction approach, and provided a full construction example. Furthermore, we implemented a tool FOOD2FOnto. Finally, we investigated how to reason on the FOOD models with the constructed fuzzy ontologies.
In the future work, we realize that the fuzzy object-oriented databases discussed in this paper do not cover all kinds of fuzzy extensions of object-oriented databases. Some fuzzy object-oriented databases (e.g., fuzzy deductive object-oriented databases and fuzzy object-relational database models) may be also important for applications, and we will consider them in the near future work. Moreover, many databases have not been designed following the disciplined methodologies, thus we will evaluate the construction approach and tool with more and complex examples.
Footnotes
Acknowledgements
The authors wish to thank the anonymous referees for their valuable comments and suggestions. The work is supported by National Natural Science Foundation of China (61202260, 61370075).
