owl:equivalentClass                             

Definition

owl:equivalentClass is a built-in property that links a class description to another class description. The meaning of such a class axiom is that the two class descriptions involved have the same class extension (i.e., both class extensions contain exactly the same set of individuals).

owl:equivalentClass has owl:Class as domain and as range.


Schema

    <rdf:Property rdf:ID="equivalentClass">

        <rdfs:label>equivalentClass</rdfs:label>

        <rdfs:subPropertyOf rdf:resource="&rdfs;subClassOf"/>

        <rdfs:domain rdf:resource="#Class"/>

        <rdfs:range rdf:resource="#Class"/>

    </rdf:Property>

Example listing

Triple

 

RDF/XML

In its simplest form, an equivalentClass axiom states the equivalence (in terms of their class extension) of two named classes. An example:

 

    <owl:Class rdf:about="#US_President">     

        <owl:equivalentClass rdf:resource="#PrincipalResidentOfWhiteHouse"/>

    </owl:Class>

Other information

AXIOM SCHEMA: class description  owl:equivalentClass   class description

 

A class axiom may contain (multiple) owl:equivalentClass statements.

NOTE: The use of owl:equivalentClass does not imply class equality. Class equality means that the classes have the same intensional meaning (denote the same concept). In the example below, the concept of "President of the US" is related to, but not equal to the concept of the principal resident of a certain estate. Real class equality can only be expressed with the owl:sameAs construct. As this requires treating classes as individuals, class equality can only be expressed in OWL Full.

 

Axioms with owl:equivalentClass can also be used to define an enumerated class by linking a type 1 class description (a class identifier) to a type 2 class description (an enumeration). An example:

 

    <owl:Class rdf:ID="DaPonteOperaOfMozart">

        <owl:equivalentClass>

            <owl:Class>

                <owl:oneOf rdf:parseType="Collection">

                    <Opera rdf:about="#Nozze_di_Figaro"/>

                    <Opera rdf:about="#Don_Giovanni"/>

                    <Opera rdf:about="#Cosi_fan_tutte"/>

                </owl:oneOf>

            </owl:Class>

        </owl:equivalentClass>

    </owl:Class>

 

This class axiom defines the class of operas that together represent the "Da Ponte operas of Mozart" (a popular subject in musicology). By using the equivalentClass construct we can state necessary and sufficient conditions for class membership, in this case consisting of an enumeration of three individuals, no less, no more.

Note that relating two classes via owl:sameAs is a very different thing to relating them via owl:equivalentClass. The former says that the two objects are in fact the same, is actually an example of class as instance, and thus pushes the ontology out of OWL DL. The latter is an assertion that the extension (e.g. the collection of members) of the classes is equivalent. OWL DL does not put any constraints on the types of class descriptions that can be used as subject and object of an owl:equivalentClass statement. In OWL Lite the subject must be a class name and the object must be either a class name or a property restriction.

NOTE: Although in principle different types of class descriptions are allowed as the subject of an owl:equivalentClass statement, in practice it usually is some class identifier. This is also true for the examples in this section.

 

It is possible to have multiple equivalentClass axioms about the same class. However, this requires care. Both axioms must lead to the same outcome, i.e. exactly the same class extension. For example, an alternate equivalentClass axiom for Mozart's "Da Ponte operas" could be the following one:

 

    <owl:Class rdf:about="#DaPonteOperaOfMozart">

        <owl:equivalentClass>

            <owl:Class>

                <owl:intersectionOf rdf:parseType="Collection">

                    <owl:Restriction>

                        <owl:onProperty rdf:resource="#hasComposer"/>

                        <owl:hasValue rdf:resource="#Wolfgang_Amadeus_Mozart"/>

                    </owl:Restriction>

                    <owl:Restriction>

                        <owl:onProperty rdf:resource="#hasLibrettist"/>

                        <owl:hasValue rdf:resource="#Lorenzo_Da_Ponte"/>

                    </owl:Restriction>

                </owl:intersectionOf>

            </owl:Class>

        </owl:equivalentClass>

    </owl:Class>

 

This states that the class extension of the Da Ponte operas of Mozart corresponds exactly to those operas which are composed by Mozart and for which the libretto is written by Da Ponte (note: intersection = "and"). This axiom indeed defines a class with exactly the same instances as the previous axiom.

 

NOTE: If we wanted to "upgrade" an axiom of the form "A subClassOf B" to "A equivalentClass B" (meaning that the class extension of A is not just any subset, but in fact the same set as the class extension of B), we could add a second subClassOf axiom of the form (B subClassOf A), which by definition makes the two class extensions equivalent (and thus has the same meaning as "A equivalentClass B"). Such subClassOf "cycles" are explicitly allowed. As OWL is usable in a distributed environment, this can be a useful feature.

We have already seen that class expressions can be the targets of rdfs:subClassOf constructors. They can also be the target of owl:equivalentClass. Again, this avoids the need to contrive names for every class expression and provides a powerful definitional capability based on satisfaction of a property.

    <owl:Class rdf:ID="TexasThings">

        <owl:equivalentClass>

            <owl:Restriction>

                <owl:onProperty rdf:resource="#locatedIn" />

                <owl:someValuesFrom rdf:resource="#TexasRegion" />

            </owl:Restriction>

        </owl:equivalentClass>

    </owl:Class>

TexasThings are exactly those things located in the Texas region. The difference between using owl:equivalentClass here and using rdfs:subClassOf is the difference between a necessary condition and a necessary and sufficient condition. With rdfs:subClassOf, things that are located in Texas are not necessarily TexasThings. But, using owl:equivalentClass, if something is located in Texas, then it must be in the class of TexasThings.

Use in ISO 15926