Semergence

Oracle 11g will gain native OWL support.

From the article:

> (2) Native OWL inferencing (for an OWL subset that includes property characteristics, class comparisons, proprety comparisons, individual comparions and class expressions) [New API]

Way to go, Oracle! I’ve always had a soft spot for Oracle’s RDF support. The way that you can blend RDF data sets and traditional relational data sets in the same query helps to deploy RDF slowly but surely. Not to mention that Oracle has already solved all the main problems that a RDBMS should solve (like ACID compliance, backup and recovery, strong security, wide developer toolset) makes Oracle’s RDF support (and soon OWL) a strong contender for RDF data stores.

TopBraid Composer is a:

> new modeling environment from industry experts for creating and managing Semantic Web ontologies.

From the people who brought you Protege OWL editor. Built on Eclipse.

IBM Web Ontology Manager has just been released.

> IBM Web Ontology Manager is a lightweight, Web-based tool for managing ontologies expressed in Web Ontology Language (OWL). With this technology, users can browse, search, and submit ontologies to an ontology repository.

Pellet, an open source OWL reasoner from Mindswap, is now at version 1.3. It is a very capable reasoner, and has excellent integration with Jena.

Below is a list of changes for 1.3:

* ENHANCED: SPARQL query engine PelletQueryExecution tu answer non-SELECT queries

* ADDED: Processing class expressions in SPARQL queries

* ADDED: Treating bnodes in SPARQL queries as non-distinguished variables

* ADDED: Query optimization features (simplification and reordering). Reordering feature is
disabled by default and needs to be enabled in the configuration file.

* ENHANCED: Datatype reasoning support for user-defined datatypes

* ADDED: Support for InverseFunctional datatype properties (a.k.a. keys). (experimental)

* ADDED: Support for DL-safe rules (experimental)

* ENHANCED: Pellet command line options

* ENHANCED: More configuration parameters in pellet.properties

The Semantic Web talk at HJUG went fairly well. About eight people attended, and a few have either used RDF or are currently using RDF and OWL. The questions from the audience were insightful, demonstrating that they were thinking critically about the technologies. Some questions were quite expected:

Q) If anyone can say anything about anything, what’s to stop someone from saying something wrong? How will I know *not* to use those incorrect assertions for my reasoning?

A) Good question! I have two solutions for this. The first is a Google-esque algorithm and hueristics will appear, allowing the top linked RDF documents to bubble to the top. That is, the more people that link to the RDF document, the more likely that the assertions contained within are valid for a majority of the views of the world. The second answer relies on ontologies, for they are able to determine if there are inconsistencies in the world. If someone says that cars and people are disjoint, and you have assertions in your RDF model that says X is a person and a car, then your reasoner can determine that at least one fact is incorrect. (of course, the hand waving here is that someone has to write the ontology, and you have to have a reasoner that provides feedback in a human readable way.)

Q) What if I use foaf:interest, but someone else uses yahoo:interest? My SPARQL queries won’t work.

A) You’re right, non-reasoning RDF stores won’t know that foaf:interest and yahoo:interest are the same thing (for your view of the world). Again, ontologies are required to provide the mapping between different ontologies. *If* you have a mapping ontology, and *if* your RDF store performs reasoning, then your SPARQL queries will work when you have two URIs for the same concept.

Q) So… what have people built with RDF?

A) The answer I gave here is the biggest adoption of semweb technologies has been bioinformatics, afaik. However, I couldn’t think of any business critical, production applications using RDF as a key component. I need to do more research here.

A better question might be, “What are some applications that utilize RDF/OWL that would have been very difficult to create otherwise?” And by applications, I mean business critical, production applications that customers use every day. I have a feeling that a lot of the RDF/OWL work is done for in-house, custom applications. What are those applications like? What scale have they been built out to?

All in all, a good talk. I met some people who are using Protege and Racer Pro to develop decision support applications for first responders. Don’t know if it’s a proof of concept of a deployed application yet.

Henry has discovered SWOOP, a small ontology editor from MindSwap. This reminds me to point out a very nice feature of SWOOP, one that Protege does not have out of the box.

SWOOP, through its integration with Pellet, is able to not only compute classifications but also able to tell you *why* your ontology is inconsistent. This, to me, is a huge step towards being able to use ontologies in “every day” problems.

The use case here is: You are collecting information from many many different sources. You have an ontology that defines your view of the world. It’s possible that all the different information sources will present to you conflicting information. Your ontology defines what is consistent, so therefore it should be able to tell you when you have information that is *inconsistent*.

SWOOP does a pretty good job at giving you the feedback to find the source of the inconsistency. An example output is:

Inconsistent ontology Reason: Individual ErrorBoat has more than 1 values for property at
Location
violating the cardinality restriction
Axioms causing the problem:
1) (ErrorBoat decommissionedAt DryDock)
2) |_(DryDock ≠ SanDiego)
3) |_(ErrorBoat deployedTo SanDiego)
4) |_(ErrorBoat rdf:type Boat)
5) |_(Boat ⊆ (= 1 atLocation))

Now that’s a simple problem, where an instance has two values for a property that is constrained to have only one.

What about when an individual belongs to two disjoint classes? This one is a bit more confusing if you don’t have a background in DL, but if you stare long enough at it, you might see the real cause:

Inconsistent ontology Reason: Individual ErrorBoat is forced to belong to class
all(decommissionedAt, not(Location))
and its complement

Axioms causing the problem:
1) (ErrorBoat decommissionedAt DryDock)
2) |_(DryDock rdf:type Location)
3) |_(SanDiego rdf:type Location)
4) |_(ErrorBoat deployedTo SanDiego)
5) (Decommissioned ≡ (∃decommissionedAt . Location))
6) (Active ⊆ ¬ Decommissioned)
7) (Active ≡ (∃deployedTo . Location))

To explain this one better, I’ve declared that the class Active and the class Decommissioned are disjoint. And I’ve placed the instance ErrorBoat into both classes.

For this reason, I like SWOOP and Pellet. Though, Protege still has nicer workflows.

Temporal relations from Henry Story on 2006-03-23 (semantic-web@w3.org from March 2006) is a post to the swig mailing list dealing with time in RDF.

The proposal in the email attempts to use N3’s ability to declare metadata about graphs, in order to say when the graph was fetched. For instance:

{ :Oven :temp “22″^^t:celsius . } :fetched [ :at “2006-03-23T10:00:00Z”^^xsd:dateTime; ] .

Of course, the problem here is there’s no formal RDF semantics for this, as there’s no formal way to write triples about a graph. This is an N3 thing. I would guess the closest thing in RDF would be reification.

This is similar to how I’ve been thinking about the problem, which is marking the time the triples were retrieved from the source. The email, though, points out that it is difficult to merge those graphs together, as you’ll end up with many values for an Oven’s :temp. Once merged, how do you query for a particular temp at a particular time?

Another way to do it is to make the measurement a formal object. I’ve blogged on this before, and it’s been heavily discussed in comments, but in short:

:Measurement :of :Oven ; :takenAt “2006-03-23T10:00:00Z”^^xsd:dateTime ; :valueRecorded “22″^^t:celcius.

A bit of OWL makes it slightly more interesting:

:TemperatureMeasurement owl:equivalentClass [ a owl:Restriction; owl:onProperty :valueRecorded; owl:someValuesFrom t:celcius ].

(Does that work? Will have to try…)

Instance Store is a

> Java application for performing efficient and scalable Description Logic (DL) reasoning over individuals

What does this mean? It’s an attempt to build a system that can reason (using OWL, for instance) across a large set of instances.

Apparently it stores individuals in a RDBMS, such as MySQL or Oracle. It then connects that store to a reasoner, such as Racer or FaCT++. I haven’t tried it yet, but I will soon, so I’m storing this here for future reference.

Would be interesting to see if plugging this directly into Oracle 10g’s RDF store provides any benefits.

I should note that a quick glance at the code indicates that it hasn’t been touched in about two years.

ConsVISor is a nice web service that can check an OWL ontology (with individuals) for consistency. It displays any errors with easy to read non-technical-jargon sentences. I’ve been trying to find a workflow where I can test a set of individuals against an ontology to see where the inconsistencies are, and this tool is the best so far for reporting any problems.

FaCT++, via Protege, doesn’t seem to provide any error messages. It does fail, though (correctly). Can’t figure out how to get it to tell me what and where the problem is.

Pellet, via their online demo, seems to work. However, the error messages are cryptic and seemingly misleading. I’m assuming they are correct, however they would never lead the lay-person to the real problem.

Anyone else using OWL for consistency checking across individuals? What tool are you using? Can it provide useful error messages?

OWL 1.1 Web Ontology Language is beginning to take shape. I’m most excited about the new datatype support. For example, you can now say “Adults are Persons that have age someValuesFrom >= 18″ In other words, you can now define ranges to acceptible values for a datatype. This is different than cardinality (which would be something like “SuperPetLover is a Person with 5 pets”), this is restricting the acceptible ranges for values of datatype properties.