Object Membership
The Ontological Structure
As an appendix to
[]
and
[],
a description of object membership is presented as it applies to ontologies.
Considered are RDF Schema and OWL 2 Full.
Preface
Author
 Ondřej Pavlata 
 Jablonec nad Nisou 
 Czech Republic 



Document date
Initial release  December 12, 2012 
Last major release 
December 12, 2012 
Last update  March 12, 2015 
(see Document history)

Warning

This document has been created without any prepublication review
except those made by the author himself.
Table of contents
Overview
In this document,
we first provide a partial abstract specification of RDF Schema and OWL 2.
The specification results in a formal structure that
induces a core
structure (Ō, ϵ, ≤, r, c, p)
between (primary) objects Ō
such that ϵ and ≤
have the usual meaning of instanceof and inheritance
relations,
respectively,
r is an inheritance root,
c is a metaclass root,
and
p is an additional distinguished object.
Subsequently,
we define a generalization of the S1_{ϵ} structure,
the canonical structure (O, ϵ) of object membership.
(∗)
The generalized structure is denoted
S1_{o} and
called the ontological structure of object membership.
We then show that the restriction to primary objects,
S1_{o}.pr,
is a specialization of the core structure of RDF Schema.
Moreover,
the additional constraints
that are not guaranteed in RDF Schema,
can be considered to be satisfied by most reasonable
RDFS structures.
In particular,
the builtin structures of RDF Schema and OWL 2 satisfy
all the axioms of
S1_{o}.pr structures.
Preliminaries
Relational indiscernibility
Let R be a (binary) relation on a set X
(thus R ⊆ X × X).
We say that elements a and b of X
are indiscernible w.r.t. R
if for every x ∈ X ∖ {a,b} the following are satisfied:
 (1)
a R x iff b R x, i.e.
a and b have have equal images under R ∖ X.∆.
 (2)
x R a iff x R b i.e.
a and b have have equal
(preimages)
 (3)
a R a iff b R b.
Equivalently, the map f = X.∆ ∖ {(a,a), (b,b)} ∪ {(a,b),(b,a)}
(f just exchanges a and b)
is an automorphism of (X,R).
Obviously, indiscernibility is an equivalence, inducing a partition of X
into blocks.
Given a system (X, R) of relations on a set X
(so that R ⊆ ℙ(X × X))
elements a and b of X
are indiscernible w.r.t. R if they are indiscernible w.r.t. R
for each R ∈ R.
For a relational system (X, R) we
distinguish the following finiteness conditions:


(IND~F~1) 
(X, R) has only
finitely many blocks of indiscernibility.
(I.e. the quotient graph is finite).

(IND~F~2) 
The quotient graph
of (X, R) is finite and its restriction to the set of infinite blocks acyclic.

(IND~F~3) 
(X, R) has only
finitely many blocks of indiscernibility and at most one of them is infinite.

(IND~F~3') 
(X, R) has a cofinite block of indiscernibility.

(IND~F~3'') 
There is a cofinite subset of X
whose elements are mutually indiscernible w.r.t. R.

Proposition:

For a relational system (X, R), the following are equivalent:

(IND~F~1)

R is finite and every R has only
finitely many blocks of indiscernibility.

If (X, R) satisfies (IND~F~2)
(and in particular, if it satisfies (IND~F~3))
then
for every relation R ∈ R,
acyclic paths in R are of limited length,
i.e. there exists n > 0
such that every path
 x_{0} R x_{1} R x_{2} … x_{n1} R x_{n}
has a cycle (i.e. x_{i} = x_{j} for some i ≠ j).

Conditions
(IND~F~3),
(IND~F~3') and
(IND~F~3'')
are equivalent.

If (IND~F~3') is satisfied and
X is infinite then there is exactly one cofinite block of
indiscernibility.
RDFS structures
We describe RDFS structures
–
i.e. structures expressed in the RDF Schema
[]
[]
–
in three abstraction refinement steps:

RDFS_{1} structures capture all the information related
to object membership.

RDFS_{2} structures contain the builtin RDFS structure
(with all axiomatic triples).

RDFS_{3} structures distinguishes literals in their embedding
into blank nodes.
RDFS_{3} structures capture most of the features of
RDFS structures.
The not covered features include the following:

Typing of literals.

Datatype entailment.
RDFS_{1}: The core structure of RDF Schema
An RDFS_{1} structure is a structure
(Ō, Ψ,
‹ϵ›, ‹≤_{C}›, ‹≤_{P}›, ‹ϵ_{d}›, ‹ϵ_{r}›,
r, c, p)
where

Ō is set of objects.

Ψ is a subset of
Ō × Ō × Ō
(= Ō^{3}).

The remaining 8 symbols denote distinguished objects with the following terminology:
Object 
RDFS name 
Terminology 
‹ϵ› 
rdf:type 
instanceof
(inverse: (a)typeof, (a)classof) 
‹≤_{C}› 
rdfs:subClassOf 
subclassof (inverse: superclassof) 
‹≤_{P}› 
rdfs:subPropertyOf 
subpropertyof (inverse: superpropertyof) 
‹ϵ_{d}› 
rdfs:domain 
domainrestrictedby
(inverse: domainrestrictorof) 
‹ϵ_{r}› 
rdfs:range 
rangerestrictedby
(inverse: rangerestrictorof) 
r 
rdfs:Resource 
resource classifier (inheritance root) 
c 
rdfs:Class 
class classifier (metaclass root / instance root) 
p 
rdf:Property 
property classifier 
Additional notation and terminology is applied:

Elements of Ō^{3} are triples of objects.
For a triple t = (s,p,o),
 s is the subject of t,
 p is the predicate of t,
 o is the object of t.
We denote .s, .p, and .o
the respective projections from
Ō^{3} to Ō.

We also denote .so the projection
from Ō^{3} to Ō^{2}
defined by
(s,p,o).so = (s,o).

The relational extent of an object p
with respect to a triples set X ⊆ Ō^{3},
is denoted p.rel(X) and defined by

p.rel(X) = {(s,o)  (s,p,o) ∈ X}.

We will be mostly concerned with triples from Ψ,
so that we abbreviate p.rel = p.rel(Ψ), i.e.

p.rel = {(s,o)  (s,p,o) ∈ Ψ}.

Using the image notation, Ō.rel denotes the
relational system of Ψ.

For a triple t = (s,p,o) we denote t.so = (s,o).
Therefore,
Ψ.so denotes the projection of Ψ to
the corresponding subjectobject pairs.

For each of the 5 symbols of the form
‹s› denoting a distinguished object x
we introduce the relational symbol s
that denotes the relation x.rel.
For example, ϵ is a relation between objects such that

x ϵ y iff (x,y) ∈ ‹ϵ›.rel
(that is, iff (x,‹ϵ›,y) ∈ Ψ).

Terminology introduced for ‹s›symbols applies to
their respective ssymbols.
For example, ϵ is the instanceof relation.
If x ϵ y then x is an instance of y.

For an object x, we write x.϶ / x.ϵ
for the preimage / image of {x} under ϵ.
In particular x.϶ is the set of all instances of x.

We use similar notation for the ϵ_{d} and ϵ_{r} relations.
For an object x,
elements of the set x.ϵ_{d} (resp. x.ϵ_{r})
are domainrestrictors (resp. rangerestrictors)
of x.

We write x.↧_{C} / x.↥_{C}
for the preimage / image of {x} under ≤_{C}.
Similar notation is applied for sets of objects.

Resources are elements of r.϶, i.e. instances of r.

Classes are elements of c.϶, i.e. instances of c.

Properties are elements of p.϶, i.e. instances of p.

Helix classes are elements of c.↥_{C},
i.e. superclasses of c.

Metaclasses are elements of c.↧_{C},
i.e. subclasses of c.
The structure is subject to the following axioms:
 (RDFS_{1}~1)
 (a)
Ō = Ψ.s ∪
Ψ.p ∪
Ψ.o,
i.e. every object appears in Ψ.
 (b)
The 8 distinguished objects are pairwise distinct.
 (RDFS_{1}~2)
The following 10 triples are in Ψ
(they are axiomatic triples
[]):
Axiom 
Consequence entailed by rdfs2 / rdfs3 
Description 
‹ϵ› ϵ_{d} r 
(ϵ) ⊆ (r.϶) × (c.϶) 
Only classes can have instances.

‹ϵ› ϵ_{r} c 
‹≤_{C}› ϵ_{d} c 
(≤_{C}) ⊆ (c.϶) × (c.϶) 
The subclassof relation is only defined between classes.

‹≤_{C}› ϵ_{r} c 
‹≤_{P}› ϵ_{d} p 
(≤_{P}) ⊆ (p.϶) × (p.϶) 
The subpropertyof relation is only defined between properties. 
‹≤_{P}› ϵ_{r} p 
‹ϵ_{d}› ϵ_{d} p 
(ϵ_{d}) ⊆ (p.϶) × (c.϶) 
Only properties can have domainrestrictors. 
‹ϵ_{d}› ϵ_{r} c 
Only classes can be domainrestrictors. 
‹ϵ_{r}› ϵ_{d} p 
(ϵ_{r}) ⊆ (p.϶) × (c.϶) 
Only properties can have rangerestrictors. 
‹ϵ_{r}› ϵ_{r} c 
Only classes can be rangerestrictors. 
 (RDFS_{1}~3)
The following RDFS rules
[]
apply:
Rule name 
Convenient expression 
Description 
Triple inference 
RDFS 
OWL 2 
rdfs2 
prpdom 
x ϵ_{d} y implies dom(x.rel) ⊆ y.϶ 

x ϵ_{d} y, a x ? 
→ 
a ϵ y 
rdfs3 
prprng 
x ϵ_{r} y implies rng(x.rel) ⊆ y.϶ 

x ϵ_{r} y, ? x a 
→ 
a ϵ y 
rdfs4a 

Ψ.s ⊆ r.϶ 
The subject of every triple is a resource. 
x ? ? 
→ 
x ϵ r 
rdf1 

Ψ.p ⊆ p.϶ 
The predicate of every triple is a property. 
? x ? 
→ 
x ϵ p 
rdfs4b 

Ψ.o ⊆ r.϶ 
The object of every triple is a resource. 
? ? x 
→ 
x ϵ r 
rdfs7 
prpspo1 
x ≤_{P} y implies x.rel ⊆ y.rel 

x ≤_{P} y, a x b 
→ 
a y b 
rdfs8 

c.϶ ⊆ r.↧_{C} 
All classes are subclasses of r.

x ϵ c 
→ 
x ≤_{C} r 
rdfs9 
caxsco 
(ϵ) ○ (≤_{C}) ⊆ (ϵ) 
Instances of a class y are (among) instances of every superclass of y.

x ϵ y, y ≤_{C} z 
→ 
x ϵ z 
rdfs10 

≤_{C} is reflexive on c.϶ 
The subclassof relation, ≤_{C}, is a preorder on classes. 
x ϵ c 
→ 
x ≤_{C} x 
rdfs11 
scmsco 
≤_{C} is transitive 
x ≤_{C} y, y ≤_{C} z 
→ 
x ≤_{C} z 
rdfs5 
scmspo 
≤_{P} is transitive 
The subpropertyof relation, ≤_{P},
is a preorder on properties. 
x ≤_{P} y, y ≤_{P} z 
→ 
x ≤_{P} z 
rdfs6 

≤_{P} is reflexive on p.϶ 
x ϵ p 
→ 
x ≤_{P} x 
 (RDFS_{1}~4)
The following extended RDFS rules
[]
apply:
Rule name 
Convenient expression 
Description 
Triple inference 
RDFS 
OWL 2 
ext1 
scmdom1 
(ϵ_{d}) ○ (≤_{C}) ⊆ (ϵ_{d}) 
Superclasses of domainrestrictors of x are domainrestrictors of x.

x ϵ_{d} y, y ≤_{C} z 
→ 
x ϵ_{d} z 
ext2 
scmrng1 
(ϵ_{r}) ○ (≤_{C}) ⊆ (ϵ_{r}) 
Superclasses of rangerestrictors of x are rangerestrictors of x.

x ϵ_{r} y, y ≤_{C} z 
→ 
x ϵ_{r} z 
ext3 
scmdom2 
(≤_{P}) ○ (ϵ_{d}) ⊆ (ϵ_{d}) 
Domainrestrictors of superproperties of x are domainrestrictors of x.

x ≤_{P} y, y ϵ_{d} z 
→ 
x ϵ_{d} z 
ext4 
scmrng2 
(≤_{P}) ○ (ϵ_{r}) ⊆ (ϵ_{r}) 
Rangerestrictors of superproperties of x are rangerestrictors of x.

x ≤_{P} y, y ϵ_{r} z 
→ 
x ϵ_{r} z 
ext5 

‹ϵ›.ϵ_{d} ⊆ r.↥_{C}

Domainrestrictors of ‹ϵ› are equivalent to r.

‹ϵ› ϵ_{d} x 
→ 
r ≤_{C} x 
ext6 

‹≤_{C}›.ϵ_{d} ⊆ c.↥_{C}

Domainrestrictors of ‹≤_{C}› are superclasses of c.

‹≤_{C}› ϵ_{d} x 
→ 
c ≤_{C} x 
ext7 

‹≤_{P}›.ϵ_{d} ⊆ p.↥_{C}

Domainrestrictors of ‹≤_{P}› are superclasses of p.

‹≤_{P}› ϵ_{d} x 
→ 
p ≤_{C} x 
ext8 

‹≤_{C}›.ϵ_{r} ⊆ c.↥_{C}

Rangerestrictors of ‹≤_{C}› are superclasses of c.

‹≤_{C}› ϵ_{r} x 
→ 
c ≤_{C} x 
ext9 

‹≤_{P}›.ϵ_{r} ⊆ p.↥_{C}

Rangerestrictors of ‹≤_{P}› are superclasses of p.

‹≤_{P}› ϵ_{r} x 
→ 
p ≤_{C} x 
 (RDFS_{1}~5)
The finite discernibility condition
(IND~F~3)
applies:

The relational system Ō.rel
has a cofinite block of indiscernibility.
As a consequence, acyclic chains in ϵ
(or in ≤) are of limited length.

Boundedness of acyclic chains in ϵ can also be ensured by finiteness
of c.϶ ∖ p.϶, i.e.

there are only finitely many classes that are not properties.
This condition is valid in
RDFS_{2} structures
(and thus in
OWL2_{1} structures).
However, we prefer to use the notion of indiscernibility
due to the descriptivness it provides.

In the specification
[],
rules ext5–ext9 are expressed with the composition
(≤_{P}) ○ (ϵ_{d}) (resp. (≤_{P}) ○ (ϵ_{r}))
instead of just ϵ_{d} (resp. ϵ_{r}).
However, due ext3 and ext4 (and by reflexivity of ≤_{P}),
the composition with ≤_{P} is redundant.
Proposition:

p ϵ c.

Every object is a resource, Ō = r.϶.

In rdfs8, rdfs9, and ext1–ext9, set inclusion, ⊆,
can be equivalently replaced by equality, =.
In particular:

(ϵ) ○ (≤_{C}) = (ϵ).

(≤_{P}) ○ (ϵ_{d}) ○ (≤_{C}) = (ϵ_{d}).

(≤_{P}) ○ (ϵ_{r}) ○ (≤_{C}) = (ϵ_{r}).
Proof:

Since Ψ is nonempty we have
∅ ≠ Ψ.p ⊆ p.ϵ (by rdf1).
Thus p ∈ rng(ϵ).
Using ‹ϵ› ϵ_{r} c and rdfs3, we have
rng(ϵ) ⊆ c.϶,
thus p ϵ c.

If x ∈ Ψ.s (resp. x ∈ Ψ.o)
then x ϵ r by rdfs4a (resp. rdfs4b).
If x ∈ Ψ.p then x ϵ p by rdf1.
Since p is a class due to the previous proposition,
it is also a subclass of r (by rdfs8).
We have
By rdfs9, x ϵ r.
RDFS_{1} closure
We say (write) that a set
X ⊆ Ō^{3}
of triples is Λ_{1}closed
if the following is satisfied:

All axiomatic triples are in X.

All entailment rules from
(RDFS_{1}~3) and
(RDFS_{1}~4)
are satisfied for X, i.e.
triples inferred from triples from X are in X.
In particular, Ψ is Λ_{1}closed.
Proposition:

Λ_{1}closed sets of triples form a closure system
in (ℙ(Ō^{3}), ⊆).
We use the Λ_{1} symbol for the corresponding closure operator,
i.e.
Λ_{1}(T) is the smallest (w.r.t. set inclusion)
superset of T that is Λ_{1}closed.

Λ_{1} preserves the finiteness condition
(RDFS_{1}~5),
i.e.
given a set T of triples,
if is a cofinite set X of objects that are mutually indiscernible
w.r.t. T,
then for some cofinite subset Y of X,
all objects of Y are indiscernible w.r.t. Λ_{1}(T).

Corollary:
Adding finitely many triples to Ψ
and subsequently applying Λ_{1}closure
results in a (new) RDFS_{1} structure.
Proof:

Let Y be the (necessarily cofinite)
subset of X of objects that do not appear as a constant in a triple pattern.
We show that all elements of Y
are mutually indiscernible w.r.t. Λ_{1}(T).
Let a, b be from Y,
p a property and o an objects different
from both a and b.
We should show that

(a,p,o) ∈ Λ_{1}(T) iff (b,p,o) ∈ Λ_{1}(T).

(o,p,a) ∈ Λ_{1}(T) iff (o,p,b) ∈ Λ_{1}(T).

(a,p,a) ∈ Λ_{1}(T) iff (b,p,b) ∈ Λ_{1}(T).
But this follows,
since the entailment rules do not contain a triple pattern
of the form
(x,x,a) or (a,x,x)
(or even (x,x,x)) where x is a variable.
The minimum RDFS_{1} structure
The following diagram shows the minimum RDFS_{1} structure,
entailed by the empty set, i.e.
Ψ = Λ_{1}(∅).
The structure contains exactly the 8 distinguished objects.
The five core relations,
ϵ,
≤_{C},
≤_{P}, ϵ_{d}, ϵ_{r}
are displayed in their respective reductions,
A, C, P, D, R.

ϵ is obtained as (≤_{C}) ○ A ○ (≤_{C}).
(A = p.϶ × {p} ∪ {(r,c)}.)

≤_{C} is obtained
as the reflexive transitive closure of (c.϶, C).
(C = {p, c} × {r}.)

≤_{P} is obtained
as the reflexive transitive closure of (p.϶, P).
(P = ∅.)

ϵ_{d} is obtained as (≤_{P}) ○ D ○ (≤_{C}).
(D = {‹≤_{P}›, ‹ϵ_{d}›, ‹ϵ_{r}›} × {p} ∪
{(‹ϵ›,r), (‹≤_{C}›,c)}.)

ϵ_{r} is obtained as (≤_{P}) ○ R ○ (≤_{C}).
(R = {‹≤_{C}›, ‹ϵ_{d}›, ‹ϵ_{r}›} × {c} ∪
{(‹ϵ›,c), (‹≤_{P}›,p)}.)
RDFS_{2}: A superstructure of the builtin RDFS structure
An RDFS_{2} structure is an
RDFS_{1} structure such that
the following is satisfied:
 (RDFS_{2}~1)
The structure has a builtin substructure shown by the diagram below.
 (RDFS_{2}~2)
Additional entailment rules
[]
are applied:
Rule name 
Convenient expression 
Description 
Triple inference 
rdfs12 
CMP .϶ ⊆ m .↧_{P} 
Instances of rdfs:ContainerMembershipProperty
are subproperties of rdfs:member . 
x ϵ CMP 
→ 
x ≤_{P} m 
rdfs13 
D .϶ ⊆ L .↧_{C} 
Instances of rdfs:Datatype
are subclasses of rdfs:Literal . 
x ϵ D 
→ 
x ≤_{C} L 
The builtin structure is the minimum RDFS_{2} structure.
The structure contains:

13 classes, including the 3 classes from the RDFS_{1} structure
(r, c, p).

16 properties other than instances of
rdfs:ContainerMembershipProperty
(CMP
),
including the 5 properties from the RDFS_{1} structure,

infinitely many properties
rdf:_1
, rdf:_2
, …,
which are all instances of CMP
,

1 terminal object,
rdf:nil
, which is an instance of rdf:List
.



Classes:
rdfs:Resource (inheritance root)
rdfs:Class (metaclass root)
rdfs:Datatype (metaclass)
rdfs:Literal
rdf:XMLLiteral
rdf:Statement
rdf:List
rdfs:Container
rdf:Bag
rdf:Seq
rdf:Alt
rdf:Property (the p class)
rdfs:ContainerMembershipProperty

Properties:
rdfs:seeAlso
rdfs:isDefinedBy
rdfs:member
rdf:_1
rdf:_2 , …

rdf:type
rdfs:subClassOf
rdfs:subPropertyOf
rdfs:domain
rdfs:range

rdf:subject
rdf:predicate
rdf:object

rdf:value
rdfs:label
rdfs:comment
rdf:first
rdf:rest



Missing arrows for ϵ_{d} / ϵ_{r}
indicate that the only respective domain or range restrictor
is the inheritance root, r.

It is correct to state that the builtin structure is the minimum
RDFS_{2} structure
since the following are satisfied:

The structure is an RDFS_{1} structure.
In particular, the finiteness condition is satisfied:
the infinitely many properties
rdf:_1
, rdf:_2
, …,
form a cofinite block of indiscernibility.
(Moreover the properties do not appear as objects of nonloop triples.)

Condition (RDFS_{2}~2) is satisfied.
RDFS_{2} closure
Similary as with RDFS_{1} structures,
a set
X ⊆ Ō^{3}
of triples is Λ_{2}closed
if the following is satisfied:

All triples from the builtin RDFS_{2} structure are in X.

All entailment rules from
(RDFS_{1}~3),
(RDFS_{1}~4) and
(RDFS_{2}~2)
are satisfied for X.
Proposition:

Any Λ_{2}closed set of triples is Λ_{1}closed.

Λ_{2}closed sets of triples form a closure system;
let Λ_{2} be the corresponding closure operator.

Λ_{2} preserves finite discernibility
(IND~F~3).

Λ_{2} and Λ_{1} preserve the following finiteness condition:

If the range of
X.so ∖ Ō.∆ is finite
then so is the range of
Λ_{2}(X).so ∖ Ō.∆.

Corollary: For every RDFS_{2}
structure
generated by a finite set of triples (via Λ_{2})
the range of Ψ.so ∖ Ō.∆ is finite,
i.e.
there are only finitely many
nonleaf
objects o such that

(s,p,o) ∈ Ψ
for some objects s, p such that s ≠ o.
Proof:

For every entailment rule T → t = (s,p,o),
either of the following is satisfied:
 (a)
o ∈ T.o.
 (b)
o ∈ {r, p}.
 (c)
s = o.
If the rule is applied to a set X of triples,
then in case (a) and (b) the range of X.so
does not increase
(is the same as the range of (X ∪ {t}).so).
In the (c) case,
t is a loop
triple, (o,p,o),
which is excluded from the finiteness constraint.
RDFS_{3}: Literals and blank nodes
An RDFS_{3} structure is a
RDFS_{2} structure
equipped with (B, L.b) where

B is a set of objects called blank nodes or bnodes.

L.b is a set of objects called literal bnodes.
The structure satisfies the following conditions:


(RDFS_{3}~1) 
Blank nodes cannot appear as the predicate of a triple, i.e.

(RDFS_{3}~2) 
Literal bnodes are blank nodes, L.b ⊆ B.

(RDFS_{3}~3) 
Literal bnodes are instances of L , i.e.
the following RDFS entailment rule
[]
applies:
Rule name 
Convenient expression 
Description 
Triple inference 
rdfs1 
L.b ⊆ L .϶ 
Literal bnodes are instances of rdfs:Literal . 
x ∈ L.b,
? ? x 
→ 
x ϵ L 
The Λ_{3} closure operator is then defined by
Λ_{3}(X) =
Λ_{2}(X ∪
((X.o ∩ L.b) × {‹ϵ›} × {L })).

(RDFS_{3}~4) 
All triples having a literal bnode as the subject are inferred,
i.e.

Ψ = Λ_{3}(Ψ ∖
(L.b × Ō × Ō)).

(RDFS_{3}~5) 
The builtin structure, Λ_{3}(∅),
does not contain any blank nodes.
(In particular, Λ_{2}(∅) = Λ_{3}(∅).)


The specification of RDF Schema
[]
introduces two dual sets of entities:
 The set L of literals.
 The set L.b of their blank node counterparts.
There is onetoone mapping, .b, between literals and their counterparts,
which assigns
each literal x an object, x.b,
called the blank node allocated to x.
Literals are disjoint with objects,
L ∩ Ō = ∅.
Together with objects, they form the set of nodes.
Objects that are not blank nodes are URI names.
The set Ψ,
as specified in []
(where it is called RDF graph),
is allowed to also contain literals as the triple's object, i.e.

Ψ ⊆
Ō × (Ō ∖ B) ×
(Ō ⊎ L).
The
literal generalization (lg) and
literal instantiation (gl) rules
[] assert that
for every objects a, b and every literal x,

(a,b,x) ∈ Ψ iff
(a,b,x.b) ∈ Ψ.

The RDF Schema specification
does not introduce any restrictions as to the range of the core 5 properties
with respect to literals. For example,

ex:x rdf:type "5"
(x ϵ "5", x is an instance of "5"
)
is a valid RDF triple.
(In contrast,
"5" rdf:type rdfs:Literal
is not a valid RDF triple
[].)
OWL2 structures
In this section,
the RDFS_{3} structure
is further extended to capture object membership, ϵ,
in OWL 2 Full
[]
[].
OWL2_{1}: A superstructure of the builtin OWL 2 structure
An OWL2_{1} structure is an
RDFS_{3} structure such that
the following is satisfied:
 (OWL2_{1}~1)
The structure has a builtin substructure shown by the diagram below.
 (OWL2_{1}~2)
Additional entailment rules
[]
are applied:
Rule name 
Convenient expression 
Description 
Triple inference 
scmcls 
c.϶ ⊆ N .↥_{C} 
Every class is an ancestor of the bottom class owl:Nothing . 
x ϵ c 
→ 
N ≤_{C} x 
 (OWL2_{1}~3)
The
N
class (owl:Nothing
) has no instances,
N
.϶ = ∅.
The builtin structure is the minimum OWL_{1} structure.
In addition to the builtin
RDFS_{2} structure,
the structure contains:

58 classes:

26 classes whose name starts with
owl:
followed by an upper case letter.

2 classes with an
owl:
prefix
followed by a lower case letter: owl:rational
, owl:real
.
(∗)

1 class prefixed
rdf:
– rdf:PlainLiteral
.

29 classes prefixed
xsd:
,
with one distinguished class xsd:nonNegativeInteger
(which is the smallest rangerestrictor of 6 cardinality restriction properties).
(∗)
The latter 2 + 1 + 29 = 32 classes are datatypes – instances of
rdfs:Datatype
.
There are 34 builtin datatypes in total.
The remaining 2 classes from the RDFS_{2} structure
are rdfs:Literal
and rdf:XMLLiteral
.
(However, the rdfs:Literal
class is made an instance of rdfs:Datatype
by an additional axiomatic triple, see notes below).

62 properties:

51 properties with
owl:
prefix.

11
facet names
– rdf:langRange
and 10 xsd:
prefixed names.
The structure
(Ō, ϵ, ≤_{C}, ≤_{P}, ϵ_{d}, ϵ_{r})
is obtained as follows:

The (unified) inheritance, ≤,
(equal to Ō.∆ ∪ (≤_{C}) ∪ (≤_{P}))
is the reflexive transitve closure of green lines
(directed upwards whenever no arrow head is indicated).

≤_{P} is the restriction of ≤ to properties (in green).

≤_{C} is the restriction of ≤ to classes
(which are in blue, brown or orange).
In contrast to the builtin
RDFS_{2} structure,
≤_{C} is not antisymmetric. There are 4 equivalent pairs:

rdfs:Resource
↔ owl:Thing
.

rdfs:Class
↔ owl:Class
.

rdfs:Datatype
↔ owl:DataRange
.

rdf:Property
↔ owl:ObjectProperty
.

ϵ is obtained as (≤) ○ A ○ (≤),
where
A is given by dashed dark blue arrows plus all imaginary arrows from
a property to p.

ϵ_{d} (resp. ϵ_{r})
is obtained as (≤_{P}) ○ R ○ (≤_{C})
where
R is given by brown arrows whose tail is on the left side (resp.right side)
of the source property
plus all imaginary arrows from a property to r.
(Therefore,
rdfs:Resource
and owl:Class
are domain and range restrictors
of every property.)




OWL Classes:
owl:AllDifferent
owl:AllDisjointClasses
owl:AllDisjointProperties
owl:Annotation
owl:AnnotationProperty
owl:AsymmetricProperty
owl:Axiom
owl:Class (equivalent to c)
owl:DataRange (deprecated, equivalent to D )
owl:DatatypeProperty
owl:DeprecatedClass
owl:DeprecatedProperty
owl:FunctionalProperty
owl:InverseFunctionalProperty
owl:IrreflexiveProperty
owl:NamedIndividual
owl:NegativePropertyAssertion
owl:Nothing
owl:ObjectProperty (equivalent to p)
owl:Ontology
owl:OntologyProperty
owl:ReflexiveProperty
owl:Restriction
owl:SymmetricProperty
owl:Thing (equivalent to r)
owl:TransitiveProperty

OWL Properties:
owl:versionInfo
owl:deprecated
owl:imports
owl:versionIRI
owl:backwardCompatibleWith
owl:incompatibleWith
owl:priorVersion
owl:cardinality
owl:maxCardinality
owl:minCardinality
owl:qualifiedCardinality
owl:maxQualifiedCardinality
owl:minQualifiedCardinality
owl:allValuesFrom
owl:someValuesFrom
owl:onProperty
owl:onProperties
owl:onDataRange
owl:onClass
owl:intersectionOf
owl:oneOf
owl:unionOf
owl:disjointUnionOf
owl:hasKey
owl:complementOf
owl:disjointWith
owl:datatypeComplementOf
owl:onDatatype

owl:annotatedProperty
owl:annotatedSource
owl:annotatedTarget
owl:sameAs
owl:differentFrom
owl:equivalentProperties
owl:equivalentClasses
owl:sourceIndividual
owl:targetIndividual
owl:topObjectProperty
owl:bottomObjectProperty
owl:topDataProperty
owl:bottomDataProperty
Facet Names:
rdf:langRange
xsd:length
xsd:maxExclusive
xsd:maxInclusive
xsd:maxLength
xsd:minExclusive
xsd:minInclusive
xsd:minLength
xsd:pattern


 (∗)
The set of builtin classes generated by the RDFS and OWL 2 RL generator service
[]
differs as follows:
 The
owl:real
datatype is not present
in [].
 On the other hand,
there are 2 additional datatypes:
xsd:date
and xsd:time
.

Property groups indicated by gray dashed lines
are blocks of indiscernibility in the builtin structure.
The remaining nongrouped properties are singletons in w.r.t. indiscernibility,
except for
v
,
sA
,
dF
,
aP
,
aS
,
aT
,
tOP
, and
bOP
which are all mutually indiscernible
(they are characterized by not having ingoing or outgoing arrows in the diagram).

The two class groups indicated by green dashed lines are each
a block of indiscernibility up to one missing class:

For datatypes,
XL
should also be grouped.

The
DeP
class is also indiscernible from TP
.

Classes
owl:AnnotationProperty
and owl:OntologyProperty
are minimal in inheritance but have 3 common instances,
which therefore do not have least type.

There are changes in the least type of some objects from
RDFS_{2}:
Object x 
The least type of x 
In RDFS_{2} 
In OWL2_{1} 
rdfs:Literal 
rdfs:Class 
rdfs:Datatype 
rdfs:label ,
rdfs:comment ,
rdfs:seeAlso ,
rdfs:isDefinedBy

rdf:Property 
owl:AnnotationProperty 

After identification of equivalent classes,
inheritance between builtin classes forms a tree.

There are 7 builtin metaclasses (of which only 5 are nonequivalent):

rdfs:Class
,
owl:Class
,
rdfs:Datatype
,
owl:DataRange
,
owl:Restriction
,
owl:DeprecatedClass
, and
owl:Nothing
.
S1_{o}: The ontological structure of object membership
Motivated by RDF Schema and OWL 2 Full,
we introduce a generalization of
S1_{ϵ} structures
that allows the following features:

Objects can have multiple minimum primary containers.
That is,
for an object x, existence of x.class is not guaranteed.

In addition to terminal objects,
there can be other objects (called properties)
that are not descendants of helix objects.

Inheritance does not have to be antisymmetric
– classes and properties can have distinct equivalents.

The only finiteness condition required is that
helix eigenclasses, when ordered by reversed inheritance,
are isomorphic to natural numbers.
An S1_{o} structure
is a structure
(O, ϵ, r, c, p)
where

O is a set of objects,

ϵ
is a relation between objects, called (object) membership,

r is a distinuished object, the inheritance root,

c is a distinuished object, the class classifier
(instance root, metaclass root),

p is a distinuished object, the property classifier.
Terminology, notation and axioms are similar
as for an S1_{ϵ} structure.

We write ϶ for the inverse of ϵ.
We write x.϶ / x.ϵ
for the set of members / containers of x
(the preimage / image of {x} under ϵ).

The inheritance, ≤ is a relation on O
defined by: x ≤ y iff y.ϵ ⊆ x.ϵ.

The usual inheritance ancestor/descendant
terminology and notation (.↥/.↧) applies.

The instanceof relation is the rangerestriction of ϵ to
classes.

The eigenclass map, .ec, is defined
in (S1_{o}~1).

Eigenclasses are elements of O.ec.
The remaining objects are primary.

Helix objects, H,
are objects x such that x ϵ x.
By (S1_{o}~1),
H.ec ⊆ H.

Classes, C,
are primary instances of c.

Properties, P,
are primary instances of p.

Terminals, T,
are primary objects that are neither classes nor properties,
i.e.
O =
T ⊎ P ⊎ C ⊎ O.ec.

Metaclasses are the lower bounds of helix classes,
i.e. objects x such that H ∩ C ⊆ x.↥.
An S1_{o} structure is subject to the following axioms:


(S1_{o}~1) 
Condition (S1_{ϵ}~1) applies,
i.e.
there is a unique map, .ec,
such that (.ec) ○ (≤) = (ϵ).

(S1_{o}~2) 
Inheritance, ≤, is antisymmetric on
T ⊎ O.ec
(but not necessarily on C ⊎ P).

(S1_{o}~3) 
Condition (S1_{ϵ}~3) applies,
i.e. terminals are minimal in inheritance.

(S1_{o}~4) 
 (a)
O.ec ⊎ C ⊆ r.↧, i.e.

O = r.϶ –
every object is a member of r, and

C ⊆ r.↧ –
every class is a descendant of r.
 (b)
r.ec ≠ c.ec, i.e.
r and c are not equivalent in inheritance, ≤.
 (c)
H ∩ C
is totally preordered by ≤.
 (d)
r.ec.↧ = c.↧ ∖ c.↥,
i.e.
r.ec is the only child of c.
 (e)
H ∩ C = c.↥,
i.e. helix classes are exactly the ancestors of c.

(S1_{o}~5⁺) 
Condition (S1_{ϵ}~5⁺) applies:
O.ec ∖ {r.ec} is a downset in inheritance.

(S1_{o}~6) 
Primary objects do not necessarily form a closure system in the inheritance.
Instead, the following weaker condition applies:

C.ec.↥ ⊆ H ∪ H.ec.↧
(= c.↥ ∪ c.↧).
i.e. nonhelix containers of classes are metaclasses.

(S1_{o}~7) 
Condition (S1_{ϵ}~7') applies,
i.e.
memberofinstanceof is the same as
instanceofinstanceof.

(S1_{o}~8) 
Condition (S1_{ϵ}~8) applies,
i.e.
H is not a subset of (C ∖ H).↧.↥.

(S1_{o}~9) 
The set H.ec is upper finite,
i.e. every helix eigenclass has finite number of eigenclass ancestors.

(S1_{o}~10) 
 (a)
p is a class
that is neither a helix class nor a metaclass,
i.e.
p ∈ C ∖ (c.↥ ∪ c.↧).
 (b)
Descendants of properties are properties, P.↧ = P.


Requiring (S1_{ϵ}~5⁺)
instead of (S1_{ϵ}~5)
simplifies condition
(S1_{o}~4)(d)
–
it follows that
r.ec(i) is the only child of c.ec(i1)
for each i > 0.

As to the examples of structures
disallowed by
(S1_{p}~6),
condition (S1_{o}~6)
allows
(ⅰ)
but still disallows (ⅱ).
[]
Proposition:

For an S1_{o} structure
(O, ϵ, r, c, p)
the reduct (O, ϵ)
is an S1_{ϵ} structure if and only if the following are satisfied:

The set P of properties forms an antichain in inheritance.

The eigenclass map, .ec, is injective.

The class map, .class, is defined for every object.

The set C of classes is finite.

For an S1_{ϵ} structure (O, ϵ)
satisfying (S1_{ϵ}~5⁺)
and containing at least one class p not from
c.↥ ∪ c.↧,
the structure (O, ϵ, r, c, p)
is an S1_{o} structure.

Up to equivalence of inheritance roots and of metaclass roots,
the structure is uniquely given by
(O, ϵ, p).
Examples
The following diagrams show parts of an
S1_{o} structure
that is an
RDFS_{2} structure
in eigenclass completion.
In the first diagram,
the terminal object x
is an instance of multiple minimal classes:
A
and B
.
These classes have been created
as instances of the rdfs:Datatype
metaclass, thus, by the rdfs13 entailment rule,
they become descendants of rdfs:Literal
.



 
 r  … 
rdfs:Resource
 c  … 
rdfs:Class
 L  … 
rdfs:Literal
 D  … 
rdfs:Datatype

The following RDF triples have been
added to the builtin structure:
ex:A rdf:type rdfs:Datatype .
ex:B rdf:type rdfs:Datatype .
ex:x rdf:type ex:A, ex:B .


The second diagram contains 5 properties,
i.e. 5 instances of the rdf:Property
class.
Properties a
and b
are equivalent,
since they have been declared as a subproperty of each other.



 
 r  … 
rdfs:Resource
 c  … 
rdfs:Class
 P  … 
rdf:Property

The following RDF triples have been added:
ex:a rdf:type ex:Q .
ex:a rdfs:subPropertyOf ex:b .
ex:b rdfs:subPropertyOf ex:a .
ex:x rdfs:subPropertyOf ex:s .
ex:y rdfs:subPropertyOf ex:s .


S1_{o}.pr: The primary structure
An S1_{o}.pr structure is a structure
(O.pr, ϵ, ≤, r, c, p)
where

O.pr is set of primary objects.

ϵ
is a relation between primary objects,
called (object) membership.

≤
is a relation between primary objects, called inheritance,

r, c and p
are distinguished primary objects.
Additional notation / terminology is applied:

For the inheritance, the usual ancestor/descendant terminology and notation applies.

For primary objects x, y,
if x ϵ y then
x is an instanceof y
and
y is a containerof x.

Helix classes, H.pr, are
primary objects x such that x ϵ x.

Classes, C,
are primary inheritance descendants of helix classes.

Properties, P,
are primary instances of p.

Terminals, T,
are primary objects that are neither classes nor properties,
i.e.
O.pr = T ⊎ P ⊎ C.

Metaclasses are objects x
such that H.pr ⊆ x.↥.

We write ϵ^{i} for ith composition of ϵ,
i > 0.
In particular, (ϵ^{2}) = (ϵ) ○ (ϵ).
We put ϵ^{0} equal to the inheritance ≤.
The structure is subject to the following axioms:


(S1_{o}.pr~1) 

(a)
(ϵ) ○ (≤) = (ϵ).

(b)
(≤) ○ (ϵ) = (ϵ).

(S1_{o}.pr~2) 
The inheritance ≤ is a preorder between objects.

(S1_{o}.pr~3) 
 (a)
Only classes can have instances.
 (b)
Terminals have no strict descendants.
(In particular, they have no distinct equivalents in ≤.)

(S1_{o}.pr~4) 
The set H.pr of helix classes is subject to the following conditions:
 (a)
Helix classes are totally preordered by the inheritance ≤.
 (b)
There are at least 2 nonequivalent helix classes.
 (c)
r is a top helix class,
c is a bottom helix class.

(S1_{o}.pr~5) 
Metaclasses can only have classes as primary instances.

(S1_{o}.pr~6) 
 (a)
Every object has a container.
 (b)
Only metaclasses and helix classes can have classes as instances.

(S1_{o}.pr~7) 
Chains in ϵ between nonhelix classes are of bounded length,
i.e.
for some i > 0,

x ϵ^{i} y implies y ϵ y,
for every objects x, y.

(S1_{o}.pr~8) 
There are only finitely many nonequivalent helix classes.

(S1_{o}.pr~9) 
p is a class
that is neither a helix class nor a metaclass.

Eigenclass completion
Eigenclass chains for ≤equivalent classes or properties are shared.
Otherwise, the eigenclass completion is the same
as for S1_{ϵ}.pr structures.
Proposition:
Up to isomorphism,
there is onetoone correspondence between
S1_{o} structures and
S1_{o}.pr structures.
Correspondence to RDFS_{1} structures
For a RDFS_{1} structure
(Ō, Ψ,
‹ϵ›, ‹≤_{C}›, ‹≤_{P}›, ‹ϵ_{d}›, ‹ϵ_{r}›,
r, c, p)
denote
≤ the relation between objects defined as
Ō.∆ ∪ (≤_{C}) ∪ (≤_{P}), i.e.

x ≤ y iff
x = y or x ≤_{C} y or x ≤_{P} y.
The following proposition
shows the correspondence of
ontological structures of ϵ
(S1_{o} / S1_{o}.pr)
to RDF Schema and OWL 2 Full:
Proposition A:
The reduct
(Ō, ϵ, ≤, r, c, p)
of an RDFS_{1} structure
is an
S1_{o}.pr structure if and only
the following (additional) conditions are satisfied:


(RDFS_{1}~ad~1) 
Classes and properties are disjoint,
c.϶ ∩ p.϶ = ∅.

(RDFS_{1}~ad~2) 
(≤) ○ (ϵ) = (ϵ).

(RDFS_{1}~ad~3) 
 (a)
Helix classes are totally preordered in ≤.
 (b)
The metaclass root can only be an instance of helix classes,
c.ϵ = c.↥.

(RDFS_{1}~ad~4) 
Only metaclasses and helix classes can have classes as instances,
i.e. for every class x,

x.϶ ∩ c.϶ ≠ ∅ implies
x ∈ c.↥ ∪ c.↧.

(RDFS_{1}~ad~5) 
Cycles in ϵ only occur among helix classes.

Proof:
Acyclic chains in ϵ are of limited length due to the finiteness condition
(RDFS_{1}~5).
Proposition B:
None of the above conditions can be omitted as shown by the following examples:
Condition ϕ name 
Generating triple(s) 
Where ϕ is violated in the Λ_{2} closure 
(RDFS_{1}~ad~1) 
rdf:value ϵ rdfs:Class . 
rdf:value is both property and class.

(RDFS_{1}~ad~2) 
rdfs:seeAlso ϵ rdf:Alt . 
rdfs:isDefinedBy ,
despite being a subproperty of rdfs:seeAlso ,
is not an instance of rdf:Alt .

(RDFS_{1}~ad~3)(a) 
rdfs:Class ≤_{C} ex:A .
rdfs:Class ≤_{C} ex:B .

The helix classes ex:A and ex:B are incomparable in inheritance.

(RDFS_{1}~ad~3)(b) 
rdfs:Class ϵ ex:C .

ex:C is not a superclass of rdfs:Class .

(RDFS_{1}~ad~4) 
rdf:Seq ϵ rdf:Bag .

rdf:Bag is not a metaclass (nor a helix class).
[]

(RDFS_{1}~ad~5) 
ex:M ≤_{C} rdfs:Class .
ex:N ≤_{C} rdfs:Class .
ex:M ϵ ex:N .
ex:N ϵ ex:M .

ex:M and ex:N are not helix classes
(despite constituting a cycle in ϵ).

References


Ivan Herman,
RDFS and OWL 2 RL generator service,
2009,
http://www.ivanherman.net/Misc/2008/owlrl/


Aimilia Magkanaraki, Sofia Alexaki, Vassilis Christophides, and Dimitris Plexousakis,
Benchmarking RDF Schemas for the Semantic Web,
ISWC,
2002,
http://www.ics.forth.gr/isl/publications/paperlink/iswc02.pdf


Ondřej Pavlata,
Object Membership: The Core Structure of Object Technology,
2012–2015,
http://www.atalon.cz/om/objectmembership/


Ondřej Pavlata,
Object Membership: The Core Structure of ObjectOriented Programming,
2012–2015,
http://www.atalon.cz/om/objectmembership/oop/


World Wide Web Consortium,
OWL 2 Profiles,
2009,
http://www.w3.org/TR/owl2profiles/


World Wide Web Consortium,
OWL 2 RDFBased Semantics,
2009,
http://www.w3.org/TR/owl2rdfbasedsemantics/


World Wide Web Consortium,
RDF Schema,
2004,
http://www.w3.org/TR/rdfschema/


World Wide Web Consortium,
RDF Semantics,
2004,
http://www.w3.org/TR/2004/RECrdfmt20040210/


World Wide Web Consortium,
Semantic Web Wiki,
http://www.w3.org/2001/sw/wiki/

Document history
December  12  2012 
The initial release.

December  13  2012 
Several additions of missing s in rdfs: .

March  12  2015 
Condition (S1_{o}.pr~9)(b)
(P.↧ = P) removed as redundant.

License
This work is licensed under a
Creative Commons AttributionNonCommercialShareAlike 3.0 License.