OracleOwlPrime

From OWL
Revision as of 10:51, 24 January 2008 by Zwu2 (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search

Page to discuss the fragment of OWL implemented in Oracle 11g.

Herman ter Horst's pD*

Herman ter Horst defined an "intentional" version of OWL, called pD* [Completeness, decidability and complexity of entailment for RDF Schema and an intensional variant of OWL. Journal of Web Semantics. Volume 3, Issues 2-3, October 2005, Pages 79-115. http://www.sciencedirect.com/science?_ob=MImg&_imagekey=B758F-4H16P4Y-1-2H5&_cdi=12925&_user=4316138&_orig=search&_coverDate=10%2F31%2F2005&_sk=999969997&view=c&wchp=dGLbVlb-zSkWz&md5=e31fa38543c80457982234b1c90c9fd5&ie=/sdarticle.pdf] pD* has a model-theoretic semantics in the RDFS and OWL Full style, with a selected set of semantic conditions.

The pD* semantic conditions are:

  • I satisfies a basic set of triples, which are called the P-axiomatic triples.
  • If p in CEI(I(FunctionalProperty)) and (a, b), (a, c) in EI(p) then (b, c) in EI(I(sameAs))
  • If p in CEI(I(InverseFunctionalProperty)) and (a, c), (b, c) in EI(p) then (a, b) in EI(I(sameAs))
  • If p in CEI(I(SymmetricProperty)) and (a, b) in EI(p) then (b, a) in EI(p)
  • If p in CEI(I(TransitiveProperty)) and (a, b), (b, c) in EI(p) then (a, c) in EI(p)
  • EI(I(sameAs)) is an equivalence relation on RI
  • If a in CI and (a, b) in EI(I(sameAs)) then (a, b) in EI(I(subClassOf))
  • If p in PI and (p, q) in EI(I(sameAs)) then (p, q) in EI(I(subPropertyOf))
  • If p in PI, (a, b) in EI(p), (a,a0) in EI(I(sameAs)) and (b,b0) in EI(I(sameAs)), then (a0, b0) in EI(p)
  • EI(I(differentFrom )) ^ EI(I(sameAs)) = {}
  • (a, b) in EI(I(equivalentClass)) if and only if (a, b) in EI(I(subClassOf)) and (b, a) in EI(I(subClassOf))
  • (a, b) in EI(I(equivalentProperty )) if and only if (a, b) in EI(I(subPropertyOf)) and (b, a) in EI(I(subPropertyOf))
  • If (a, b) in EI(I(disjointWith)) then CEI(a) ^ CEI(b) = {}
  • If (p, q) in EI(I(inverseOf)) then (a, b) in EI(p) if and only if (b, a) in EI(q)
  • If (a, p) in EI(I(onProperty)), (a, b) in EI(I(hasValue)) then x in CEI(a) if and only if (x, b) in EI(p)
  • If (a, p) in EI(I(onProperty)), (a, b) in EI(I(someValuesFrom)), (x,y) in EI(p) and y in CEI(b), then x in CEI(a)
  • If (a, p) in EI(I(onProperty)), (a, b) in EI(I(allValuesFrom)), x in CEI(a) and (x,y) in EI(p), then y in CEI(b)

pD* ends up being quite unusual. Restrictions in particular are handled idiosyncratically. (In the following, by ..., a piece of DL syntax that constitutes an OWL restriction, we mean a blank node in the graph that satisfies the conditions to be an occurence of the restriction. For example, EpC is a blank node, _:n, and the triples _:n onProperty p and _:n someValuesFrom c should be considered to be part of the graph. Each ... introduces a different fresh blank node.)

  • For hasValue (r:V in DL syntax): o type r:V *iff* o satisfies the usual hasValue condition
  • For someValuesFrom (ErC): o type ErC *if* o satisfies the usual someValuesFrom condition
  • For allValuesFrom (ArC): o type ArC *only if* o satisfies the usual allValuesFrom condition

So it looks like hasValue has extensional semantics, allValuesFrom has intentional semantics, and someValuesFrom has some other kind of semantics. However, pD* has no comprehension conditions, so no restriction (including hasValue) has a full existential meaning.

Here is a sampling of entailments and non-entailments in pD*:

  • john type ErC NOTentails john r _:x
  • john r v, v type C NOTentails john type ErC
  • john r v, v type C, bill type ErC entails john type ErC
  • john type ErC, C subClassOf D, bill type ErD NOTentails john type ErD
  • john type ArC, john r v entails v type C
  • john r v, bill type ArResource NOTentails john type ArResource
  • john type ArD, C subClassOf D, bill type ArC NOTentails john type ArC
  • john type ErC, john type ArD, C disjointWith D NOTentails Resource disjointWith Resource
  • john type r:v entails john r v
  • john r v NOTentails john type r:v
  • john r v, bill type r:v entails john type r:v
  • john sameAs bill, john differentFrom bill entails _:x sameAs _:y (which is not computable by simply running all the pD* inference rules)

It is the case that entailment in pD* (and RDFS and RDF, by the way) cannot be determined simply by running a (safe) forward chaining rule engine on a set of tuples.

It appears that the main criterion for selecting the semantic conditions was to get close to a language that can be implemented by forward-chaining rules, but this is, of course, not the case.

Peter Patel-Schneider 06:29, 10 December 2007 (EST)

Semantic Details for OWLSIF

It is a bit hard to determine exactly what Oracle has implemented. It appears that they have something like pD* entailment.

Therefore in OWLSIF there are semantic conditions like the following. (I've used considerable shortcuts below to concentrate on what I think are the important bits.)

  • IF p is in FunctionalProperty, THEN p is functional
  • ...
  • IF o is in all p b THEN if o p x then x is in b
  • o is in exists p b IF o p x and x is in b
  • o is in value p v IFF o p v

This is the OWLSIF level in Oracle. The OWLPRIME level adds complementOf.

It appears that the implementation is via forward-chaining rules, although that cannot be complete

Peter Patel-Schneider 01:55, 10 December 2007 (EST)

Official documentation for Oracle 11gR1 RDF/OWL product

http://download.oracle.com/docs/cd/B28359_01/appdev.111/b28397/owl_concepts.htm

For those who are interested in the design, implementation and optimization details of Oracle 11gR1 OWL inference support, please refer to the following paper (accepted for ICDE 2008)

"Implementing an Inference Engine for RDFS/OWL Constructs and User-Defined Rules in Oracle"


Zhe Wu 02:45pm, 26 November 2007


Definition of OWLPrime (RDFS 3.0)

I am going to start with the following core set of RDFS 3.0 (http://www.w3.org/2007/OWL/wiki/Fragments) vocabularies because they are the most frequently asked RDFS/OWL vocabularies Oracle has seen on the field. Transitive properties, same as and inverse functional properties, among others, are indispensable.

- rdfs:domain

- rdfs:range

- rdfs:subClassOf

- rdfs:subPropertyOf

- owl:equivalentClass

- owl:equivalentProperty

- owl:sameAs

- owl:inverseOf

- owl:TransitiveProperty

- owl:SymmetricProperty

- owl:FunctionalProperty

- owl:InverseFunctionalProperty

One can think of the above set as a minimum requirement that meets the needs of applications Oracle is dealing with. This set happens to be a subset of pD* vocabulary. Regarding the relationships between this set and other OWL fragments, it seems that the above vocabulary set is not covered by DL-Lite (missing transitive properties for example) or EL++ (missing functional/inverse functional properties for example). Carsten has helped a lot in clarification (many thanks!). Ian and Boris also have been really helpful and they kindly pointed me to the DLP paper and later the DLP section on W3C fragment wiki page which seems to be a better fit in the sense that all the above constructs are covered.


For the syntax specification of the above vocabulary set (please view in HTML mode), I shamelessly took the following from the (WWW03 Grosof/Horrocks/Volz/Decker's) DLP paper and modified a tiny bit. The HTML-based math symbols are from http://barzilai.org/math_sym.htm.

- rdfs:domain                T ⊆ ∀P‾.C

- rdfs:range                  T ⊆ ∀P.C

- rdfs:subClassOf           C1 ⊆ C2

- rdfs:subPropertyOf       P1 ⊆ P2

- owl:equivalentClass     C1 ≡ C2

- owl:equivalentProperty   P1 ≡ P2

- owl:sameAs                 {i1} ≡ {i2}

- owl:inverseOf               P1 ≡ P2‾

- owl:TransitiveProperty         P+ ⊆ P

- owl:SymmetricProperty          P ≡ P‾

- owl:FunctionalProperty          T ⊆ ≤1 P

- owl:InverseFunctionalProperty   T ⊆ ≤1 P‾

- i type C         i : C

- i1 P i2           <i1, i2> : P

The relevant entailment rules from the pD* paper can be used for inference for an ontology based on the above vocabulary set. Obviously, the above vocabulary set is very simple. It is nonetheless very useful in practice. And I want to add that it is non-trivial to support it efficiently in a large scale.

Zhe Wu 10:10am, 24 Jan 2008