Standalone Profile: EL
- 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.
- 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....
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.
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 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
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:
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:
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).
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.
equivalentObjectProperties | subObjectPropertyOf |
objectPropertyDomain | objectPropertyRange |
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.
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.