Content deleted Content added
→History: Some dates added |
→Ontological structure: New section added |
||
Line 845:
Some languages support transitions such that the old structure is not a [[substructure]] of the new one.
In particular, Python, CLOS and Perl allow to change the class of a terminal object.
== {{anchor|ontological structure}} Ontological structure of ϵ ==
A generalization of the canonical structure of ϵ
allows
for a description of the core structure of [[Ontology_(information_science)|ontologies]] in which
classes are (among) individuals.<ref name="ome-ontology">
{{cite web | url=http://www.atalon.cz/om/object-membership/ontology/ | title=Object Membership: The ontological structure}}</ref>
<!-- -->
Motivated by the [[RDF Schema]],
the generalization can be characterized by the following features:
<ul>
<li>
Distinction of ''properties''
as instances of a special class, ''<u>p</u>''.
Properties, like terminal objects, are not descendants of the inheritance root. In contrast to terminals, properties can have (other properties as) ancestors / descendants.
<li>
Inheritance does not have to be antisymmetric
–
distinct classes or properties can be descendants of each other and thus become equivalent.
<li>
''Multiple classification'' –
an object ''x'' can have multiple minimum classes of which ''x'' is an instance, so that
the existence of ''x.class'' is not guaranteed.
<li>
Finiteness conditions are less strict in order to
allow infinitely many terminals or properties.
</ul>
In eigenclass completion,
the structure can be expressed with the signature
<span style="white-space:nowrap">''(<u>O</u>'', ϵ, ''<u>p</u>)''</span>.
Additional symbols ''<u>r</u>'' and ''<u>c</u>'' can be used for distinction between the possibly many equivalent inheritance and metaclass roots.
The primary ontological structure is then expressed as
<span style="white-space:nowrap">
''(<u>Ō</u>'', ϵ, ≤, ''<u>r</u>, <u>c</u>, <u>p</u>)''</span>.
=== In RDF Schema ===
In [[RDF Schema]] (RDFS),<ref>
{{cite web | url=http://www.w3.org/TR/rdf-mt/ | title=RDF Semantics }}</ref>
the (primary) ontological structure of ϵ is the core structure of the RDF graph formed by triples ''(s,p,o)'' whose predicate ''p'' equals
<code>rdf:type</code>,
<code>rdfs:subClassOf</code> or <code>rdfs:subPropertyOf</code>.
The <code>rdf:type</code> property stands for the instance-of relation,
ϵ.
Uniformity of inheritance, ≤, is achieved by the assumption
of disjointness of classes and properties,
which is not guaranteed by RDFS but usually satisfied.
The
<code>rdfs:subClassOf</code> and <code>rdfs:subPropertyOf</code> properties then
correspond to the restriction of inheritance to classes and properties,
respectively.
Objects are called <em>resources</em>
– every object is an instance of the <code>rdfs:Resource</code> class (''<u>r</u>'').
Classes are instances of <code>rdfs:Class</code> (''<u>c</u>''),
properties are instances of <code>rdf:Property</code> (''<u>p</u>'').
Unlike classes, properties do not have a common built-in ancestor.
Structure constraints are expressed via [[entailment]] rules
– the presence of some triples entails the presence of other triples.
For example,
the <span style="white-space: nowrap">(ϵ) ○ (≤) = (ϵ)</span> equality is asserted by the rdfs9 entailment rule,{{efn|
More precisely,
rdfs9 only asserts the inclusion (ϵ) ○ (≤) ⊆ (ϵ). Equality is asserted by other rules.
}}
which says that triples ''(x'',ϵ,''y)'' and ''(y'',≤,''z)'' entail the triple ''(x'',ϵ,''z)'', i.e.
whenever ''x'' is an instance of ''y'' and ''y'' a subclass of ''z'' then ''x'' is an instance of ''z''
(this is also known as the ''subsumption rule''<ref>
{{cite web | author= Seiji Koide, Hideaki Takeda | url=http://www-kasm.nii.ac.jp/papers/takeda/06/koide06aswc.pdf | title=OWL-Full Reasoning from an Object Oriented Perspective}}</ref>).
There are conditions that can be considered as natural constraints but are not asserted by RDFS entailment.
In particular, there is no "type monotonicity" rule which would assert that
<span style="white-space: nowrap">(≤) ○ (ϵ) = (ϵ)</span>.
Another example of a possible anomaly is a class that is not a metaclass (a descendant of <code>rdfs:Class</code>) but has classes as instances.<ref>
{{cite web | author=Aimilia Magkanaraki et al. | url=http://www.ics.forth.gr/isl/publications/paperlink/iswc02.pdf | title=Benchmarking RDF Schemas for the Semantic Web}}</ref>
[[File:Rdfs-builtin-isa.svg|
The built-in core structure of RDF Schema|
right|
350px
]]
The built-in structure, entailed by the empty set, is shown by the diagram on the right.
The structure is fairly regular.
Except for inheritance between properties and the infinity of the set {<code>rdf:_1</code>, <code>rdf:_2</code>, …},
even the axioms for the (primary) [[#Primary_structure|canonical structure]] are satisfied.
There is single classification (yielding the ''.class'' map) and single inheritance.
Since the ''.class'' map is inherited via type monotonicity, the diagram shows only the reduction (dashed arrows).
Similarly to the Python programming language,
there is a minimal chain of 2 helix classes:
:<i><u>c</u></i> = <code>rdfs:Class</code> < <code>rdfs:Resource</code> = <i><u>r</u></i>.
The <code>rdfs:Datatype</code> class is the second built-in metaclass.
=== In OWL 2 ===
In [[Web_Ontology_Language#OWL_Full|OWL 2 Full]],<ref>
{{cite web | url=http://www.w3.org/TR/owl2-rdf-based-semantics/ | title=OWL 2 RDF-Based Semantics }}</ref>
the structure of RDF Schema is extended by additional axiomatic triples.
The extension is then subject to the (additional) OWL 2 RL/RDF rules.<ref>
{{cite web | url=http://www.w3.org/TR/owl2-profiles/ | title=OWL 2 Profiles }}</ref>
The built-in structure contains four helix classes, preordered by
:{<code>owl:Class</code>, <code>rdfs:Class</code>} < {<code>owl:Thing</code>, <code>rdfs:Resource</code>},
which indicates that RDFS helix classes have their OWL equivalents.
Similarly,
<code>rdf:Property</code> is equivalent to
<code>owl:ObjectProperty</code> and
the metaclass <code>rdfs:Datatype</code> is equivalent to
(the metaclass) <code>owl:DataRange</code>.
<!-- -->
In total, there are 7 built-in metaclasses, including
the bottom class, <code>owl:Nothing</code>, a descendant of all classes which is disallowed to have instances.
==See also==
|