Standalone Profile: EL

From OWL
Jump to: navigation, search

[Hide Review Comments]

Document title:
OWL 2 Web Ontology Language
Profiles: EL++ (Second Edition)
The OWL 2 Web Ontology Language, informally OWL 2, is an ontology language for the Semantic Web with formally defined meaning. OWL 2 ontologies provide classes, properties, individuals, and data values and are stored as Semantic Web documents. OWL 2 ontologies can be used along with information written in RDF, and OWL 2 ontologies themselves are primarily exchanged as RDF documents. The OWL 2 Document Overview describes the overall state of OWL 2, and should be read before other OWL 2 documents.
Status of this Document
This document is an experiment in having a standalone profile document.

Copyright © 2008-2009 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.

1 Background

The EL++ profile [EL++,EL++ Update] is designed as a maximal subset of OWL 2 DL that

  • captures the expressive power used by many large-scale ontologies and
  • for which the following reasoning problems can be decided in polynomial time: satisfiability, subsumption, classification, and instance checking.

A main design principle of EL++ is to focus on the class constructors ObjectIntersectionOf and ObjectSomeValuesFrom, but to provide ObjectAllValuesFrom only in the form of range restrictions. Many biomedical ontologies, such as SNOMED CT, fall within this profile.

EL++ was designed with large biohealth ontologies in mind, such as SNOMED-CT, the NCI thesaurus, and Galen. Common characteristics of such ontolgoies include complex structural descriptions (e.g., defining certain body parts in terms of what parts they contain and are contained in or propagating diseases along part-subpart relations), huge numbers of classes, the heavy use of classification to manage the terminology, and the application of the resulting terminology to vast amounts of data. Thus, EL++ has a comparatively expressive class expression language and it has no restrictions on how they may be used in axioms. It also has fairly expressive property expressions, including property chains but excluding inverse.

(Sensible use of EL++ is not restricted to the bioheath domain: as with the other profiles of OWL, EL++ is domain independent. However, EL++ shines when your domain and your application require recognition of structurally complex objects. Such domains include system configuration, product inventories, and many scientific domains.)

Working with EL++ is fairly similar to working with OWL DL: one can use class expressions on both sides of a subClassStatement and even infer such relations. For many class expression oriented ontologies, EL++ makes a good approximation target, that is, by only a little simplification one can get an EL++ ontology and preserve much of the meaning of the original ontology.

1.1 Notes for Users

Two key missing features are allValuesFrom and cardinality restrictions....

Editor's Note: Mooted?

1.2 Notes for Implementors

EL++ is very robust computationally and reasonably easy to implement. Not only does it scale well for facts and axioms, but it scales well for complex expressions.

Editor's Note: What else? I suppose some examples.

2 Feature Overview

EL++ provides the following features:

  • existential quantification to a class (ObjectSomeValuesFrom) or a data range (DataSomeValuesFrom) ,
  • existential quantification to a nominal (ObjectHasValue) or a constant (DataHasValue) ,
  • self quantification (ObjectExistsSelf),
  • enumerations involving a single element (ObjectOneOf) or a single constant (DataOneOf) ,
  • intersection of classes (ObjectIntersectionOf),
  • class inclusion (SubClassOf),
  • class equivalence (EquivalentClasses),
  • class disjointness (DisjointClasses),
  • object property inclusion (SubObjectPropertyOf) possibly involving property chains and data property inclusion (SubDataPropertyOf) ,
  • property equivalence (EquivalentObjectProperties and EquivalentDataProperties),
  • transitive object properties (TransitiveObjectProperty),
  • reflexive object properties (ReflexiveObjectProperty),
  • domain restrictions (ObjectPropertyDomain and DataPropertyDomain ),
  • range restrictions (ObjectPropertyRange and DataPropertyRange),
  • facts (SameIndividual, DifferentIndividuals, ClassAssertion, ObjectPropertyAssertion, DataPropertyAssertion, NegativeObjectPropertyAssertion, and NegativeDataPropertyAssertion),
  • functional data properties (FunctionalDataProperty),
  • a limited range of datatypes.

The following features of OWL 2 are missing in EL++:

  • universal quantification to a class (ObjectAllValuesFrom) or a data range(DatAllaValuesFrom) ,
  • counting quantification (ObjectMaxCardinality, ObjectMinCardinality, ObjectExactCardinality),DataMaxCardinality, DataMinCardinality, and DataExactCardinality))
  • disjunction (ObjectUnionOf, DisjointUnion),
  • negation (ObjectComplementOf),
  • enumerations involving multiple elements (ObjectOneOf, DataOneOf),
  • disjoint properties (DisjointObjectProperties and DisjointDataProperties),
  • irreflexive object properties (IrreflexiveObjectProperty),
  • inverse object properties (InverseObjectProperties),
  • functional object properties (FunctionalObjectProperty),
  • symmetric object properties (SymmetricObjectProperty),
  • asymmetric object property (AsymmetricObjectProperty).

3 Profile Specification

The productions for EL++ are defined in the following sections. All global restrictions on axioms from the [OWL 2 Specification] apply. An additional such restriction is imposed, as detailed below.

3.1 Entities

The entities of EL++ are exactly as in the entire OWL 2 language. Furthermore, EL++ supports the owl:Thing and owl:Nothing predefined classes that are interpreted as specified in [OWL 2 Specification].

EL++ supports the following datatypes:

  • The unary datatype with URI rdfs:Literal
  • xsd:decimal
  • xsd:integer
  • xsd:nonNegativeInteger
  • xsd:positiveInteger
  • xsd:dateTime
  • xsd:date
  • xsd:string
  • xsd:normalizedString
  • xsd:anyURI
  • xsd:token
  • xsd:Name
  • xsd:NCName
  • xsd:hexBinary
  • xsd:base64Binary

Furthermore, the following predefined datatypes of full OWL 2 are not available in EL++: xsd:double, xsd:float, xsd:long, xsd:int, xsd:short, xsd:byte, xsd:nonPositiveInteger, xsd:negativeInteger, xsd:unsignedLong, xsd:unsignedInt, xsd:unsignedShort, xsd:unsignedByte, xsd:time, xsd:gYear, xsd:gMonth, xsd:gDay, xsd:gYearMonth, and xsd:gMonthDay .

3.2 Class Expressions

The design principle of EL++ is to focus on the class constructors ObjectIntersectionOf and ObjectSomeValuesFrom, which are used extensively in many large-scale ontologies. It additionally provides for objectExistsSelf, objectHasValue, dataSomeValuesFrom, dataHasValue, and objectOneOf enumerations that contain a single individual (called nominals in the DL literature). Thus, EL++ class descriptions are defined according to the following production:

description := owlClassURI | objectIntersectionOf | objectOneOf |
    objectSomeValuesFrom | objectExistsSelf | objectHasValue |
    dataSomeValuesFrom | dataHasValue

The productions for class constructors are as defined in [OWL 2 Specification], with the exception of objectOneOf which admits only a single individual:

objectOneOf := 'ObjectOneOf' '(' individualURI')'

EL++ disallows ObjectUnionOf, ObjectComplementOf, ObjectAllValuesFrom, DataAllValuesFrom, ObjectMaxCardinality, ObjectMinCardinality, ObjectExactCardinality, DataMaxCardinality, DataMinCardinality, and DataExactCardinality.

3.3 Property Expressions

Inverse properties are not supported in EL++, and thus object property expressions are restricted to named properties. Data property expressions are as in OWL 2.

objectPropertyExpression := objectPropertyURI

3.4 Data Range Expressions

A data range expression is restricted in EL++ to the predefined datatypes admitted in EL++ and enumerated datatypes consisting of a single constant.

dataRange := datatypeURI | dataOneOf
dataOneOf := 'DataOneOf' '(' constant')'

EL++ does not support DataComplementOf and DatatypeRestriction (i.e., no facet is admitted).

3.5 Axioms

The class axioms of EL++ are the same as in full OWL 2, except that DisjointUnion is not allowed.

classAxiom := subClassOf | equivalentClasses | disjointClasses

The productions for all supported kinds class axioms are as in the [OWL 2 Specification], with the difference that they use the new description production. We refer to that document for details.

EL++ supports the following object property axioms.

objectPropertyAxiom :=
    equivalentObjectProperties | subObjectPropertyOf |
    objectPropertyDomain | objectPropertyRange |
    transitiveObjectProperty| reflexiveObjectProperty

The productions for all supported kinds of object property axioms are as in the [OWL 2 Specification]. EL++ disallows DisjointObjectProperties, IrreflexiveObjectProperty, InverseObjectProperties, FunctionalObjectProperty, SymmetricObjectProperty, and AsymmetricObjectProperty axioms.

Regarding data property axioms, EL++ provides the same facilities as OWL 2, except DisjointDataProperty. Therefore, data property axioms in EL++ are defined as follows.

dataPropertyAxiom :=
    subDataPropertyOf |
    equivalentDataProperties |
    dataPropertyDomain |
    dataPropertyRange |

Again, the productions for all supported kinds of property axioms are as in the [OWL 2 Specification].

The facts in EL++ are the same as in OWL 2, with the diffence that descriptions and object property expressions are restricted as specified previously. Finally, the axioms of EL++ are the same as in OWL 2, with the difference that each axiom type is restricted as specified previously.

3.6 Global Restriction

The axiom closure Ax of an EL++ ontology must obey the restrictions described in Section 10 of the structural specification [OWL 2 Specification]. To obtain polytime reasoning problems, one additional restriction is imposed.

Let CE be a class expression. We say that Ax imposes a range restriction to CE on an object property PE1 if it contains axioms

  • SubObjectPropertyOf(PE1 PE2),...,SubObjectPropertyOf(PEk-1 PEk)
  • ObjectPropertyRange(PEk CE)

We require that if

  • Ax contains SubObjectPropertyOf(SubObjectPropertyChain(PE1 ... PEn) PE) and
  • Ax imposes a range restriction to CE on PE

then Ax imposes a range restriction to CE on PEn.

Remarks: (1) The restriction is vacuously true if the SubObjectPropertyOf in the first item is a role inclusion statement -- that is, if it does not contain SubObjectPropertyChain. (2) Range restrictions on reflexive and transitive roles are generally allowed, unless they are used in axioms following the forbidden pattern above.