OntoKit

What are Properties?

Properties are the verbs of an ontology — they describe how individuals relate to each other and what attributes they carry. RDF defines a single base type and OWL layers a richer typology on top, with axioms for characteristics (functional, transitive, …) and relationships between properties (sub-property, equivalence, disjointness).

The Base: rdf:Property

Every predicate that connects a subject to an object in an RDF triple is, at minimum, an rdf:Property. The W3C RDF specification doesn't distinguish between “properties that point to other resources” and “properties that hold literal values” — it's just one flat type. RDFS adds rdfs:domain and rdfs:range to constrain what classes a property can apply to and what kind of values it accepts, but the typology stops there.

@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .

ex:hasMember a rdf:Property ;
    rdfs:domain ex:Group ;
    rdfs:range  ex:Person .

For most modelling tasks the OWL property kinds (below) are a better fit, since they let reasoners distinguish references from literal values and enforce the difference automatically.

owl:ObjectProperty

Connects an individual to another individual — the range is always another resource (an IRI or blank node), never a literal. Use object properties for relationships between things: hasParent, memberOf, locatedIn.

@prefix owl:  <http://www.w3.org/2002/07/owl#> .

ex:hasParent a owl:ObjectProperty ;
    rdfs:domain ex:Person ;
    rdfs:range  ex:Person .

ex:Alice ex:hasParent ex:Bob .   # both must be IRIs / individuals

owl:DatatypeProperty

Connects an individual to a literal value typed by an XSD or RDF datatype: xsd:string, xsd:integer, xsd:date, etc. Use datatype properties for raw attributes: hasAge, hasName, birthDate.

@prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .

ex:hasAge a owl:DatatypeProperty ;
    rdfs:domain ex:Person ;
    rdfs:range  xsd:nonNegativeInteger .

ex:Alice ex:hasAge "34"^^xsd:nonNegativeInteger .

owl:AnnotationProperty

Carries metadata about an entity rather than asserting a logical relationship. Annotation properties are invisible to OWL reasoners — they don't participate in inference, but they're what people read in the UI. Common examples: rdfs:label, rdfs:comment, skos:prefLabel, dcterms:creator.

ex:hasMaintainer a owl:AnnotationProperty ;
    rdfs:label "Has maintainer"@en .

ex:MyOntology ex:hasMaintainer "Jane Doe" .  # not used in inference

Rule of thumb: if a value should drive logical conclusions (membership, equivalence, consistency checking), it belongs on an object or datatype property. If it's for humans — labels, comments, dates, authorship — use an annotation property.

Characteristic Axioms

OWL lets you mark a property with axioms that constrain how it behaves — a reasoner uses these to derive new triples or detect contradictions. In OWL 2 DL these characteristics apply to object properties; the only one also permitted on datatype properties is owl:FunctionalProperty.

AxiomMeaningExample
owl:FunctionalPropertyEach subject has at most one valuehasFather
owl:InverseFunctionalPropertyEach value identifies at most one subject (only on object properties)hasPassport
owl:TransitivePropertyIf a P b and b P c, then a P cisAncestorOf
owl:SymmetricPropertyIf a P b, then b P ahasSibling
owl:AsymmetricPropertyIf a P b, then b P a is falsehasParent
owl:ReflexivePropertyEvery individual P itselfknows
owl:IrreflexivePropertyNo individual P itselfisParentOf
ex:isAncestorOf a owl:ObjectProperty , owl:TransitiveProperty , owl:IrreflexiveProperty .

# From  Alice -isAncestorOf-> Bob  and  Bob -isAncestorOf-> Carol
# A reasoner derives  Alice -isAncestorOf-> Carol

Relationships Between Properties

Properties can also relate to each other, not just to instances. These axioms let you organise properties into hierarchies, declare alignments, or rule out impossible combinations.

AxiomMeaning
rdfs:subPropertyOfEvery triple using the sub-property also entails one using the super-property. E.g. hasMother rdfs:subPropertyOf hasParent.
owl:equivalentPropertyTwo properties always carry the same triples in both directions — a reasoner can substitute one for the other freely.
owl:inverseOfReverses subject and object. If a hasParent b, then b hasChild a.
owl:propertyDisjointWithTwo properties cannot share any pair of values. Used for mutually-exclusive relations — e.g. hasSpouse vs hasParent.
owl:AllDisjointPropertiesThe n-ary form: declare three or more properties pairwise-disjoint in one axiom.
owl:propertyChainAxiomDerive a property by chaining others. E.g. hasGrandparent ≡ hasParent ∘ hasParent.
ex:hasParent owl:inverseOf ex:hasChild .

ex:hasSpouse owl:propertyDisjointWith ex:hasParent ;
             a owl:SymmetricProperty .

ex:hasGrandparent owl:propertyChainAxiom ( ex:hasParent ex:hasParent ) .

Domain and Range

rdfs:domain declares what class a subject must belong to in order to be a valid subject of the property; rdfs:range does the same for the object.

In OWL these are not validation constraints — they're entailments. Asserting hasParent rdfs:domain Person and then writing ex:Spot ex:hasParent ex:Rex doesn't raise an error; it lets a reasoner conclude that Spot is a Person. Use SHACL or domain-specific lint rules if you want classical “wrong type” validation.

Choosing the Right Kind

  • Will the value be a reference to another individual in your ontology? → owl:ObjectProperty.
  • Will the value be a literal (number, string, date, …)? → owl:DatatypeProperty.
  • Is the value metadata for humans, not for the reasoner? → owl:AnnotationProperty.
  • Are you not committing to OWL at all (e.g. plain RDFS)? → rdf:Property works, but you lose reasoner support for the distinctions above.

References