Who uses reasoning? Where? Which form? Why?

I still do not have gained is a clear picture about where reasoning is really used nowadays. I don't talk about experiments, or university exercises. I'm talking about real use, and, ideally, productive use.

So, is there anybody out there? Who has a story to tell and loves to share it with the rest of us? Where do you use reasoning? What is your concrete application scenario? Which form of reasoning do you use (language, reasoning engine, special ways to use reasoning) to achieve your goals? And why have you decided to use this form of reasoning, provided that it is not already obvious from the use case? So answers would look something like: "At example.org, we use OWL 2 RL/RDF reasoning on large-scale SKOS knowledgebases, in order to [WHATEVER REASON]."

Edit: It does not really need to be your own story. If you know of some organization making serious use of reasoning, that's quite as good. Any pointers are welcome!

At VW we use reasoning (forward chaining) to maximise the value of our data i.e make it more discoverable and accessible to 3rd parties.


For me, this is the most compelling use case from a very commercial perspective. Since we are not advocating controlling vocabularies, people will familiarise and adopt a diversity of terms that actually describe the same thing. It is therefore beneficial to be able to align those vocabularies and ensure the relevant data is made accessible to the right organisations.

I have also proposed a meetup that I hope to host on such a subject since there seems to be quite varying opinions about the reasons for reasoning.


In short, we use it for materialisation (can't think of any instance where we use it for deductive purposes yet) for the following reasons:

  1. We don't use GoodRelations directly for our product data. We use the Car Options Ontology, which extends the Vehicle Sales Ontology, which in turn extends GoodRelations. We describe things in our terms and then let the reasoner describe them in other peoples terms instead of explicitly (and maybe incorrectly) stating them ourselves. This also saves time in learning other vocabularies, especially amongst a team who are fairly new to Semantic Web technologies.

  2. It maximises the value of our data especially since we can't always predict the context in which it is going to be used, especially where third parties are concerned. Also you can't expect SPARQL users to be familiar with entailment or a SPARQL endpoint to support backward chaining / query time entailment, so we materialise ahead of query time.

  3. Combined with the fact that we encourage 3rd party websites (those that are part of the domain, but developed, hosted, managed and served separately) to use RDFa. We have to make it as simple, painless and unobtrusive to do so, therefore we cherry pick recommended terms for use and materialise the rest at crawl time.

Some speculative prediction

  1. Not all developers will be Web Ontologists. In the long run, as Semantic Web technology starts to take off (it's benefits are actually starting to be understood now), organisations will employ full time, working Web Ontologists (note I use the phrase 'Web Ontologist' not 'Ontologist') who define basic terms for developers to map to within the context of their application and domain, along with references to relevant ontologies to included during any kind of reasoning.

  2. In the long run, reasoning cannot be ignored. The number of vocabularies will grow and for the Semantic Web to be a success and to ensure homogeneity, consistency and some level of intelligence (and advantage over the current web of data, i.e lots of meaningless XML and JSON), we will need 'corrective' reasoning to make up for short sighted vocabularies and incorrect implementations.

  3. I recon after 1 and 2, then it will be viable to start to do deductive / intelligent reasoning on a far greater scale. There is probably nothing to stop it now, other than it might have less value or not operationally or commerically viable yet.

At TopQuadrant we have several customer projects that use inferencing as a way to transform one data structure into another. A currently ongoing project is EPIM ReportingHub http://www.topquadrant.com/docs/pr/11-08-12%20_TQ_%20EPIM_ReportingHub.pdf . This is all about integration of XML-based files into a shared RDF model. The role of the target ontology is to serve as a central repository of all sorts of oil and gas related information, independent of the XML serialization. Our approach takes the XML Schemas and converts them into "Semantic XML" RDF models that more or less represent the XML verbatim. Then we have SPIN rules/SPARQL CONSTRUCT queries that map the "raw" XML into the proper target ontology. The benefit of using SPIN/SPARQL for the transformations is that the mapping rules themselves can query other background knowledge that is already encoded in RDF.

There has been a great presentation gives by the guys from AllegroGraph in relation to one of their customers AMDOCS that provides CRM systems to telecoms companies around the world. They've completely rebuilt their system to incorporate RDF and utilise rules based reasoning in order to provide better customer service with tangible business ROI.

See here for various links to presentation slides, webcasts etc

For the record I have no professional relationship whatsoever with Franz Inc I've just seen their presentation at SemTech conferences a couple of times and it's really impressive and fits your question exactly.

I wanna share a story, which is about emergency rescue in civil aviation field. As we know, there are many air accidents come up all around the world, however,there is not an effective decision system,as far as i know, which can offer rescuing schemes for commanders automatically according with the specific accident information when the emergencies happen.

In civil aviation, the rescuing schemes,most of time,are got via the experience of commanders, however, the air accidents occured have stong uncertainty,for example, where, when, the degree and so on, all of them are uncertainty. Under such circumstance, although there are different kinds of established plans for differnet kinds of emergence cases, the schemes got according with experience may not achieve good effect, especially for big, confused cases.(Of course, the experience could be considered as expert knowledge used to construct rules for reasoning.) So, a fast, precise as soon as possible,specific scheme got under specific air accident will become very, very important and necessary.

In order to acheieve the goal, we should develop a system which can generate a relevant solution according with specific accident circumstance for commanders, and one of the most important aspect is the rescuing rescources dispatch. For example, if one of fire departments is short of pumpers, the decision system should generate a according solution about where the commander should go to dispatch,which will become a decision problem, and so the reasoning should play a great role.

Of course, in order to get an effective reslut via reasoning, the ontology constructed, i think, will become very,very important, which is the base of resoning and will decide that the reasoning result is good or not.

I am really consider that it will reduce loss caused by air accidents effectively with such a system which can offer the commanders rescuing solutions automatically via reasoning, and the meathod could be applied on many other related field .

What do you think? and do you have any suggesions or ideas for me? Thank you all!

OWL reasoning is good for merging data from different data sources and for converting between different type systems. For instance, DBpedia and Freebase cover similar domains but use different type definitions. Freebase has different types for :FilmActor, :TheatreActor, and :TelevisionActor, but somebody might want to to say

 :Actor owl:unionOf [:FilmActor,:TheatreActor,:TelevisionActor] .

Remember that the semantic web is based on Description Logics, which a hybrid between logic and databases. In particular, OWL reasoning is reasoning over a DL.

One of the most popular methods of "inference" is the use of SPARQL queries. If, for instance, you wanted to validate that a certain predicate is never used, you could write

  SELECT COUNT(?) { ?s :badPredicate ? o }

and know that the validation has failed if the count is nonzero. There's a RDF application called SPIN that formalizes the use of SPARQL for inference. SPARQL can be used for data filtering, item selection, for generating summary reports and many other tasks that some might consider 'inference'. CONSTRUCT queries are particularly useful, for instance

      ?player a :TopScoringPlayer .
  } WHERE {
      ?player a :Player .
      ?player :score ?score

It's also possible to reason on RDF data with other logical systems, such as First Order Logic. An early example is tbl's Closed World Machine. The cwm extends RDF to support a form of FOL. The cwm can do many kinds of processing of RDF data driven by FOL axioms.