Existing approaches for querying OWL DL do either only operate on syntactic constructs without taking into account the semantics of OWL or do only have a restricted access to the T-Box. We present SAIQL, the novel Schema And Instance Query Language for OWL DL, that is well suited for ontology extraction. We describe its syntax and explain a basic evaluation strategy. We illustrate the use of SAIQL with an example for ontology extraction and re-use.
With the standardization of the Web Ontology Language OWL [1], the use and re-use of ontological knowledge has gained significant momentum. For using web ontologies it is crucial to be able to access web ontologies in an intuitive and versatile manner. In contrast to RDF, where SPARQL [2] is providing access to RDF data and RDF schema information, a corresponding query language is missing for OWL. Existing OWL querying approaches, e.g. OWL-QL [3], have only a restricted access to the T-Box so that only named classes and individuals can be retrieved. Using SPARQL [2] for querying OWL allows the user to query OWL A-Box and T-Box, but it is not aware of OWL semantics and it is very cumbersome, because of its triple semantics. In fact, we will give some examples of querying desiderata that cannot easily be fulfilled by SPARQL or OWL-QL.
The requirements for querying OWL naturally include conjunctive queries of the OWL A-Box [4], but as has also been recently argued for other ontology languages with explicitly queryable schema representations (cf. [5]), the querying of schema as well as instance information constitutes an important feature of the querying language.
We illustrate our requirements for querying OWL with an application from ontology extraction (cf., [6]) for re-using parts of an ontology. While implementations of ontology extraction algorithms are currently dominated by imperative style programming, re-using parts of an ontology would be greatly facilitated by a query language that would allow querying for schema and instance information. For instance, it is useful to ask for all individuals of classes, which are defined using a restriction with a certain property or having a specific subclass.
As one main contribution, our query language can handle class descriptions in addition to class names and individuals. The extraction of these class descriptions is of major importance as they provide the definition for a certain class name. Instead of extracting isolated class names and individuals like in OWL-QL, the class names, class descriptions and individuals are returned as OWL DL axioms. Thus, the result is a fully working OWL DL ontology.
In the following, we present our small example use case in ontology extraction and derive some requirements from it (section 2). We then discuss some of the foundations on which we build our approach in section 4. In section 5, we present the original querying language SAIQL (Schema And Instance Query Language) that is able to combine T-Box and A-Box querying in an integrated manner. Finally, we discuss some related work, before we conclude.
In our running example, we assume a large ontology, MotorOntology, parts of which we want to extract and re-use for a new information system about cars in order to save costs and ensure high quality (cf., [7] on the benefits of ontology re-use). Naturally, we do not want to adopt the given ontology one by one, as we are only interested in schema and instance information related to cars.
For extracting our target ontology from MotorOntology (see an excerpt in Figure 1), we are interested in all axioms that contain class names, which are subclasses of the cardinality restriction with the value 4 for the property hasWheel, and their descriptions. Additionally, we are interested in all axioms about individuals of these classes. Given the running example in Figure 1, the class names Car, Convertible and Van and their descriptions should be delivered as class axioms. Furthermore, the individual axioms about c and v need to be extracted. From the presented use case we derive the following requirements: First, the query language should regard and use the semantics of OWL DL ontologies. By exploiting their semantics, additional knowledge can be inferred that is not explicitly stated in the ontology. Thus, in our running example the class Van could be returned as a subclass of Car without being explicitly mentioned as its subclass.
As a further requirement, the query language should not only retrieve class names and individuals, but also class descriptions. As shown in our use case, it is not sufficient to return the class Convertible without knowing its definition. We also want to retrieve the class description of the class Convertible, namely that it is a subclass of the class Car and that it has an existential restriction for the property hasConvertibleTop.
Instead of extracting isolated class names and individuals, we want to return the class names, class descriptions and individuals as OWL DL axioms so that the result is a fully working OWL DL ontology. Thus, it should be possible to use the result of a SAIQL query as an input for another SAIQL query.
As models of OWL ontologies are infinite in general, query answering might cause infinite results. In order to ensure finite answers to queries, we need to define privileged sets of class names, class descriptions and individuals that are used in query results. These sets should be determined by the concrete syntactic notation of the queried ontology, which is always finite.
Finally, we want to state join-like conditions on selected classes and individuals by using identical names for variables. Thus, it should be possible to select all classes ?X so that an individual ?i belongs to this class ?X and so that the same class ?X must be a subclass of another class ?Y .
In our running example, we want to extract the axioms for our target ontology from MotorOntology. As we are interested in all axioms about class names, which are subclasses of the cardinality restriction with value 4 for the property hasWheel, their descriptions and their individuals, the SAIQL query in figure 2 is formulated. Within this query, three variables ?i, ?X and ?Z are used. The variable ?i is treated as a placeholder for an individual, whereas the variable ?X is a placeholder for a class name and ?Z for a class description. Furthermore, the SAIQL query consists of four clauses: The CONSTRUCT clause determines the format of the extracted axioms, the FROM clause determines from which ontology axioms are extracted, the LET clause associates variables with value ranges and the WHERE clause constitutes the conditions under which axioms are extracted.
CONSTRUCT Class(?X partial ?Z); Individual(?i type(?X)) FROM MotorOntology LET IndividualName ?i; ClassName ?X; ClassDescription ?Z WHERE Class(?X partial restriction(hasWheel cardinality(4)))
AND Individual(?i type(?X)) AND Class(?X partial ?Z) Fig. 2. SAIQL query for our example 4 Abstract Syntax and Semantics for OWL DL SAIQL is a query language for OWL DL. In this section, we repeat some of the foundations of OWL DL that we need for defining SAIQL.
In the following, we present the abstract syntax for OWL DL by means of an extended BNF. The syntax is adopted from [8]. For the sake of simplicity and consistency, the syntax is slightly simplified leaving out annotation properties and import commands. Additionally, some terms are renamed. For example, the term fact is called individualAxiom in order to be consistent with the rest of the paper. Furthermore, we omit datatypes and datatype properties. Based on this syntax, we will define the syntax of SAIQL. Below you find an excerpt of the OWL abstract syntax in EBNF:
In the following, we describe parts of the model-theoretic semantics for OWL DL. The presented semantics is taken from [9]. We have slightly modified its presentation given here in order to use it more easily for the definition of SAIQL in the remainder of the paper. OWL class constructors are e.g. union, intersection or complement of classes, restrictions or enumerations. As mentioned in section 4.1, datatypes and datatype properties are not considered in detail in this paper. More details of the semantics of OWL DL can be found in [8].
As models of OWL ontologies are infinite in general, query answering could cause infinite answers. In oder to ensure finite answers to queries, we have defined the four finite sets N C , N IP , N DP and N I . Additionally, we must define the finite set of class descriptions used in the OWL DL ontology O. As proposed in [9], we distinguish class axioms, individual axioms and property axioms.
In this section the syntax of SAIQL is described. Additionally, a basic evaluation strategy for SAIQL queries is proposed.
As mentioned before, axioms are the central elements of OWL DL ontologies and they are also important for SAIQL queries. Their definition is extended by allowing variables in them. Definition 6. An axiom pattern p is defined analogously to an axiom, but allows variables at positions of class descriptions and individual names. The range of these variables can be either N C , N I or N CD . The name of a variable must start with a "?".
In contrast to [3], we do not support non-distinguished variables. As proposed for axioms without any variables, axiom patterns can be either class axiom patterns, individual axiom patterns or property axiom patterns.
Example. The SAIQL query in Figure 2 contains two individual axiom patterns and three class axiom patterns in the CONSTRUCT clause and in the WHERE clause. For instance, Class(?X partial ?Z) is a class axiom pattern and Individual(?i type(?X)) is an individual axiom pattern.
The range of a variable is specified in the LET clause. In our running example in Figure 2, the variable ?X is specified as a class name, the variable ?Z is specified as a class description and the variable ?i is specified as an individual name. where constructClause contains a sequence of axiom patterns, fromClause contains an URI reference of an ontology, letClause specifies the range of the variables and whereClause is a sequence of axiom patterns.
In this paper, we restrict ourselves to a single ontology, from which axioms can be extracted. The complete syntax for SAIQL is as follows:
The query evaluation consists of three steps. In the first step the LET clause is evaluated: From the ontology O declared in the FROM clause we retrieve three sets of ontology elements, namely the finite set of class names N C , the finite set of class descriptions N CD and the finite set of individual names N I . The finite set of class names N C contains the names of all atomic classes and the names of all named complex classes. Additionally, the finite set of class descriptions N CD contains all class descriptions that appear in the concrete syntactic notation of O (note that this includes all class names). Thus, In the third and last step, the CONSTRUCT clause is evaluated and the result of the query is generated.
Definition 12. The set of resulting axioms of a SAIQL query is the set of axiom patterns in the CONSTRUCT clause instantiated with every s ∈ S v .
The result of the query evaluation is a new set of axioms, i.e. a new ontology.
In the third and last step, the CONSTRUCT clause is evaluated. Each single axiom pattern of the CONSTRUCT clause is instantiated with each valid solution s ∈ S v . Thus, the classes Car, Van and Convertible, their descriptions and the individuals c and v are inserted as axioms into a new OWL ontology that is shown in Figure 3.
The most common way for querying OWL DL for schema and instance information is by using languages like SPARQL [2] or RQL [10]. They can retrieve RDF triples that match a given pattern. Compared to SAIQL, the RDF query languages are not able to retrieve schema information from the T-Box, which is not explicitly stated. They can only query the T-Box by inspecting the underlying RDF triples on a syntactic level. By using SAIQL, explicit and inferred knowledge can be found.
For instance, in our running example in section 2 it would not be possible to achieve the same answer that was retrieved by the SAIQL query by performing OWL-QL or SPARQL queries. OWL-QL has only a restricted access to the T-Box so that only named classes and individuals can be retrieved. Thus, it is not possible to retrieve the class descriptions that define the named classes. SPARQL is not aware of OWL semantics. Thus, the class name Convertible could not be retrieved because it is not explicitly stated as a subclass of the cardinality restriction for the property hasWheel. Even if we use an OWL reasoner such as Pellet [11] to infer such a relation, there is no standard way to explicitly store the results of the inferencing in RDF. Additionally, there are ambiguous serializations e.g. for qualified number restrictions. In our use case restriction(has-Wheel cardinality(4)) could also be expressed as intersectionOf(restriction(hasWheel minCardinality(4)) restriction(hasWheel maxCardinality(4))).
Although it is possible to extract the desired part of an ontology manually, this is naturally a harder task than specifying a SAIQL query and, of course, it is error-prone. Thus, it is certainly easier and more reasonable to use a SAIQL query instead. The need for such an automatic extraction is even increased if the former large ontology is changed and, thus, an update of the extracted ontology is required. Because changes of company-wide ontologies can happen very often, manual approaches for ontology extraction are almost infeasible. Further information about ontology extraction or ontology segmentation can be found in [12].
In this paper we have presented a novel query language for OWL DL, called SAIQL (Schema And Instance Query Language), that is suited for querying the T-Box and the A-Box in a uniform way.
As one main contribution, our query language cannot only handle class names and individuals, but also class descriptions. The extraction of these class descriptions is of major importance as they provide the definition for a certain class name. By constructing OWL DL axioms that contain the extracted class names, individuals and class descriptions, the query answer will be a fully working OWL DL ontology that can be directly re-used.
We have described the syntax of our query language and we have provided a basic evaluation strategy for it. As we demonstrated in our running example, SAIQL is appropriate for extracting parts of an ontology (schema and instances) that shall be re-used in other applications.
In our future work, we will implement the evaluation of SAIQL queries. We will also extend the expressivity of SAIQL, e.g. by allowing more than one ontology, from which axioms can be retrieved, or by introducing variable bindings for properties. As another important extension, the retrieval of anonymous individuals and classes will be handled.
This work has been partially supported by the EU in the projects NeOn (IST-2006-027595) and K-Space (FP6-027026).