Formalizing fuzzy object-oriented database models using fuzzy ontologies

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.

Keywords

Fuzzy object-oriented database (FOOD) model fuzzy ontology formalization construction reasoning

1 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:

We propose a formal approach and develop an automated tool for constructing fuzzy ontologies from FOOD models in Section 3, including: (i) We propose a formalization method of FOOD models (see Section 3.1), where schema features and object instances of FOOD models are contained in the formal definition; (ii) We propose an approach for constructing fuzzy ontologies from FOOD models; Further, we prove the approach is correct and semantics-preserving, and provide a construction example (see Section 3.2); (iii) We implement a prototype construction tool called FOOD2FOnto (see Section 3.3).

We propose an approach for reasoning on the FOOD models with the constructed fuzzy ontologies in Section 4, including: (i) We give formal definitions of reasoning problems of FOOD models; (ii) We propose an approach for reasoning on FOOD models with constructed fuzzy ontologies.

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.

2 Preliminaries

In this section, we briefly report some preliminaries on fuzzy ontologies and FOOD models.

2.1 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].

Definition 1. (fuzzy OWL ontology): A fuzzy OWL ontology FO is a tuple FO = (FO_S, FO_I) = (FID ₀, FAxiom ₀), where:

FID ₀ = FCID ₀ ∪ FIID ₀ ∪ FDRID ₀ ∪ FDPID ₀ ∪ FOPID ₀ is a set of identifiers partitioned into: a subset FCID ₀ of fuzzy class identifiers; a subset FIID ₀ of individual identifiers; a subset FDRID ₀ of fuzzy data range identifiers; a subset FDPID ₀ of fuzzy datatype property identifiers; and a subset FOPID ₀ of fuzzy object property identifiers;

FAxiom ₀ is a set of fuzzy OWL axioms defined over FID ₀ partitioned into: a subset of fuzzy class/property axioms, used to represent fuzzy ontology structure information FO_S; and a subset of fuzzy individual axioms, used to represent fuzzy ontology instance information FO_I.

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.

2.2 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).

3 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.

3.1 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).

Definition 2. (formal definition of FOOD models): A FOOD model, which includes the schema information FOOD_FS and the object information FOOD_FO, can be defined as a tuple FOOD = (FOOD_FS, FOOD_FO):

FOOD_FS = (FO_FS, FD_FS, FC_FS, FA_FS, FP_FS) consists of a set of object identities, attribute domains, classes, attributes, and class declarations, where:

FO_FS is a set of objects FO; each object is characterized by a unique object identity (OID);

FD_FS 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}.

FC_FS is a set of classes FC;

FA_FS 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;

FP_FS is a set of class declarations. For each class FC ∈ FC_FS, FP_FS 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 → {FO₁/μ ₁, FO₂/μ ₂, … , FO_n/μ _n} End |

Union FC₁ … FC_q (disjoint, complete) End |

Record FA₁: FT₁, … , FA_k: FT_k, μ: Real, f (P₁, … , P_m): R End

where FT _i is one of the following cases (where i ∈ {1 … k}):

FT_i → FD_i|

Set-of FC_i/η _i [(m₁, n₁), (m₂, n₂)].

FOOD_FO is a set of object declarations FP_FO representing values of attributes of objects. For each object FO ∈ FO_FS, FP_FO contains a declaration:

Object FO belong-to FC/μ

has-value [FA₁ : FD₁, FA₂ : FD₂…] 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 FC_sup with a membership degree β ∈ [0, 1];

The type-is part specifies the structure of a class FC through a type expression FT;

The expression {FO₁/μ ₁, FO₂/μ ₂, … , FO_n/μ _n} denotes that FC is an extensional class defined by a list of its object instances {FO₁/μ ₁, FO₂/μ ₂, … , FO_n/μ _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 ₁, … , P _m): R represents a method, where f is the name of the method, P ₁, … , 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 FA_i: Set-of FC_i/η _i [(m ₁, n ₁) , (m ₂, n ₂)] End) denotes an association relationship between classes FC and FC_i by an attribute FA_i; η _i ∈ [0, 1] denotes the association occurs in classes FC and FC_i with a membership degree of η _i; [(m ₁, n ₁) , (m ₂, n ₂)] 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 FOOD₁.

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).

Definition 3. (semantics of FOOD models): The semantics of a FOOD model can be given by a fuzzy database state FJ, which is defined by a fuzzy interpretation FI_FD = (FV _FJ, π ^FJ, ρ ^FJ, • ^FJ):

A set FV _FJ = FD ^FJ ∪ FO ^FJ ∪ FR ^FJ ∪ FS ^FJ of fuzzy values is inductively defined as follows:

${FD}^{FJ} = \cup_{i = 1}^{n} {FD}_{i}^{FJ}$ , where FD_i is a crisp or fuzzy domain as mentioned in the previous sections;

FO ^FJ = {FO₁/μ ₁, … , FO_n/μ _n}, where FO_i is an object associated with a membership degree μ _i;

FR ^FJ is a set of record values. A record value is denoted by [FA₁ : FV ₁, … , FA_k : FV _k], where FA_i 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 ₁, … , 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 FC₁, …, FC_q (disjoint, complete) End, then it follows ${FT}^{FJ} = {FC}_{1}^{FJ} \cup \dots \cup {FC}_{q}^{FJ}$ and ${FC}_{i}^{FJ} \cap {FC}_{j}^{FJ} = \emptyset$ , where i, j ∈ {1, …, q}, and i ≠ j.

Furthermore, if for each class declaration Class FC is-a FC_sup/β type-is FT in a FOOD model, the fuzzy database state FJ defined above satisfies conditions: (i) ∀FO ∈ π ^FJ (FC), $β \leq {FC}^{FJ} (FO) \leq {FC}_{sup}^{FJ} (FO)$ , i.e., ${FC}^{FJ} \subseteq {FC}_{sup}^{FJ}$ ; (ii) ρ ^FJ (FC ^FJ) ⊆ FT ^FJ, then FJ is considered as an interpretation of the FOOD model.

3.2 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.

3.2.1 Construction approach

The following Definition 4 proposes a complete approach for constructing fuzzy ontologies from FOOD models. Giving a FOOD model FOOD = (FOOD_FS, FOOD_FO) = (FO_FS, FD_FS, FC_FS, FA_FS, FP_FS, FP_FO), starting with the constructions of identifiers of fuzzy classes, fuzzy properties and fuzzy individuals from the sets of symbols FO_FS, FD_FS, FC_FS and FA_FS, the Definition 4 further creates a set of axioms from the class and individual declarations FP_FS and FP_FO in the FOOD model.

Definition 4. (construction approach): Given a FOOD model FOOD = (FOOD _FS, FOOD _FO) = (FO_FS, FD_FS, FC_FS, FA_FS, FP_FS, FP_FO) in Definition 2, a fuzzy ontology FO = (FO_S, FO_I) = (FID ₀, FAxiom ₀) can be constructed by a function φ shown in Table 1.

3.2.2 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.

Theorem 1. Given a FOOD model FOOD, φ(FOOD) is a constructed fuzzy ontology from FOOD. There are mappings:

α _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.

Proof. Firstly, given a fuzzy database state F J for FOOD, a fuzzy interpretation α _FS (FJ) of φ(FOOD) can be defined as follows:

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 ₀ 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 FA₁ : FD₁, … , FA_k : FD_k End, we have $(φ ({FA}_{i}))^{α_{FS} (FJ)} = {< FO, d_{i} > \in Δ^{α_{FS} (FJ)} \times Δ^{α_{FS} (FJ)}} | FO \in {FC}^{FJ} d_{i} \in {FD}_{i}^{FJ}}$ , where i = 1, … , k;

For each fuzzy class declaration Class FC₁ type-is Record FA: Set-of FC₂ End, we have $(φ ({FU}_{j}))^{α_{FS} (FJ)} = {< r, {FO}_{j} > \in Δ^{α_{FS} (FJ)} \times Δ^{α_{FS} (FJ)} | r \in {FA}^{FJ} \land {FO}_{j} \in {FC}_{j}^{FJ}}, j = 1, 2$ .

Further, we prove α _FS (FJ) is a model of φ(FOOD), i.e., prove α _FS (FJ) satisfies each axiom of FAxiom₀ of φ(FOOD) in Definition 4. Note that, the fuzzy axioms of FAxiom₀ can be partitioned into several main cases:

Case 1. for a fuzzy class FC such that Class FC is-a FC_sup/β. Firstly, according to Definition 3, if FJ is a fuzzy database state, then ∀FO ∈ π ^FJ (FC), ${FC}^{FJ} (FO) \leq {FC}_{sup}^{FJ} (FO)$ , i.e., ${FC}^{FJ} \subseteq {FC}_{sup}^{FJ}$ (the semantics of β is straightforward and is omitted here for simplicity). Then, by definition of α _FS (FJ) above, we have (φ (FC)) ^α_FS(FJ) ⊆ (φ (FC_sup)) ^α_FS(FJ). That is, α _FS (FJ) satisfies the corresponding fuzzy axiom of this case in Definition 4.

Case 2. for a fuzzy class FC such that Class F C type-is Union FC₁, … FC_q (disjoint, complete) End. Firstly, according to Definition 3, if FJ is a fuzzy database state, we have ${FC}^{FJ} = {FC}_{1}^{FJ} \cup \dots \cup {FC}_{q}^{FJ}$ and ${FC}_{i}^{FJ} \cap {FC}_{j}^{FJ} = \emptyset$ , where i, j ∈ {1, … , q} and i ≠ j. By definition of α _FS (FJ) above, it follows (φ (FC)) ^α_FS(FJ) = (φ (FC₁)) ^α_FS(FJ) ∪ … ∪ (φ (FC_q)) ^α_FS(FJ)) and (φ (FC_i)) ^α_FS(FJ)∩ (φ (FC_j)) ^α_FS(FJ) = ∅. That is, α _FS (FJ) satisfies the corresponding fuzzy axioms of this case in Definition 4.

Case 3. for a fuzzy class FC such that Class F C type-is Record FA₁ : FD₁, …, FA_k : FD_k End (note that the methods are included in this case). Firstly, for an instance FO ∈ (φ (FC)) ^α_FS(FJ), according to Definition 3, if FJ is a fuzzy database state, then ρ ^FJ (FC ^FJ) ⊆ FT ^FJ, where FT is the record type above. Then, by Definition 3 once again, we have FO = [FA₁ : FV ₁, … FA_k : FV _k], where ${FV}_{i} \in {FD}_{i}^{FJ} \subseteq {FV}_{FJ}$ , i ∈ {1, … , k}.Furthermore, by definition of α _FS (FJ) above, there is exactly one element $d_{i} \in {FD}_{i}^{FJ} = (φ ({FD}_{i}))^{α_{FS} (FJ)}$ such that (FO, d _i) ∈ (φ (FA_i)) ^α_FS(FJ),i.e., $(φ (FC))^{α_{FS} (FJ)} \subseteq ⋂_{i = 1}^{k} {FO | \forall d_{i .} < FO, d_{i} > \in (φ ({FA}_{i}))^{α_{FS} (FJ)} \to d_{i} \in (φ ({FD}_{i}))^{α_{FS} (FJ)} \land # {d_{i} | < FO, d_{i} > \in} (φ ({FA}_{i}))^{α_{FS} (FJ)} = 1}$ , where # {} denotes the base of a set {}. That is, α _FS (FJ) satisfies the corresponding fuzzy axioms of this case in Definition 4.

Case 4. for a fuzzy class FC₁ such that Class FC₁ type-is Record F A: Set-of FC₂/η [(m ₁, n ₁) , (m ₂, n ₂)]. Firstly, for an instance r ∈ (φ (FA)) ^α_FS(FJ), by Definition 2 it follows r = {FV ₁, …, FV _k}, where ${FV}_{i} \in {FC}_{j}^{FJ} \in {FV}_{FJ}$ , i ∈ {1, … , k}, j ∈ {1, 2}. Then, by definition of α _FS (FJ) above, there is exactly one element ${FO}_{j} \in {FC}_{j}^{FJ} = (φ ({FC}_{j}))^{α_{FS} (FJ)}$ such that (r, FO_j) ∈ (φ (FU _j)) ^α_FS(FJ), i.e., $(φ (FA))^{α_{FS} (FJ)} \subseteq \cap_{j = 1}^{2} {r | \forall {FO}_{j .} < r, {FO}_{j} > \in (φ ({FU}_{j}))^{α_{FS} (FJ)} \to {FO}_{j} \in (φ ({FC}_{j}))^{α_{FS} (FJ)} # {{FO}_{j} | < r, {FO}_{j} > \in (φ ({FU}_{j}))^{α_{FS} (FJ)}} = 1}$ , where #{} denotes the base of a set {}. Moreover, according to the semantics of cardinality constraints on associations mentioned in Definition 2, we have card _min (FC_j, FA, FU _j) ≤ # {r ∈ FA ^FJ|FA [FU _j] = FO_j} ≤ card _max (FC_j, FA, FU _j), which denotes the minimum and maximum times of an object instance of a fuzzy class participating in an association. Further, by definition of α _FS (FJ) above, it follows (φ (FC_j)) ^α_FS(FJ) ⊆ {FO_j|card _min (FC_j, FA, FU _j) ≤ # {r ∈ (φ (FA)) ^α_FS(FJ)| < r, FO_j > ∈ (φ (FU _j)) ^α_FS(FJ) ≤ card _max (FC_j, FA, FU _j)}. In addition, we know that FV ₁ = invof_φ (FU ₁) and FV ₂ = invof_φ (FU ₂) are the inverse object property identifiers of FU ₁ and FU ₂, respectively, and thus we have $(φ ({FV}_{j}))^{α_{FS} (FJ)} = {< {FO}_{j}, r > \in Δ^{α_{FS} (FJ)} \times Δ^{α_{FS} (FJ)} | {FO}_{j} \in {FC}_{j}^{FJ} \land r \in {FA}^{FJ}}$ , j = 1, 2, i.e., (φ (FV _j)) ^α_FS(FJ) = ((φ (FU _j)) ^α_FS(FJ)) ^- ⊆ (φ (FC_j)) ^α_FS(FJ) × (φ (FA)) ^α_FS(FJ). That is, α _FS (FJ) satisfies the corresponding fuzzy axioms of this case in Definition 4.

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.

3.2.3 A construction example

Example 1. Given the FOOD model FOOD₁ in Fig. 1, according to the approach in Definition 4, we obtain a fuzzy ontology FO = φ (FOOD ₁) in Fig. 2.

3.3 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.

4 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.

4.1 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.

Definition 5. (consistency of FOOD models): A FOOD model is consistent, if the elements altogether in the FOOD model are not contradictory.

Definition 6. (satisfiability of fuzzy classes): A fuzzy class FC in a FOOD model FOOD is satisfiable, if there is at least one fuzzy database state FJ of FOOD mentioned in Definition 3 such that FC ^FJ≠ ∅, i.e., there is at least one object FO in FJ, it holds that FC ^FJ (FO) >0.

Definition 7. (sub/super of fuzzy classes): For two fuzzy classes FC₁ and FC₂ in a FOOD model FOOD, FC₁ is a subclass of FC₂ with a membership degree β ∈ [0, 1], if for each fuzzy database state FJ of FOOD such that (i) ${FC}_{1}^{FJ}$ is a subset of ${FC}_{2}^{FJ}$ , and (ii) ∀FO ∈ FJ, ${FC}_{1}^{FJ} (FO) \geq β$ (where FO stands for an object).

Definition 8. (equivalence of fuzzy classes): A fuzzy class FC₁ is equivalent to another fuzzy class FC₂, if at least one of the following conditions is satisfied: (i) two fuzzy classes FC₁ and FC₂ have same objects with same membership degrees; (ii) two fuzzy classes FC₁ and FC₂ do not have subclass/superclass relationship but they have same objects with different membership degrees.

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 FC₁ and FC₂ with different membership degrees u _FC1 (FO) ∈ (0, 1] and u _FC2 (FO) ∈ (0, 1]. At this moment, which one in FC₁ and FC₂ is the class of object FO depends on the following cases: if u _FC1 (FO) ≤ u _FC2 (FO), then FC₂ is considered as the class of object FO and we say FC₂ fuzzily includes FC₁, else FC₁ 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.

Definition 9. (disjointness of fuzzy classes): In a FOOD model FOOD, two fuzzy class FC₁ and FC₂ are disjoint, if for each fuzzy database state FJ of FOOD such that ${FC}_{1}^{FJ} \cap {FC}_{2}^{FJ} = \emptyset$ .

Definition 10. (redundancy of FOOD models): A FOOD model is redundant, if there is some class standing for an empty class; or there are two equivalent fuzzy classes.

Definition 11. (instance retrieval of fuzzy classes): Given a fuzzy class FC of a FOOD model and n ∈ (0, 1], retrieving all the object instances FO that satisfy the condition FC ^FJ (FO) ≥ n.

4.2 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].

Theorem 2. (consistency of FOOD models): Given a FOOD model FOOD , and φ( FOOD) is the constructed fuzzy ontology based on the proposed approach in Section 3 . The FOOD model FOOD is consistent iff φ( FOOD) is consistent.

Theorem 3. (satisfiability of fuzzy classes): Given a FOOD model FOOD, φ (FOOD) is the constructed fuzzy ontology, F C is a fuzzy class in FOOD, and φ (FC) is the fuzzy concept in φ (FOOD) corresponding to F C. Then: F C is satisfiable in FOOD iff φ (FOOD) |≠ φ (FC) ⊑ ⊥.

Theorem 4. (sub /super): Given a FOOD model FOOD, φ (FOOD) is the constructed fuzzy ontology, FC₁ and FC₂ are two fuzzy classes in FOOD, and φ (FC₁), φ (FC₂) are two fuzzy concepts in φ (FOOD) corresponding to FC₁ and FC₂ respectively. Then: FC₁ is a subclass of FC₂ with membership degree β ∈ [0, 1] iff φ (FOOD) | =< φ (FC₁) ⊑ φ (FC₂) , β >.

Theorem 5. (equivalence): Given a FOOD model FOOD, φ (FOOD) is the constructed fuzzy ontology, FC₁ and FC₂ are two fuzzy classes in FOOD, and φ (FC₁), φ (FC₁) are two fuzzy concepts in φ (FOOD) corresponding to FC₁ and FC₁ respectively. Then: FC₂ is equivalent to FC₂ (FC₁ ≈ FC₂) iff φ (FC₁) is equivalent to φ (FC₂) (φ (FC₁ ≈ φ (FC₂)), i.e., at least one of conditions is satisfied: (i) φ (FOOD) | = φ (FC₁) ≡ φ (FC₂); (ii) φ (FOOD) | ≠ φ (FC₁) ⊑ φ (FC₂) and Set _φ(FC₁) {FO|φ (FC₁) ^FI (FO) >0} = Set _φ(FC₂) {FO|φ (FC₂) ^FI (FO) >0}, where FI is a fuzzy interpretation of φ (FOOD).

Theorem 6. (disjointness): Given a FOOD model FOOD, φ (FOOD) is the constructed fuzzy ontology, FC₁ and FC₂ are two fuzzy classes in FOOD, and φ (FC₁), φ (FC₂) are two fuzzy concepts in φ (FOOD) corresponding to FC₁ and FC₂ respectively. Then: FC₁ is disjoint to FC₂ iff φ (FOOD) | = φ (FC₁)⊓ φ (FC₂) ⊑ ⊥.

Theorem 7. (redundancy): Given a FOOD model FOOD, φ (FOOD) is the constructed fuzzy ontology, FC, FC₁ and FC₂ are fuzzy classes in FOOD, and φ (FC), φ (FC₁) and φ (FC₂) are fuzzy concepts in φ (FOOD) corresponding to FC, FC₁ and FC₂ respectively. Then: FOOD is redundant iff at least one of t he following conditions is satisf ied: (i) φ (FOOD) | = φ (FC)⊑ ⊥; (ii) φ (FC₁) ≈ φ (FC₂) as mentioned in Theorem 5.

Theorem 8. (instance retrieval of fuzzy classes): Given a FOOD model FOOD, φ (FOOD) is the constructed fuzzy ontology, FC is a fuzzy class in FOOD, φ (FC) is the fuzzy concept in φ (FOOD) corresponding to FC, F J is a fuzzy database state for FOOD, α _FS (FJ) is the corresponding fuzzy interpretation of φ (FOOD) as mentioned in Theorem 1, and n ∈ (0, 1]. Then: retrieving all the object instances FO that satisfy the condition FC ^FJ (FO) ≥ n in FOOD can be reduced to retrieving all the individuals FO that satisfy the condition (φ (FC)) ^α_FS(FJ) (FO) ≥ n in φ (FOOD).

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.

5 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.

6 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).

References

10.

11.

12.

13.

14.

15.

16.

17.

18.

19.

20.

21.

22.

23.

24.

25.

26.

27.

28.

29.

30.

31.

32.

33.

34.

35.