The OWL2 Working group has published a quick reference guide [Bao et al. 2009] summarizing all language features1. In this reference guide the authors use a number of predefined namespaces and some place holders for certain kinds of entities or entity names. In the following table we replicate the used notational conventions:
Prefix Name |
Expansion |
rdf: |
http://www.w3.org/1999/02/22-rdf-syntax-ns# |
rdfs: |
http://www.w3.org/2000/01/rdf-schema# |
owl: |
http://www.w3.org/2002/07/owl# |
xsd: |
http://www.w3.org/2001/XMLSchema# |
Prefixes for standard namespaces.
Letters |
Meaning |
C |
class expression |
CN |
class name |
D |
data range |
DN |
datatype name |
P |
object property expression |
PN |
object property name |
R |
data property |
A |
annotation property |
a |
individual |
aN |
individual name |
_:a |
anonymous individual (a blank node label) |
v |
literal |
n |
non-negative integer |
f |
facet |
ON |
ontology name |
U |
IRI |
s |
IRI or anonymous individual |
t |
IRI, anonymous individual, or literal |
p |
prefix name |
_:x |
blank node |
(a1 … an) |
RDF list |
Variable names and their meaning
In this section we will give an overview of the supported OWL2 features (including OWL1, cf. [Golbreich, Wallace 2009] for an overview and rationale for the new, additional OWL2 features). We will use the same structuring as chosen in the OWL2 reference guide [Bao et al. 2009]. The following tables present the following information:
The actual OWL2 feature
Functional style syntax of the feature according to the OWL2 recommendation
Syntax for the feature as used in the NeOn Toolkit. This is based on the Manchester Syntax for OWL (if applicable)
Is the feature supported by the GUI of the NeOn Toolkit? yes/no
The first group of features represents the different ways to specify complex OWL classes.
|
Functional Syntax |
NeOn Toolkit Syntax |
supported by GUI of NeOn Toolkit 2.3 |
2.1 Class Expressions |
|||
Predefined and named classes |
|
|
|
named class |
C |
C |
yes |
universal class |
owl:Thing |
owl:Thing |
yes |
empty class |
owl:Nothing |
owl:Nothing |
yes |
|
|||
Boolean Connectives and Enumeration of Individuals |
|||
intersection |
ObjectIntesectionOf(C1…Cn) |
C1 and … Cn |
yes |
union |
ObjectUnionOf(C1…Cn) |
C1 or … Cn |
yes |
complement |
ObjectComplementOf(C) |
not C |
yes |
enumeration |
ObjectOneOf(a1 … an) |
{a1, … an} |
yes |
|
|||
Object Property Restrictions |
|||
universal |
ObjectAllValuesFrom (P C) |
P only C |
yes |
existential |
ObjectSomeValuesFrom(P C) |
P some C |
yes |
individual value |
ObjectHasValue(P a) |
P value a |
yes |
local reflexivity |
ObjectHasSelf(P) |
P Self |
yes |
exact cardinality |
ObjectExactCardinality(n P) |
P exactly n owl:Thing |
yes |
qualified exact cardinality |
ObjectExactCardinality(n P C) |
P exactly n C |
yes |
maximum cardinality |
ObjectMaxCardinality(n P) |
P max n owl:Thing |
yes |
qualified maximum cardinality |
ObjectMaxCardinality(n P C) |
P max n C |
yes |
minimum cardinality |
ObjectMinCardinality(n P) |
P min n owl:Thing |
yes |
qualified minimum cardinality |
ObjectMinCardinality(n P C) |
P min n C |
yes |
|
|||
Data Property Restrictions |
|||
universal |
DataAllValuesFrom (P D) |
P only D |
yes |
existential |
DataSomeValuesFrom(P D) |
P some D |
yes |
literal value |
DataHasValue(P a) |
P value a |
yes |
exact cardinality |
DataExactCardinality(n P) |
P exactly n |
yes |
qualified exact cardinality |
DataExactCardinality(n P D) |
P exactly n D |
yes |
maximum cardinality |
DataMaxCardinality(n P) |
P max n |
yes |
qualified maximum cardinality |
DataMaxCardinality(n P D) |
P max n D |
yes |
minimum cardinality |
DataMinCardinality(n P) |
P min n |
yes |
qualified minimum cardinality |
DataMinCardinality(n P D) |
P min n D |
yes |
|
|||
Restrictions Using n-ary Data Range |
|||
n-ary universal |
DataAllValuesFrom (R1 … Rn Dn) |
no |
|
n-ary existential |
DataSomeValuesFrom (R1 … Rn Dn) |
no |
As can be seen the NeOn Toolkit support nearly all complex class expressions, with the exception of n-ary data ranges. It also supports the new OWL2 expressions like qualified number restrictions, local reflexivity (Self) or the new built-in class owl:Nothing.
In the second group we will all features representing property expressions.
|
Functional Syntax |
NeOn Toolkit Syntax |
supported by GUI of NeOn Toolkit 2.3 |
2.2 Properties |
|
|
|
Object Property Expressions |
|||
named object property |
PN |
PN |
yes |
universal object property |
owl:topObjectProperty |
owl:topObjectProperty |
yes |
empty object property |
owl:bottomObjectProperty |
owl:bottomObjectProperty |
yes |
inverse property |
ObjectInverseOf(PN) |
|
no |
|
|||
Data Property Expressions |
|||
named Data property |
R |
R |
yes |
universal Data property |
owl:topDataProperty |
owl:topDataProperty |
yes |
empty Data property |
owl:bottomDataProperty |
owl:bottomDataProperty |
yes |
The NeOn Toolkit supports all property expressions, with the exception of inverse object properties. Users can specify inverse properties using axioms but currently cannot use them in class expressions. Nevertheless, loading and storing ontologies that make use of ObjectInverseOf expressions is supported by the NeOn toolkit via the OWL API datamodel, parsers and serializers. All new top and bottom properties introduced by OWL2 are supported by the NeOn Toolkit.
The third group describes basic individuals or datatype values (literals).
|
Functional Syntax |
NeOn Toolkit Syntax |
supported by GUI of NeOn Toolkit 2.3 |
2.3 Indivduals and Literals |
|||
named individual |
aN |
aN |
yes |
anonymous individual |
_:a |
|
no |
literal (dataype value) |
"abc"^^DN |
"abc"^^DN |
yes |
With the exception of the anonymous individuals we support all individuals and literals within the text fields of the NeOn Toolkit. The underlying datamodel does support anonymous individuals, thus the NeOn Toolkit can handle such ontologies.
Group number four describes (complex) datatypes, which are called data ranges in OWL2.
|
Functional Syntax |
NeOn Toolkit Syntax |
supported by GUI of NeOn Toolkit 2.3 |
2.4 Data Ranges |
|||
Data Range Expressions |
|||
named datatype |
DN |
DN |
Yes |
data range complement |
DataComplementOf (D) |
|
No |
data range intersection |
DataIntersectionOf (D1…Dn) |
|
No |
data range union |
DataUnionOf (D1…Dn) |
|
No |
literal enumeration |
DataOneOf (v1 … vn) |
{v1, … vn} |
Yes |
datatype restriction |
DatatypeRestriction (DN f1 v1 … fn vn) |
No |
With respect to complex data ranges the Neon Toolkit only supports named data types and enumerations. The new OWL2 expressions to construct new data ranges, e.g. via facets is not yet supported by the GUI.
The next group starts a long list of axioms which can be asserted in OWL2. In the NeOn toolkit axioms are accessible through different GUI mechanisms instead of being represented in pure textual form. Because of this, from now on, we leave out the NeOn Toolkit syntax column.
Class axioms make statements about the relationship between OWL classes.
|
Functional Syntax |
NeOn Toolkit 2.3 GUI Element |
supported by GUI of NeOn Toolkit 2.3 |
2.5 Axioms |
|||
Class Expression Axioms |
|||
subclass |
SubClassOf(C1 C2) |
Taxonomy Tab of Class, resp. Restrictions Tab if C2 is a restriction |
Yes |
equivalent classes |
EquivalentClasses (C1 … Cn) |
Yes |
|
disjoint classes |
DisjointClasses(C1 C2) |
Taxonomy Tab of Class |
Yes |
pairwise disjoint classes |
DisjointClasses (C1 … Cn) |
Yes |
|
disjoint union |
DisjointUnionOf (CN C1 … Cn) |
|
No |
Except for the new OWL2 feature of specifiying a class as a disjoint union of its subclasses the NeOn Toolkit supports all class axioms. They can be entered via the entity property view for classes in separate sections or tabs (see below).
In the following group we list a rather extensive set of different axioms that specify the semantics of object properties OWL2.
|
Functional Syntax |
NeOn Toolkit 2.3 GUI Element |
supported by GUI of NeOn Toolkit 2.3 |
Object Property Axioms |
|||
subproperty |
SubObjectPropertyOf (P1 P2) |
Taxonomy tab of Object Property |
Yes |
property chain inclusion |
SubObjectPropertyOf (ObjectPropertyChain (P1 … Pn) P) |
Yes |
|
property domain |
ObjectPropertyDomain (P C) |
Domain/Range Tab of Object Property |
Yes |
property range |
ObjectPropertyRange (P C) |
Yes |
|
equivalent properties |
EquivalentObjectProperties (P1 … Pn) |
Taxonomy tab of Object Property |
Yes |
disjoint properties |
DisjointObjectProperties (P1 P2) |
|
No |
pairwise disjoint properties |
DisjointObjectProperties (P1 … Pn) |
|
No |
inverse properties |
InverseObjectProperties (P1 P2) |
Taxonomy tab of Object Property |
Yes |
functional property |
FunctionalObjectProperty (P) |
Domain/Range Tab of Object Property |
Yes |
inverse functional property |
InverseFunctionalObjectProperty (P) |
Yes |
|
reflexive property |
ReflexiveObjectProperty (P) |
Yes |
|
irreflexive property |
IrreflexiveObjectProperty (P) |
Yes |
|
symmetric property |
SymmetricObjectProperty (P) |
Yes |
|
asymmetric property |
AsymmetricObjectProperty (P) |
Yes |
|
transitive property |
TransitiveObjectProperty (P) |
Yes |
With the sole except of disjoint properties the NeOn toolkit supports all object property axioms, including the new OWL2 features such as property chains, reflexive, irreflexive or asymmetric properties.
The next group shows the data property axioms, which allow to specify the semantics of data properties OWL2.
|
Functional Syntax |
NeOn Toolkit 2.3 GUI Element |
supported by GUI of NeOn Toolkit 2.3 |
Data Property Axioms |
|||
subproperty |
SubDataPropertyOf(R1 R2) |
Taxonomy Tab of Data Property |
Yes |
property domain |
DataPropertyDomain(R C) |
Domain/Range Tab of Data Property |
Yes |
property range |
DataPropertyRange(R D) |
Yes |
|
equivalent properties |
EquivalentDataProperties (R1 … Rn) |
Taxonomy Tab of Data Property |
Yes |
disjoint properties |
DisjointDataProperties (R1 R2) |
|
No |
pairwise disjoint properties |
DisjointDataProperties (R1 … Rn) |
|
No |
functional property |
FunctionalDataProperty(R) |
Domain/Range Tab of Data Property |
Yes |
Similarly to object properties above, there is only one OWL2 feature that users of the NeOn toolkit cannot immediately access via the GUI, namely disjoint data properties.
OWL2 allows now to define new datatpyes by giving data range specifications a new name.
|
Functional Syntax |
NeOn Toolkit 2.3 GUI Element |
supported by GUI of NeOn Toolkit 2.3 |
Datatype Definitions |
|||
datatype definition |
DatatypeDefinition(DN D) |
Context menu of Datatype Folder of Ontology Navigator |
Yes |
This feature is not yet supported by the NeOn Toolkit because without being able to specify complex data ranges this would be meaningless.
In this group we collect all A-Box axioms making assertions about individuals.
|
Functional Syntax |
NeOn Toolkit 2.3 GUI Element |
supported by GUI of NeOn Toolkit 2.3 |
Assertions |
|||
individual equality |
SameIndividual(a1 … an) |
Taxonomy tab of Individual |
Yes |
individual inequality |
DifferentIndividuals(a1 a2) |
Yes |
|
pairwise individual inequality |
DifferentIndividuals (a1 … an) |
Yes |
|
class assertion |
ClassAssertion(C a) |
Yes |
|
positive object property assertion |
ObjectPropertyAssertion (PN a1 a2 ) |
Properties tab of Individual |
Yes |
positive data property assertion |
DataPropertyAssertion (R a v ) |
Yes |
|
negative object property assertion |
NegativeObjectPropertyAssertion (P a1 a2 ) |
|
No |
negative data property assertion |
NegativeDataPropertyAssertion (R a v ) |
|
No |
All essential types of assertions are supported by the NeOn toolkit. Only negative assertions are not yet implemented in the user interface.
OWL2 now allows specifying key properties for classes, which formulates a rule that all individuals of that class with the same values for all key properties are identical.
|
Functional Syntax |
NeOn Toolkit 2.3 GUI Element |
supported by GUI of NeOn Toolkit 2.3 |
Keys |
|||
Key |
HasKey(C (P1 … Pm) (R1 … Rn) ) |
|
no |
This feature is not implemented in the NeOn Toolkit yet.
Entities of all kinds can be declared to exist in OWL2.
|
Functional Syntax |
NeOn Toolkit 2.3 GUI Element |
supported by GUI of NeOn Toolkit 2.3 |
2.6 Declarations |
|||
class |
Declaration( Class( CN ) ) |
Context menu of folders and entites of Ontology Navigator |
yes |
datatype |
Declaration( Datatype( DN ) ) |
no |
|
object property |
Declaration( ObjectProperty( PN ) ) |
yes |
|
data property |
Declaration( DataProperty( R ) ) |
yes |
|
annotation property |
Declaration ( AnnotationProperty( A ) ) |
yes |
|
named individual |
Declaration ( NamedIndividual( aN ) ) |
yes |
With the exception of declaring datatypes users of the NeOn toolkit can introduce new instances all other entity types.
Annotations represent metadata about axioms or entities.
|
Functional Syntax |
NeOn Toolkit 2.3 GUI Element |
supported by GUI of NeOn Toolkit 2.3 |
2.7 Annotations |
|||
Annotations |
|||
annotation assertion |
AnnotationAssertion (A s t) |
Annotations tab of all entities |
yes |
annotation of an axiom |
AXIOM(Annotation (A t) …) |
|
no |
annotation of another annotation |
Annotation(Annotation (A t) … A1 t1) |
|
no |
The OWL2 specification supports extensive use of annotations. Users of the NeOn toolkit can read, create and modify annotations for all entity types and ontologies. Axiom annotations and annotations of annotations are not yet supported.
OWL2 specifies a number pre-existing annotation properties.
|
Functional Syntax |
NeOn Toolkit 2.3 GUI Element |
supported by GUI of NeOn Toolkit 2.3 |
Annotation Properties |
|||
named annotation property |
A |
|
yes |
human-readable name |
rdfs:label |
|
yes |
human-readable comment |
rdfs:comment |
|
yes |
additional information |
rdfs:seeAlso |
|
yes |
defining agent |
rdfs:isDefinedBy |
|
yes |
version information |
owl:versionInfo |
|
yes |
deprecation |
owl:deprecated |
|
yes |
backwards compatibility |
owl:backwardCompatibleWith |
|
yes |
incompatibility |
owl:incompatibleWith |
|
yes |
Prior version |
owl:priorVersion |
|
yes |
All predefined annotation properties are supported by the NeOn toolkit. In addition, user defined annotation properties can be introduced and used.
OWL2 introduces the new features for modelling properties of annotation properties.
|
Functional Syntax |
NeOn Toolkit 2.3 GUI Element |
supported by GUI of NeOn Toolkit 2.3 |
Annotation Axioms |
|||
annotation subproperties |
SubAnnotationPropertyOf(A1 A2) |
|
no |
annotation property domain |
AnnotationPropertyDomain(A U) |
|
no |
annotation property range |
AnnotationPropertyRange(A U) |
|
no |
These new OWL2 features were not yet implemented in the NeOn Toolkit.
In the final group we find ontology-level information
|
Functional Syntax |
NeOn Toolkit 2.3 GUI Element |
supported by GUI of NeOn Toolkit 2.3 |
2.8 Ontologies |
|||
OWL ontology (importing) |
Ontology([ON [U]] Import(ON1)... Annotation(A t) ... ) |
Imports and Namespace tab of Ontology |
yes |
prefix declaration |
Prefix(p=U) |
yes |
In the NeOn Toolkit we support ontology imports and the management of prefixes.
Bao
et al 2009: Jie Bao, Elisa
F. Kendall, Deborah L. McGuinness, Peter F. Patel-Schneider: OWL 2
Web Ontology Language Quick Reference Guide. W3C Recommendation 27
October
2009.
http://www.w3.org/TR/2009/REC-owl2-quick-reference-20091027/
Golbreich,
Wallace 2009: Christine
Golbreich, Evan K. Wallace (ed.): OWL 2 Web Ontology Language. New
Features and Rationale. W3C Recommendation 27 October
2009.
http://www.w3.org/TR/2009/REC-owl2-new-features-20091027/
1cf. http://www.w3.org/TR/owl2-quick-reference/