Extensive research activities are recently directed towards the Semantic Web as a future form of the Web. Consequently, Web search as the key technology of the Web is evolving towards some novel form of Semantic Web search. A very promising recent approach to such Semantic Web search is based on combining standard Web search with ontological background knowledge and using standard Web search engines as the main inference motor of Semantic Web search. In this paper, we propose to further enhance this approach to Semantic Web search by the use of inductive reasoning techniques. This adds especially the important ability to handle inconsistencies, noise, and incompleteness, which are very likely to occur in distributed and heterogeneous environments, such as the Web. We report on a prototype implementation of the new approach and experimental results.
Web search [
A very promising recent representative of the second direction to Semantic Web search
has been presented in [
The overall architecture of our Semantic Web search system is shown in Fig. 1. It consists of the Interface, the Query Evaluator, and the Inference Engine (Fig. 1, dark parts), where the Query Evaluator is implemented on top of standard Web Search Engines. Standard Web pages and their objects are enriched by Annotation pages, based on an Ontology.
We thus assume that there are semantic annotations to standard Web pages and to
objects on standard Web pages. Note that such annotations are starting to be widely available
for a large class of Web resources, especially with the Web 2.0. Semantic annotations
about Web pages and objects may also be automatically learned from the Web pages and
the objects to be annotated (see, e.g., [
For example, in a very simple scenario, a Web page i1 may contain information about a Ph.D. student i2, called Mary, and two of her papers, namely, a conference paper i3 entitled “Semantic Web search” and a journal paper i4 entitled “Semantic Web search engines” and published in 2008. A simple HTML page representing this scenario is shown in Fig. 2, left side. There may now exist one semantic annotation each for the Web page, the Ph.D. student Mary, the journal paper, and the conference paper. The annotation for the Web page may simply encode that it mentions Mary and the two papers, while the one for Mary may encode that she is a Ph.D. student with the name Mary and the author of the papers i3 and i4. The annotation for the paper i3 may encode that i3 is a conference paper and has the title “Semantic Web search”, while the one for the paper i4 may encode that i4 is a journal paper, authored by Mary, has the title “Semantic Web search engines”, was published in 2008, and has the keyword “RDF”. The semantic annotations of i1, i2, i3, and i4 are formally expressed as the sets of axioms Ai1 , Ai2 , Ai3 , and Ai4 , respectively: Ai1 = fcontains(i1; i2); contains(i1; i3); contains(i1; i4)g; Ai2 = fPhDStudent(i2); name(i2; \mary"); isAuthorOf(i2; i3); isAuthorOf(i2; i4)g; Ai3 = fConferencePaper(i3); title(i3; \Semantic Web search")g; Ai4 = fJournalPaper(i4); hasAuthor(i4; i2); title(i4; \Semantic Web search engines"); yearOfPublication(i4; 2008); keyword(i4; “RDF”)g: (1) Inference Engine. Using an ontology containing some background knowledge, these semantic annotations are then further enhanced in an offline ontology compilation step, where the Inference Engine adds all properties that can be deduced from the semantic Interface
Query Evaluator Search Engine Inference Engine
Web Annotations
Ontology
annotations and the ontology. In [
ConferencePaper v Article; JournalPaper v Article; ConferencePaper v :JournalPaper; 9isAuthorOf v Scientist; 9isAuthorOf v Article; isAuthorOf v hasAuthor; hasAuthor v isAuthorOf; (funct hasFirstAuthor): (2) Using this ontological knowledge, we can derive from the above annotations that the two papers i3 and i4 are also articles, and both authored by John. These resulting searchable (completed) semantic annotations of (objects on) standard Web pages are published as HTML Web pages with pointers to the respective object pages, so that they (in addition to the standard Web pages) can be searched by standard search engines. For example, the HTML pages for the completed semantic annotations of the above Ai1 , Ai2 , Ai3 , and Ai4 are shown in Fig. 2, right side. Note that on the HTML page of each individual, its identifier is located beside the atomic concept below the row specifying the URIs. Practically, such an identifier may simply be the HTML address of the Web page/object’s annotation page. For example, considering the HTML pages of Fig. 2, the individual described by p4 is i4, and the one described by p2 is i2. Observe that we use a plain textual representation of the completed semantic annotations in order to allow their processing by existing standard search engines for the Web. It is important to point out that this textual representation is simply a list of properties, each eventually along with an identifier or a data value as attribute value, and it can thus immediately be encoded as a list of RDF triples. Query Evaluator. The Query Evaluator (see Fig. 1) reduces each Semantic Web search query of the user in an online query processing step to a sequence of standard Web search queries on standard Web and annotation pages, which are then processed by a standard Web Search Engine. The Query Evaluator also collects the results and re-transforms them into a single answer which is returned to the user. As an example of a Semantic Web search query, one may ask for all Ph.D. students who have published an article in 2008 with RDF as a keyword, which is formally expressed as follows:
Q(x) = 9y (PhDStudent(x) ^ isAuthorOf(x; y) ^ Article(y) ^
yearOfPublication(y; 2008) ^ keyword(y; \RDF ”)) : This query is transformed into the two queries Q1 = PhDStudent AND isAuthorOf and Q2 = Article AND “yearOfPublication 2008” AND “keyword RDF”, which can both be submitted to a standard Web search engine, such as Google. The result of the original query Q is then built from the results of the two queries Q1 and Q2. Note that a graphical user interface, such as the one of Google’s advanced search, or even a natural language interface can help to hide the conceptual complexity of ontological queries to the user. 3
We now introduce Semantic Web knowledge bases and the syntax and semantics of
Semantic Web search queries to such knowledge bases. We then generalize the PageRank
technique to our approach. We assume the reader is familiar with the syntax and the
semantics of Description Logics (DLs) [
We assume pairwise disjoint sets D, A, RA, RD, I, and V of atomic datatypes, atomic concepts, atomic roles, atomic attributes, individuals, and data values, respectively. Let I be the disjoint union of two sets P and O of Web pages and Web objects, respectively. Informally, every p 2 P is an identifier for a concrete Web page, while every o 2 O is an identifier for a concrete object on a concrete Web page. We assume the atomic roles links to between Web pages and contains between Web pages and Web objects. The former represents the link structure between concrete Web pages, while the latter encodes the occurrences of concrete Web objects on concrete Web pages.
Definition 1. A semantic annotation Aa for a Web page or object a 2 P [ O is a finite set of concept membership axioms A(a), role membership axioms P (a; b), and attribute membership axioms U (a; v), where A 2 A, P 2 RA, U 2 RD, b 2 I, and v 2 V. A Semantic Web knowledge base KB = (T ; (Aa)a 2 P[O) consists of a TBox T and one semantic annotation Aa for every Web page and object a 2 P [ O.
Informally, a Semantic Web knowledge base consists of some background terminological knowledge and some assertional knowledge for every concrete Web page and for every concrete object on a Web page. The background terminological knowledge may be an ontology from some global Semantic Web repository or an ontology defined locally by the user site. In contrast to the background terminological knowledge, the assertional knowledge will be directly stored on the Web (on annotation pages like the described standard Web pages) and is thus accessible via Web search engines.
Example 1. (Scientific Database). We use a DL knowledge base KB = (T ; A) to specify some simple information about scientists and their publications. The sets of atomic concepts, atomic roles, atomic attributes, and data values are:
A = fScientist; Article; ConferencePaper; JournalPaperg; RA = fhasAuthor; isAuthorOf; containsg; RD = fname; title; yearOfPublicationg; V = f\mary"; \Semantic Web search"; 2008; \Semantic Web search engines"g: Let I = P [ O be the set of individuals, where P = fi1g is the set of Web pages, and O = fi2; i3; i4g is the set of Web objects on the Web page i1. The TBox T contains the axioms in Eq. 2. Then, a Semantic Web knowledge base is given by KB = (T ; (Aa)a 2 P[O), where the semantic annotations of the individuals in P [ O are the ones in Eq. 1. Semantic Web Search Queries. We use unions of conjunctive queries with negated conjunctive subqueries as Semantic Web search queries to Semantic Web knowledge bases. We now first define the syntax of Semantic Web search queries and then the semantics of positive and general such queries.
Syntax. Let X be a finite set of variables. A term is either a Web page p 2 P, a Web object o 2 O, a data value v 2 V, or a variable x 2 X. An atomic formula (or atom) is of one of the following forms: (i) d(t), where d is an atomic datatype, and t is a term; (ii) A(t), where A is an atomic concept, and t is a term; (iii) P (t; t0), where P is an atomic role, and t; t0 are terms; and (iv) U (t; t0), where U is an atomic attribute, and t; t0 are terms. An equality has the form =(t; t0), where t and t0 are terms. A conjunctive formula 9y (x; y) is an existentially quantified conjunction of atoms and equalities =(t; t0), which have free variables among x and y.
Definition 2. A Semantic Web search query Q(x) is an expression Win=1 9yi i(x; yi), where each i with i 2 f1; : : : ; ng is a conjunction of atoms (also called positive atoms), negated conjunctive formulas not , and equalities =(t; t0), which have free variables among x and yi, and the x’s are exactly the free variables of Win=1 9yi i(x; yi).
Intuitively, Semantic Web search queries are unions of conjunctive queries, which may contain negated conjunctive queries in addition to atoms and equalities as conjuncts. Example 2. (Scientific Database cont’d). Two Semantic Web search queries are: Q1(x) = (Scientist(x) ^ not doctoralDegree(x; \oxford university") ^ worksFor(x; \oxford university")) _ (Scientist(x) ^ doctoralDegree(x; \oxford university") ^ not worksFor(x; \oxford university")); Q2(x) = 9y (Scientist(x) ^ worksFor(x; \oxford university") ^ isAuthorOf(x; y)^ not ConferencePaper(y) ^ not 9z yearOfPublication(y; z)): Informally, Q1(x) asks for scientists who are either working for oxford university and did not receive their Ph.D. from that university, or who received their Ph.D. from oxford university but do not work for it. Whereas query Q2(x) asks for scientists of oxford university who are authors of at least one unpublished non-conference paper. Note that when searching for scientists, the system automatically searches for all subconcepts (known according to the background ontology), such as e.g. Ph.D. students or computer scientists. Semantics of Positive Search Queries. We now define the semantics of positive Semantic Web search queries, which are free of negations, in terms of ground substitutions via the notion of logical consequence.
A search query Q(x) is positive iff it contains no negated conjunctive subqueries. A (variable) substitution maps variables from X to terms. A substitution is ground iff it maps to Web pages p 2 P, Web objects o 2 O, and data values v 2 V. A closed first-order formula is a logical consequence of a knowledge base KB = (T ; (Aa)a2P[O), denoted KB j= , iff every first-order model I of T [ Sa2P[O Aa also satisfies . Definition 3. Given a Semantic Web knowledge base KB and a positive Semantic Web search query Q(x), an answer for Q(x) to KB is a ground substitution for the variables x (which are exactly the free variables of Q(x)) with KB j= Q(x ).
Example 3. (Scientific Database cont’d). Consider the Semantic Web knowledge base KB of Example 1 and the following positive Semantic Web search query, asking for all scientists who author at least one published journal paper:
Q(x) = 9y (Scientist(x) ^ isAuthorOf(x; y) ^ JournalPaper(y) ^ 9z yearOfPublication(y; z)):
= fx=i2g. Recall that i2 represents the scientist Mary.
Semantics of General Search Queries. We next define the semantics of general
Semantic Web search queries by reduction to the semantics of positive ones, interpreting
negated conjunctive subqueries not as the lack of evidence about the truth of . That is,
negations are interpreted by a closed-world semantics on top of the open-world semantics
of DLs (we refer to [
Definition 4. Given a Semantic Web knowledge base KB and search query Q(x) = Win=1 9yi i;1(x; yi) ^ ^ i;li (x; yi) ^ not i;li+1(x; yi) ^ ^ not i;mi (x; yi) ; an answer for Q(x) to KB is a ground substitution for the variables x such that KB j= Q+(x ) and KB 6j= Q (x ), where Q+(x) and Q (x) are defined as follows: QQ+((xx)) == WWiinn==11 99yyii ii;;11((xx;; yyii)) ^^ ^ i;li (x; yi) and ^ i;li (x; yi) ^ ( i;li+1(x; yi) _ _ i;mi (x; yi)) :
Roughly, a ground substitution is an answer for Q(x) to KB iff (i) is an answer for Q+(x) to KB , and (ii) is not an answer for Q (x) to KB , where Q+(x) is the positive part of Q(x), while Q (x) is the positive part of Q(x) combined with the complement of the negative one. Observe that both Q+(x) and Q (x) are positive queries. Example 4. (Scientific Database cont’d). Consider the Semantic Web knowledge base KB = (T ; (Aa)a2P[O) of Example 1 and the following general Semantic Web search query, asking for Mary’s unpublished non-journal papers:
Q(x) = 9y (Article(x) ^ hasAuthor(x; y) ^ name(y; \mary") ^ not JournalPaper(x) ^ not 9z yearOfPublication(x; z)): An answer for Q(x) to KB is given by = fx=i3g. Recall that i3 represents an unpublished conference paper entitled “Semantic Web search”. Observe that the membership axioms Article(i3) and hasAuthor(i2; i3) do not appear in the semantic annotations Aa with a 2 P [ O, but they can be inferred from them using the background ontology T . Ranking Answers. As for the ranking of all answers for a Semantic Web search query Q to a Semantic Web knowledge base KB (i.e., ground substitutions for all free variables in Q, which correspond to tuples of Web pages, Web objects, and data values), we use a generalization of the PageRank technique: rather than considering only Web pages and the link structure between Web pages (expressed through the role links to here), we also consider Web objects, which may occur on Web pages (expressed through the role contains), and which may also be related to other Web objects via other roles. More concretely, we define the ObjectRank of a Web page or an object a as follows:
R(a) = d Pb2Ba R(b) = Nb + (1 d) E(a) ; where (i) Ba is the set of all Web pages and Web objects that relate to a, (ii) Nb is the number of Web pages and Web objects that relate from b, (iii) d is a damping factor, and (iv) E associates with every Web page and every Web object a source of rank. 4
In this section, we describe the (deductive) offline ontology reasoning step, which
compiles the implicit terminological knowledge in the TBox of a Semantic Web knowledge
base into explicit membership axioms in the ABox, i.e., in the semantic annotations of
Web pages / objects, so that it (in addition to the standard Web pages) can be searched by
standard Web search engines. For the online query processing step, see [
The compilation of TBox knowledge into ABox knowledge is formalized as follows. Given a satisfiable Semantic Web knowledge base KB = (T ; (Aa)a2P[O), the simple completion of KB is the Semantic Web knowledge base KB 0 = (;; (Aa0)a2P[O) such that every Aa0 is the set of all concept memberships A(a), role memberships P (a; b), and attribute memberships U (a; v) that logically follow from T [ S P 2 RA, U 2 RD, b 2 I, and v 2 V. Informally, for every Web paag2eP[anOdAobaj,ewcth,etrheeAsim2pAle, completion collects all available and deducible facts (whose predicate symbols shall be usable in search queries) in a completed semantic annotation.
Example 5. Consider the TBox T of Example 1 and the semantic annotations (Aa)a 2 P[O of Example 1. The simple completion contains in particular the new axioms Article(i3), hasAuthor(i3; i2), and Article(i4). The first two are added to Ai3 and the last one to Ai4 .
As shown in [
Once the completed semantic annotations are computed, we encode them as HTML pages, so that they are searchable via standard keyword search. Specifically, we build one HTML page for the semantic annotation Aa of each individual a 2 P [ O. That is, for each individual a, we build a page p containing all the atomic concepts whose argument is a and all the atomic roles/attributes where the first argument is a (see Section 2).
We now describe an inductive inference based on similarity search, which we propose
to use instead of deductive inference for offline ontology compilation in our approach to
Semantic Web search. Section 6 then summarizes the central advantages of this proposal.
Inductive Inference Based on Similarity Search. In similarity search [
Observe that this setting assigns to the query instance xq a value, which stands for one in a set of pairwise disjoint concepts (corresponding to the value set V ). In a multirelational setting, as those of the Semantic Web (SW) context, this assumption cannot be made in general, since it is well known that an individual may be an instance of more than one concept. The problem is also related to the closed-world assumption (CWA) usually made in the knowledge discovery context. To deal with the open-world assumption (OWA), generally adopted for the SW representations, the absence of information on whether a training instance x belongs to the extension of a query concept Q should not be interpreted negatively, as in the standard settings which adopt the CWA, rather, it should count as neutral (uncertain) information. Assuming this alternate viewpoint, the multiclass classification problem is transformed into a ternary one and the V = f+1; 1; 0g value set is adopted for the classification of an individual with respect to a query concept Q and where the three values denote, respectively, membership, non-membership, and uncertainty. Hence, the task is cast as follows: given a query concept Q, determine the membership of an instance xq through the NN procedure (see Eq. 3) where V = f 1; 0; +1g and the hypothesis function values for the training instances are determined as: hQ(x) =
That is, the value of hQ for the training instances is determined by logical entailment (denoted j=) of the corresponding assertion from the knowledge base. Alternatively, a look-up in the ABox of the knowledge base could be considered, thus obtaining a classification process less complex but also possibly less accurate.
For measuring the similarity between individuals, a totally semantic and language
independent family of dissimilarity measures has been used [
2 jFj 1 F 4X wi j i(a; b) jp5 j j i=1 31=p ; where the dissimilarity function i (i 2 f1; : : : ; mg) is defined as follows: 8a; b 2 Ind(A) : i(a; b) = 8 0 >< 1 >: 1=2
Fi(a) 2 A ^ Fi(b) 2 A Fi(a) 2 A ^ :Fi(b) 2 A or :Fi(a) 2 A ^ Fi(b) 2 A otherwise:
An alternative definition for the projections requires the entailment of an assertion (instance-checking) rather than the simple ABox look-up; this can make the measure more accurate yet more complex to compute. Moreover, using instance checking, induction is performed on top of deduction, thus making it a kind of completion of deductive reasoning.
As for the weights wi employed in the family of measures, they should reflect the impact of the single feature concept Fi relative to the overall dissimilarity. This is determined by the quantity of information conveyed by a feature, which is measured as its entropy. Namely, the extension of a feature Fi relative to the whole domain of objects may be probabilistically quantified as PFi = jFiI j=j I j (relative to the canonical interpretation I). This can be roughly approximated by jretrieval(Fi)j=jInd(A)j. Hence, considering also the probability P:Fi related to its negation and the one related to the unclassified individuals (relative to Fi), denoted PU , we may give an entropic measure for the feature: H(Fi) =
(PFi log(PFi ) + P:Fi log(P:Fi ) + PU log(PU )) :
The measures strongly depend on F. Here, we make the assumption that the feature-set
F represents a sufficient number of (possibly redundant) features that are able to
discriminate really different individuals. However, an optimal discriminating feature set could be
learned [
Measuring the Likelihood of an Answer. The inductive inference made by the procedure shown above is not guaranteed to be deductively valid. Indeed, inductive inference naturally yields a certain degree of uncertainty. So, from a more general perspective, the main idea behind the above inductive inference for Semantic Web search is closely related to the idea of using probabilistic ontologies to increase the precision and the recall of querying databases and of information retrieval in general. But, rather than learning probabilistic ontologies from data, representing probabilistic ontologies, and reasoning with probabilistic ontologies, we directly use the data in the inductive inference step.
In order to measure the likelihood of the decision made by the inductive procedure (individual xq belongs to the query concept denoted by value v maximizing the argmax argument in Eq. 3), given the k-nearest training individuals in NN (xq) = fx1; : : : ; xkg, the quantity that determined the decision should be normalized by dividing it by the sum of such arguments over the (three) possible values: l(class(xq) = vjNN (xq)) =
Pik=1 wi Pv02V Pik=1 wi (v; hQ(xi)) (v0; hQ(xi)) : (4)
Hence, the likelihood of the assertion Q(xq) corresponds to the case when v = +1. The computed likelihood can be used for building a probabilistic ABox (which is a collection of pairs, each consisting of a classical ABox axiom and a probability value).
In this section, we illustrate the main advantages of using inductive reasoning in Semantic Web search, namely, that inductive reasoning (differently from deductive reasoning) can handle inconsistencies, noise, and incompleteness in Semantic Web knowledge bases, which are all very likely to occur when knowledge bases are stored in a distributed and heterogeneous fashion, like on the Web.
Inconsistencies. Since our inductive method is based on the majority vote of the individuals in the neighborhood, it may be able to give a correct classification even in the case of inconsistent knowledge bases. This aspect is illustrated by the following example. Example 6. Consider the description logic knowledge base KB = (T ; A) that consists of the following TBox T and ABox A:
T = fMan Male u Human; Professor Person u 9abilitatedTo:Teaching u 9isSupervisorOf:PhDThesis u Researcher; Researcher GraduatePerson u 9worksFor:ResearchInstitute u :9isSupervisorOf:PhDThesis; : : :g ; A = fProfessor(Franz); isSupervisorOf(Franz; DLThesis); Professor(John); isSupervisorOf(John; RoboticsThesis); Professor(Flo); isSupervisorOf(Flo; MLThesis); Researcher(Nick); Researcher(Ann); isSupervisorOf(Nick; SWThesis); : : :g : Actually, Nick is a Professor, indeed, he is the supervisor of a PhD thesis in A. However, by human mistake, he is asserted to be a Researcher in A, and by the axiom for Researcher in T , he cannot be the supervisor of any PhD thesis. Hence, KB is inconsistent, and thus a deductive reasoner cannot answer whether Nick is a Professor or not (since everything can be deduced from an inconsistent knowledge base). On the contrary, by inductive reasoning, it is highly probable that the returned classification result is that Nick is an instance of Professor. This is because the most similar individuals are Franz, John, and Flo, and all of them vote for the concept Professor.
Noise. Inductive reasoning may also be able to give a correct classification in the presence of noise in a knowledge base (containing, e.g., incorrect concept and/or role membership assertions), which is illustrated by the following example.
Example 7. Consider the description logic knowledge base KB = (T 0; A), where the ABox A is as in Example 6 and the TBox T 0 is obtained from the TBox T of Example 6 by replacing the axiom for Researcher by the following axiom:
Researcher
GraduatePerson u 9worksFor:ResearchInstitute : Again, Nick is actually a Professor, but by human mistake asserted to be a Researcher in KB . But due to the slightly modified axiom for Researcher, there is no inconsistency in KB anymore. By deductive reasoning, however, Nick turns out to be a Researcher, whereas by inductive reasoning, it is highly probable that the returned classification result is that Nick is an instance of Professor, as above, because the most similar individuals are Franz, John, and Flo, and all of them vote for the concept Professor. Incompleteness. Clearly, inductive reasoning may also be able to give a correct classification in the presence of incompleteness in a knowledge base. That is, inductive reasoning is not necessarily deductively valid, and may produce new knowledge.
Example 8. Consider the description logic knowledge base KB = (T 0; A0), where the TBox T 0 is as in Example 7 and the ABox A0 is obtained from the ABox A of Example 6 by removing the axiom Researcher(Nick). Then, the resulting knowledge base is neither inconsistent nor noisy, but it is now incomplete. Nonetheless, by the same line of argumentation as in Examples 6 and 7, it is highly probable that the classification result by inductive reasoning is that Nick is an instance of Professor.
In this section, we describe our prototype implementation for a semantic desktop search engine. Furthermore, we report on very positive experimental results on the precision and the recall under inductively vs. deductively completed semantic annotations. Implementation. We have implemented a prototype for a semantic desktop search engine. We have realized both a deductive and an inductive version of the offline inference step for generating the completed semantic annotation for every considered resource. The deductive version uses PELLET1, while the inductive one is based on the k-NN technique, integrated with an entropic measure, as proposed in Section 5. Specifically, each individual i of a Semantic Web knowledge base is classified relative to all atomic concepts and all restrictions 9R :fig with roles R. The parameter k was set to log(jInd(A)j), where Ind(A) stands for all individuals in the knowledge base. The simpler distances d1F were employed, using all the atomic concepts in the knowledge base for determining the set F. Precision and Recall of Inductive Semantic Web Search. We next give an experimental comparison between Semantic Web search under inductive and under deductive reasoning. We do this by providing the precision and the recall of the latter vs. the former. Our experimental results with queries relative to the FINITE-STATE-MACHINE (FSM) and the SURFACE-WATER-MODEL (SWM) ontology from the Prote´ge´ Ontology Library2 are summarized in Table 1. For example, Query (8) asks for all transitions having no target state, while Query (16) asks for all numerical models having either the domain “lake” and public availability, or the domain “coastalArea” and commercial availability. The experimental results in Table 1 essentially show that the answer sets under inductive reasoning are very close to the ones under deductive reasoning. 8
We have presented a combination of Semantic Web search as presented in [
2 http://protegewiki.stanford.edu/index.php/Protege Ontology Library
Onto- Query logy 1 FSM State(x) 2 FSM StateMachineElement(x) 3 FSM Composite(x) ^ hasStateMachineElement(x; accountDetails) 4 FSM State(y) ^ StateMachineElement(x) ^ hasStateMachineElement(x; y) 5 FSM Action(x) _ Guard(x) 6 FSM 9y; z (State(y) ^ State(z) ^ Transition(x) ^ source(x; y) ^ target(x; z)) 7 FSM StateMachineElement(x) ^ not 9y (StateMachineElement(y) ^
hasStateMachineElement(x; y)) 8 FSM Transition(x) ^ not 9y (State(y) ^ target(x; y)) 9 FSM 9y (StateMachineElement(x) ^ not hasStateMachineElement(x;
accountDetails) ^ hasStateMachineElement(x; y) ^ State(y)) 10 SWM Model(x) 11 SWM Mathematical(x) 12 SWM Model(x) ^ hasDomain(x; lake) ^ hasDomain(x; river) 13 SWM Model(x) ^ not 9y (Availability(y) ^ hasAvailability(x; y)) 14 SWM Model(x) ^ hasDomain(x; river) ^ not hasAvailability(x; public) 16 SWM 9Nyum(Meroicdaell((xx)) ^^ hhaassDDoevmealoinp(exr(;xla;kye))^^UhansivAevrasiiltayb(yil)it)y(x; public)_ 15 SWM
Numerical(x) ^ hasDomain(x; coastalArea) ^ hasAvailability(x; commercial) 34 0
In the future, we aim especially at extending the desktop implementation to a real Web implementation, using existing search engines, such as Google. Another interesting topic is to explore how search expressions that are formulated as plain natural language sentences can be translated into the ontological conjunctive queries of our approach. It would also be interesting to investigate the use of probabilistic ontologies rather than classical ones. Acknowledgments. Georg Gottlob’s work was supported by the EPSRC grant Number EP/E010865/1 “Schema Mappings and Automated Services for Data Integration.” Georg Gottlob, whose work was partially carried out at the Oxford-Man Institute of Quantitative Finance, gratefully acknowledges support from the Royal Society as the holder of a Royal Society-Wolfson Research Merit Award. Thomas Lukasiewicz’s work was supported by the German Research Foundation (DFG) under the Heisenberg Programme.