# FullSemanticsSubPropertyChains

WORK IN PROGRESS

The OWL 2 Full semantics of Sub Property Chains.

Note: There is a significant issue with the current RDF syntax. This will have to be discussed by the WG. An alternative syntax is proposed in the #Considerations.

## Sub Property Chains

### Syntax

``` x rdfs:subPropertyOf q
x owl:propertyChain SEQ(p_1 ... p_n)
```

### Semantics

Definition:

``` EXT_I(p_1) ∘ EXT_I(p_2) := { (x,y) | ∃ z: (x,z) ∈ EXT_I(p_1) ∧ (z,y) ∈ EXT_I(p_2) }
```

Axiomatic triples, derived from RDFS:

``` rdfs:subPropertyOf rdf:type rdf:Property
rdfs:subPropertyOf rdfs:domain rdf:Property
rdfs:subPropertyOf rdfs:range rdf:Property
```

Axiomatic triples for new vocabulary:

``` owl:propertyChain rdf:type rdf:Property
owl:propertyChain rdfs:domain rdfs:Resource
owl:propertyChain rdfs:range rdf:List
```

Note: The domain of owl:propertyChain has been deliberately chosen to be rdfs:Resource. The idea is that the LHS is not the property chain, but just a glue individual.

Main semantic conditions:

``` IF
l is a sequence of p_1, ..., p_n over IOT,
(x,q) ∈ EXT_I(S_I(rdfs:subPropertyOf)),
(x,l) ∈ EXT_I(S_I(owl:propertyChain))
THEN
q ∈ IOOP,
p_1, ..., p_n ∈ IOOP,
EXT_I(p_1) ∘ ... ∘ EXT_I(p_n) ⊆ EXT_I(q)
```
``` IF
l is a sequence of p_1, ..., p_n over IOOP,
q ∈ IOOP,
EXT_I(p_1) ∘ ... ∘ EXT_I(p_n) ⊆ EXT_I(q)
THEN ∃ x:
x ∈ IOT,
(x,q) ∈ EXT_I(S_I(rdfs:subPropertyOf)),
(x,l) ∈ EXT_I(S_I(owl:propertyChain))
```

Note, this splitting of the main semantic condition into two is necessary, since the two directions of the semantic condition are asymmetric. The second semantic condition asserts the existence of some individual x, which is the "glue node" for the sub property chain expression.

## Considerations

### General considerations

• The semantics here are generally in line with the OWL 2 DL semantics.
• It has been decided to postpone the issue whether there should be Sub Data Property Chains or not. Thus, currently there only exist *object* chains. This has, of course, only a minor effect on Full, since in Full every data property is an object property.
• It has been discussed by the WG (Issue 8) whether Full should allow more general versions of sub property chains, such as property chains in the super property position, or even unrestricted property chains.
• IMO, this should *not* be done.
• There is no precedence in OWL 1 Full for language features, which are in the Full version only.
• Generally, the idea is that Full and DL share the same language features and be semantically as similar as possible, where Full is an extention of RDFS.
• Unrestricted property chains are only possible with the current RDF syntax. With another syntax, they might not be possible to define.

### Considerations about the semantics

It would not be the same to define the semantics as

``` EXT_I(p_1 ∘ ... ∘ p_n) ⊆ EXT_I(q)
```

This would demand that there is some property r := p_1∘...∘p_n, because the EXT_I(.) operator is only applicable on property resources. The actual semantics does not demand the existence of such a property.

There are now axiomatic triples for domain and range of owl:propertyChain

### Comprehension Principle

There is some similarity between sub property chains and the sequence based axioms, e.g. owl:intersectionOf. This similarity suggests to have a comprehension principle for sub property chains.

But for what kind of object should such a comprehension principle make an existential assertion? The following sounds suggestive:

For a given property q and a sequence of properties p_1, ..., p_n demand the existence of a property p, which has a property extension equal to EXT_I(p_1) o ... o EXT_I(p_n), and which is a sub property of q.

Problems:

• It does not seem to be possible to express this by the existing means. In particular, in a sub property expression there is no representation of such a property.
• Demanding the existence of a property entity with such an extension seems to be a very strong demand.
• We would suddenly start to talk about real property chains instead of sub property chains.

Conclusion: A comprehension principle is neither possible nor desirable.

### Problems with current Syntax

The current syntax doesn't make clear that we are talking about sub object property chains.

The current syntax is a multi-triple axiom. This would not be necessary: One could have a single-triple axiom of the form

``` "q owl:subsumesPropertyChain SEQ(p_1 ... p_n)"
```

This is more compact, and single triple axioms should generally be preferred, if technically possible.

The current syntax with the "helper variable" needs a semantic condition with an existential quantor, or alternatively a comprehension principle. It would be better if there was a simple IFF semantic condition. This is possible again with the syntax

``` "q owl:subsumesPropertyChain SEQ(p_1 ... p_n)"
```

Now, the following semantic condition can be defined:

``` IF
l is a sequence of p_1, ..., p_n over IOT
THEN
(q,l) ∈ EXT_I(S_I(owl:subsumesPropertyChain))
IF AND ONLY IF
q ∈ IOOP,
p_1, ..., p_n ∈ IOOP,
EXT_I(p_1) ∘ ... ∘ EXT_I(p_n) ⊆ EXT_I(q)
```

The current syntax produces additional undesired "artifact" meaning:

• "There exists some property x, which is a sub property of p, and which stands in a propertyChain relationship to some sequence.
• It is important to understand that the LHS of this axiom does *not* represent the property which is the property chain. The variable 'x' is just a helper variable, because we have a multi-triple axiom.
• The additional existence statement is pretty strong: From a sub property chain axiom one normally shouldn't be able to conclude the existence of some sub property. There isn't necessarily a property which has a property extention that equals 'EXT_I(p_1) ∘ ... ∘ EXT_I(p_n)'
• The problem exists, because the rdfs:subPropertyOf syntax is overloaded to also be a part of the more general sub property chain syntax.

It might be of advantage to have a distinct expression for sub property chains

• Although sub property chains are extentions to sub property axioms, it might be unwise to express the more general language constructs in terms of the more restricted one.
• The 'owl:propertyChain' might give the wrong impression that there may be less restricted property chains. It seems to be better to regard sub property chains as a distinct language construct. If there should be "real" property chains in future versions of OWL (which is rather unlikely), having a dedicated encoding for them might make more sense. (This new encoding may then cover the more restrictive sub property chains.)

### Alternative Syntaxes

``` q owl:subsumesPropertyChain SEQ(p_1 ... p_n)
```

This is the most compact form. It is a single-triple axiom, and should be preferred, IMO.

It has been suggested that this is a confusing property name, since it suggests that the LHS is the sub property chain of the RHS (analog to rdfs:subPropertyOf).

``` _:x owl:subPropertyChainOf q
_:x owl:propertyChain SEQ(p_1 ... p_n)
```

This is a shadow variant of the current syntax. It doesn't produce the semantic artifacts described above. However, the problem with the existential variable in the semantic condition holds, too.

``` _:x rdf:type owl:SubPropertyChain
_:x owl:superProperty q
_:x owl:propertyChain SEQ(p_1 ... p_n)
```

This is more in the style of a restriction expression. Perhaps exaggerated.