Hubbry Logo
RDF SchemaRDF SchemaMain
Open search
RDF Schema
Community hub
RDF Schema
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
RDF Schema
RDF Schema
RDF Schema
View on Wikipedia
from Wikipedia
RDF Schema
Resource Description Framework Schema
AbbreviationRDFS
StatusW3C Recommendation
Year startedJanuary 5, 1999; 27 years ago (1999-01-05)[1][2]
First publishedApril 30, 2002; 23 years ago (2002-04-30)[2]
Latest version1.1 (Recommendation)
February 25, 2014; 11 years ago (2014-02-25)[3]
Organization
Editors
Base standardsRDF
Related standards
Domain
Websitewww.w3.org/TR/rdf-schema/

RDF Schema (Resource Description Framework Schema, variously abbreviated as RDFS, RDF(S), RDF-S, or RDF/S) is a set of classes with certain properties using the RDF extensible knowledge representation data model, providing basic elements for the description of ontologies. It uses various forms of RDF vocabularies, intended to structure RDF resources. RDF and RDFS can be saved in a triplestore, then one can extract some knowledge from them using a query language, like SPARQL.

The first version[1][4] was published by the World-Wide Web Consortium (W3C) in April 1998, and the final W3C recommendation was released in February 2014.[3] Many RDFS components are included in the more expressive Web Ontology Language (OWL).

Terminology

[edit]

RDFS constructs are the RDFS classes, associated properties and utility properties built on the vocabulary of RDF.[5][6][7]

Classes

[edit]
rdfs:Resource
Represents the class of everything. All things described by RDF are resources.
rdfs:Class
An rdfs:Class declares a resource as a class for other resources.

A typical example of an rdfs:Class is foaf:Person in the Friend of a Friend (FOAF) vocabulary.[8] An instance of foaf:Person is a resource that is linked to the class foaf:Person using the rdf:type property, such as in the following formal expression of the natural-language sentence: 'John is a Person'. 

ex:John       rdf:type        foaf:Person

The definition of rdfs:Class is recursive: rdfs:Class is the class of classes, and so it is an instance of itself. 

rdfs:Class    rdf:type        rdfs:Class

The other classes described by the RDF and RDFS specifications are:

rdfs:Literal
literal values such as strings and integers. Property values such as textual strings are examples of RDF literals. Literals may be plain or typed.
rdfs:Datatype
the class of datatypes. rdfs:Datatype is both an instance of and a subclass of rdfs:Class. Each instance of rdfs:Datatype is a subclass of rdfs:Literal.
rdf:XMLLiteral
the class of XML literal values. rdf:XMLLiteral is an instance of rdfs:Datatype (and thus a subclass of rdfs:Literal).
rdf:Property
the class of properties.

Properties

[edit]

Properties are instances of the class rdf:Property and describe a relation between subject resources and object resources. When used as such a property is a predicate (see also RDF: reification).

rdfs:domain
the rdfs:domain of an rdf:Property declares the class of the subject in a triple whose predicate is that property.
rdfs:range
the rdfs:range of an rdf:Property declares the class or datatype of the object in a triple whose predicate is that property.

For example, the following declarations are used to express that the property ex:employer relates a subject, which is of type foaf:Person, to an object, which is of type foaf:Organization: 

ex:employer	  rdfs:domain  	  foaf:Person
ex:employer	  rdfs:range	  foaf:Organization

Given the previous two declarations, from the triple: 

ex:John		  ex:employer	  ex:CompanyX

can be inferred (resp. follows) that ex:John is a foaf:Person, and ex:CompanyX is a foaf:Organization.

rdf:type
a property used to state that a resource is an instance of a class. A commonly accepted QName for this property is "a".[9]
rdfs:subClassOf
allows declaration of hierarchies of classes.[10]

For example, the following declares that 'Every Person is an Agent': 

foaf:Person	  rdfs:subClassOf	  foaf:Agent

Hierarchies of classes support inheritance of a property domain and range (see definitions in the next section) from a class to its subclasses.

rdfs:subPropertyOf
an instance of rdf:Property that is used to state that all resources related by one property are also related by another.
rdfs:label
an instance of rdf:Property that may be used to provide a human-readable version of a resource's name.
rdfs:comment
an instance of rdf:Property that may be used to provide a human-readable description of a resource.

Utility properties

[edit]
rdfs:seeAlso
an instance of rdf:Property that is used to indicate a resource that might provide additional information about the subject resource.
rdfs:isDefinedBy
an instance of rdf:Property that is used to indicate a resource defining the subject resource. This property may be used to indicate an RDF vocabulary in which a resource is described.

RDFS entailment

[edit]

An entailment regime defines whether the triples in a graph are logically contradictory or not. RDFS entailment [11] is not very restrictive, i.e. it does not contain a large amount of rules (compared, for example, to OWL) limiting what kind of statements are valid in the graph. On the other hand it is also not very expressive, meaning that the semantics that can be represented in a machine-interpretable way with the graph is quite limited.

Below in a simple example of the capabilities and limits of RDFS entailment, we start with a graph containing the following explicit triples: 

foo:SomeGiraffe rdf:type bar:Animal.
foo:SomeElephant rdf:type bar:Elephant.
foo:SomeZoo rdf:type bar:Zoo.
bar:livesInZoo rdfs:domain bar:Animal.
bar:livesInZoo rdfs:range bar:Zoo.
foo:SomeElephant bar:livesInZoo foo:SomeZoo.

Without enabling inferencing with RDFS entailment, the data we have does not tell us whether foo:SomeElephant is a bar:Animal. When we do RDFS-based inferencing, we will get the following extra triple: 

foo:SomeElephant rdf:type bar:Animal.

The rdfs:domain statement dictates that any subject in triples where bar:livesInZoo is the predicate is of type bar:Animal. What RDFS entailment is not able to tell us is the relationship between bar:Animal and bar:Elephant. Due to inferencing we now know that foo:SomeElephant is both bar:Animal and bar:Elephant so these classes do intersect but there is no information to deduce whether they merely intersect, are equal or have a subclass relationship.

In RDFS 1.1, the domain and range statements do not carry any formal meaning and their interpretation is left up to the implementer. On the other hand in the 1.2 Working draft they are used as entailment rules for inferencing the types of individuals. Nevertheless in both versions, it is very clearly stated that the expected functionality of range is "the values of a property are instances of one or more classes" and domain "any resource that has a given property is an instance of one or more classes".

The example above demonstrated some of the limits and capabilities of RDFS entailment, but did not show an example of a logical inconsistency (which could in layman terms be interpreted as a "validation error"), meaning that the statements the triples make are in conflict and try to express contradictory states of affairs. An example of this in RDFS would be having conflicting datatypes for objects (e.g. declaring a resource to be of type xsd:integer and being also declared to be xsd:boolean when inferencing is enabled).

Examples of RDF vocabularies

[edit]

RDF vocabularies represented in RDFS include:[10]

  • FOAF: the source of the FOAF Vocabulary Specification is RDFS written in the RDFa syntax.[8]
  • Dublin Core: RDFS source is available in several syntaxes[12]
  • Schema.org: the source of their schema was originally RDFS written in the RDFa syntax until July 2020.[13][14]
  • Simple Knowledge Organization System (SKOS) developed the RDF schema titled as SKOS XL Vocabulary, which is an OWL ontology for the SKOS vocabulary that uses the OWL RDF/XML syntax, and hence makes use of a number of classes and properties from RDFS.[15]
  • The Library of Congress defines an RDF schema titled Metadata Authority Description Schema in RDF, or MADS/RDF for short. From the abstract, it is intended for use within their library and "information science (LIS) community". It allows for annotating special relational data, such as if an individual within a family is well-known via madsrdf:prominentFamilyMember.[16]
  • The UniProt database has an RDF schema for describing biochemical data, and is specialized towards describing proteins.[17]

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

RDF Schema

View on Grokipedia
from Grokipedia
RDF Schema (RDFS) is a (W3C) recommendation that extends the (RDF) by providing a standardized for describing classes, properties, and relationships among RDF resources, enabling the construction of lightweight ontologies within the framework. Developed as a semantic extension of RDF, RDFS introduces namespaces such as rdfs: and builds upon RDF's foundational concepts, syntaxes (like and ), and semantics to support . It defines key classes, including rdfs:Resource (encompassing all RDF entities), rdfs:Class (the class of all classes), and rdfs:Literal (for value representations), which allow resources to be categorized and related hierarchically. Essential properties include rdfs:domain (specifying the classes from which a property's subjects must be instances), rdfs:range (defining the classes of a property's objects), and rdfs:subClassOf (for establishing subclass relationships), providing mechanisms to constrain and enrich RDF vocabularies without the full expressiveness of more advanced ontology languages like . The specification, first recommended in 2004 as part of RDF 1.0 and revised in subsequent versions, has RDF Schema 1.1 as the current W3C Recommendation (2014) and RDF 1.2 Schema as a Working Draft published in 2025, incorporating updates such as new terms like rdf:dirLangString for language-tagged strings, rdf:JSON for JSON values, rdfs:Proposition for statement representations, and rdf:reifies for reification enhancements. These additions align RDFS with evolving RDF capabilities, including support for and structured , while maintaining its role as a foundational layer for knowledge representation on the web. RDFS is expressed entirely in RDF itself, ensuring compatibility and extensibility for applications in , , and knowledge graphs.

Overview

Definition and Purpose

RDF Schema (RDFS) is an extensible RDF vocabulary for specifying classes, properties, and their relationships, enabling the definition of constraints and richer descriptions for RDF resources. It builds upon the Resource Description Framework (RDF), the foundational data model for representing information on the Semantic Web. The primary purposes of RDFS are to provide a framework for ontology-like definitions that add semantic structure to RDF data, to support inference mechanisms over RDF graphs for deriving implicit knowledge, and to promote interoperability across Semantic Web applications by standardizing resource descriptions. Key benefits of RDFS include its support for subclassing hierarchies, domain and range restrictions on properties, and basic typing of resources, all while avoiding the greater expressiveness and complexity of full found in more advanced languages like . RDFS is formally defined in W3C recommendations, with the current version 1.1—published on February 25, 2014—serving as the standard and providing refined semantics along with extended datatype support.

Historical Development and Standards

RDF Schema originated in 1999 as an extension to the (RDF), developed under the W3C Metadata Activity to address the need for schema languages that could define vocabularies and constraints within XML-based and RDF ecosystems for metadata interoperability. The initial specification, edited by Dan Brickley and R.V. Guha, was published as a W3C Proposed Recommendation on March 3, 1999, building directly on the RDF Model and Syntax Recommendation from February 22, 1999, to enable machine-understandable descriptions of resources, such as those used in applications like resource discovery and the (P3P). This early work was led by the , established in 1997, which aimed to provide a lightweight vocabulary for describing RDF properties and classes in a environment. The specification evolved into RDF Schema 1.0, reaching Candidate Recommendation status on March 27, 2000, with a primary focus on defining core mechanisms for classes (e.g., rdfs:Class and ) and (e.g., rdfs:subClassOf, rdfs:domain, and rdfs:range) to support reuse and in RDF data models. Further refinements by the W3C RDF Core culminated in its formal adoption as a W3C Recommendation on February 10, 2004, as part of the RDF 1.0 suite, solidifying its role in providing basic type systems and constraints for RDF metadata without altering the underlying RDF syntax. RDF Schema 1.1, published as a W3C Recommendation on February 25, 2014, refined datatype support with additions like rdf:langString and rdf:HTML, clarified entailment rules for literals including rdf:XMLLiteral, and enhanced compatibility with modern tools. These updates, overseen by the RDF Working Group with editorial contributions from Guus Schreiber, aligned RDFS more closely with RDF 1.1 and addressed longstanding ambiguities in datatype handling and semantic extensions. Following the Recommendation, RDF Schema has seen minor errata and, in the RDF 1.2 draft (Working Draft, October 3, 2025), extensions including new terms like rdf:dirLangString for directional language-tagged strings, for JSON values, rdfs:Proposition for reified statements, and rdf:reifies for reification enhancements to support evolving RDF features, while maintaining core semantics. As part of the W3C standards track, RDFS occupies a foundational layer above core RDF for vocabulary definition but below for advanced ontological expressivity, ensuring modular in Web-scale data exchange.

Core Terminology

Classes and Class Hierarchy

In RDF Schema (RDFS), classes provide a mechanism for defining types of within the RDF , enabling the organization of knowledge through categorization and . The central class is rdfs:Class, which represents the set of all classes that can be used to classify RDF ; notably, rdfs:Class itself is an instance of rdfs:Class, allowing for self-referential typing. Every RDF is implicitly an instance of rdfs:Resource, the root class that serves as the superclass of all other classes, encompassing all entities describable in RDF. Class membership is formally established using the rdf:type property, where a triple such as (x, rdf:type, C) indicates that x belongs to the extension (or set of instances) of class C; the domain of rdf:type is rdfs:Resource, and its range is rdfs:Class. The in RDFS is constructed through the rdfs:subClassOf property, which defines subclass relationships between classes and supports transitive . If class A is declared a subclass of class B via (A, rdfs:subClassOf, B), then all instances of A are also instances of B, allowing properties and constraints defined for B to apply to A's instances. This relationship is transitive, meaning chains of subclass declarations propagate upward through the , and RDFS supports by permitting a class to have multiple superclasses via separate rdfs:subClassOf . However, RDFS does not enforce constraints, disjointness between classes, or other advanced taxonomic features found in more expressive ontologies. RDFS includes several built-in classes that exemplify the hierarchy, particularly for modeling collections. The rdfs:Container class acts as a superclass for container types, providing a foundational structure for grouping . Specific subclasses include rdf:Bag, which represents unordered collections where order of members does not matter; rdf:Seq, for ordered sequences where member position is significant; and rdf:Alt, denoting alternatives among mutually exclusive options. These container classes inherit from rdfs:Container and ultimately from rdfs:Resource, illustrating practical use of the subclass mechanism to extend the core vocabulary without altering the underlying RDF model.

Properties and Domains/Ranges

In RDF Schema (RDFS), properties are defined as resources that belong to the class rdf:Property, which itself is a subclass of rdfs:Resource, allowing properties to be declared using the rdf:type predicate to indicate their membership in this class. This enables properties to represent binary relations between resources in an RDF graph, facilitating the description of structured data beyond simple triples. The rdfs:domain property constrains the subjects of a given P by specifying one or more classes of which those subjects must be instances; for example, declaring ex:author rdfs:domain ex:Document implies that any resource serving as the subject of ex:author is inferred to be an instance of ex:Document. Similarly, the rdfs:range property restricts the objects of P to instances of specified classes, such as ex:author rdfs:range ex:[Person](/page/Person), which infers that objects of ex:author are instances of ex:[Person](/page/Person). These declarations support : if a triple S P O exists and P has a domain or range class C, then S rdf:type C or O rdf:type C is entailed, respectively. Properties can have multiple domains or ranges, in which case subjects or objects must be instances of all listed classes, promoting intersection-based constraints. RDFS restrictions are monotonic, meaning that adding further domain or range declarations to a property does not invalidate existing inferences but may strengthen them by introducing additional entailments. The rdfs:subPropertyOf relation further refines by establishing a : if P1 rdfs:subPropertyOf P2, then any triple using P1 entails a corresponding triple using P2, and this relation is transitive, allowing for of domains and ranges across subproperties. Support for datatypes in ranges was introduced in RDF Schema 1.0, where classes from (e.g., xsd:string or xsd:integer) can be used to constrain literal values; thus, ex:age rdfs:range xsd:integer ensures that objects of ex:age are integer literals, enabling validation of data types alongside class-based restrictions. This integration bridges RDF's resource-oriented model with typed literals, enhancing in semantic applications.

Built-in RDFS Vocabulary

The RDF Schema (RDFS) specification defines a core set of built-in classes and properties within its namespace, http://www.w3.org/2000/01/rdf-schema# (prefixed as rdfs:), which serve as the foundational vocabulary for describing RDF resources, classes, properties, and their relationships. These predefined terms enable the extension of RDF's basic data model by providing mechanisms for hierarchy, constraints, and annotations, all while remaining instances of RDF itself. All RDFS terms are RDF resources, allowing the vocabulary to be self-descriptive; for example, rdfs:Class is declared as an instance of rdfs:Class using the RDF triple rdfs:Class rdf:type rdfs:Class.

Key Classes

The RDFS vocabulary includes several fundamental classes that form the basis for schema definitions:
  • rdfs:[Resource](/page/Resource): The root class of everything describable by RDF, serving as the superclass of all other classes; every RDF resource is implicitly an instance of rdfs:[Resource](/page/Resource).
  • rdfs:Class: The class of all classes in RDF, used to declare types and hierarchies; it is itself a subclass of rdfs:[Resource](/page/Resource) and an instance of rdfs:Class.
  • rdfs:Literal: The class encompassing all literal values, such as strings or numbers, which are leaf nodes in RDF graphs with no further outgoing properties; it is a subclass of rdfs:[Resource](/page/Resource).
  • rdfs:[Container](/page/Container): A superclass for collections of resources that represent unordered or ordered sets; its subclasses include:
    • rdf:Bag (from the RDF namespace): An unordered container where member order does not matter.
    • rdf:Seq (from the RDF namespace): An ordered container where the sequence of members is significant.
    • rdf:Alt (from the RDF namespace): A container representing alternatives, where exactly one member is typically selected.
  • rdfs:Datatype: The class of all datatypes, which are used to constrain literal values; it is both a subclass and an instance of rdfs:Class. It supports integration with datatypes (e.g., xsd:string, xsd:integer) and RDF-specific datatypes (e.g., rdf:langString, rdf:[HTML](/page/HTML) from RDF 1.1; rdf:dirLangString, rdf:[JSON](/page/JSON) from RDF 1.2), by allowing them as instances of rdfs:Datatype, thereby enabling typed literals in RDF. Each instance of rdfs:Datatype is a subclass of rdfs:Literal.
  • rdfs:Proposition (RDF 1.2): A class for representing RDF statements (triples) as resources, facilitating reification and statement-level annotations.

Key Properties

RDFS also provides a set of predefined properties for establishing relationships, constraints, and metadata:
  • rdfs:subClassOf: Relates a subclass to its superclass, enabling class hierarchies; its domain and range are both rdfs:Class.
  • rdfs:subPropertyOf: Relates a subproperty to its superproperty, supporting property hierarchies; its domain and range are both rdf:Property.
  • rdfs:domain: Specifies the class of subjects to which a property applies; its domain is rdf:Property and range is rdfs:Class.
  • rdfs:range: Specifies the class of objects to which a property's values belong; its domain is rdf:Property and range is rdfs:Class.
  • rdfs:label: Provides a human-readable name or label for a resource; its domain is rdfs:Resource and range is rdfs:Literal.
  • rdfs:comment: Supplies a human-readable description or annotation for a resource; its domain is rdfs:Resource and range is rdfs:Literal.
  • rdfs:seeAlso: Indicates a resource providing additional information about the subject; its domain and range are both rdfs:Resource.
  • rdfs:isDefinedBy: Points to the resource that defines the subject, acting as a subproperty of rdfs:seeAlso; its domain and range are both rdfs:Resource.
  • rdfs:member: A superproperty of the membership properties for containers (e.g., rdf:_1, rdf:_2), relating a container to its members; its domain and range are both rdfs:Resource.
  • rdf:reifies (RDF 1.2): Relates a resource to the RDF statement (proposition) that it reifies; its domain and range are rdfs:Resource and rdfs:Proposition, respectively, enhancing reification capabilities.
These classes and properties collectively form a lightweight ontology that can be extended for domain-specific schemas, with rdfs:Datatype playing a crucial role in bridging RDFS to more precise value constraints from XML Schema.

Semantics and Inference

RDFS Entailment Rules

RDF Schema (RDFS) entailment provides a formal mechanism for inferring additional triples from an RDF graph based on the RDFS vocabulary, enabling semantic reasoning in a monotonic manner. This entailment regime extends RDF entailment by incorporating rules that handle class hierarchies, property domains and ranges, and typing constraints, allowing systems to derive implicit knowledge from explicit statements. RDFS can be understood as a decidable fragment of description logics, specifically corresponding to the description logic ALC with qualified number restrictions in its extended form, which ensures tractable inference for ontology-based applications. In RDFS semantics, entailment is defined model-theoretically: an RDF graph GG RDFS-entails another graph HH (denoted G⊨RDFSHG \models_{RDFS} H) if every RDFS interpretation that satisfies GG also satisfies HH. This definition aligns with simple entailment for RDF but extends it to account for RDFS-specific constructs like rdfs:subClassOf and rdfs:domain. The semantics is fully characterized by a set of 14 monotonic rules, known as the RDFS closure rules (rdfs1 through rdfs14), which generate the smallest graph containing all triples logically implied by the original graph under RDFS entailment. These rules are operational approximations of the , allowing forward-chaining engines to compute entailments efficiently without full . RDF 1.2 introduces rdfs14 to support typing of propositions derived from triple terms. The core RDFS entailment rules address key aspects of the vocabulary:
  • Subclass and Typing Rules: These handle inheritance in class hierarchies. For instance, rule rdfs9 infers instance membership in a superclass: if xxx rdfs:subClassOf yyy and zzz rdf:type xxx, then zzz rdf:type yyy. Reflexivity (rdfs10: a class is a subclass of itself) and transitivity (rdfs11: chaining subClassOf relations) ensure hierarchical closure. Additionally, rdfs8 states that every class is a subclass of rdfs:Resource.
  • Domain and Range Rules: Rule rdfs2 infers subject typing from property domains: if aaa rdfs:domain xxx and yyy aaa zzz, then yyy rdf:type xxx. Symmetrically, rdfs3 infers object typing from ranges: if aaa rdfs:range xxx and yyy aaa zzz, then zzz rdf:type xxx.
  • Property Rules: Similar to classes, properties support subproperty relations with reflexivity (rdfs6), transitivity (rdfs5), and substitution (rdfs7: if aaa rdfs:subPropertyOf bbb and xxx aaa yyy, then xxx bbb yyy).
  • Resource and Datatype Rules: Rule rdfs4 ensures all subjects and objects are instances of rdfs:[Resource](/page/Resource). For datatypes, rdfs1 declares datatype IRIs as instances of rdfs:Datatype, and rdfs13 infers they are subclasses of rdfs:Literal. Container-related rules (rdfs12) treat membership properties as subproperties of rdfs:member. The new rule rdfs14 types proposition terms from triple terms as instances of rdfs:[Proposition](/page/Proposition).
The complete set of 14 RDFS entailment rules is presented below for reference:
RulePremisesConclusionPurpose
rdfs1aaa in D (set of supported datatypes)aaa rdf:type rdfs:DatatypeDatatype typing
rdfs2aaa rdfs:domain xxx, yyy aaa zzzyyy rdf:type xxxDomain inference
rdfs3aaa rdfs:range xxx, yyy aaa zzzzzz rdf:type xxxRange inference
rdfs4xxx appears in any triplexxx rdf:type rdfs:ResourceTerm as resource
rdfs5xxx rdfs:subPropertyOf yyy, yyy rdfs:subPropertyOf zzzxxx rdfs:subPropertyOf zzzSubproperty transitivity
rdfs6xxx rdf:type rdf:Propertyxxx rdfs:subPropertyOf xxxSubproperty reflexivity
rdfs7aaa rdfs:subPropertyOf bbb, xxx aaa yyyxxx bbb yyyProperty inheritance
rdfs8xxx rdf:type rdfs:Classxxx rdfs:subClassOf rdfs:ResourceClass as resource subclass
rdfs9xxx rdfs:subClassOf yyy, zzz rdf:type xxxzzz rdf:type yyySubclass instance inheritance
rdfs10xxx rdf:type rdfs:Classxxx rdfs:subClassOf xxxSubclass reflexivity
rdfs11xxx rdfs:subClassOf yyy, yyy rdfs:subClassOf zzzxxx rdfs:subClassOf zzzSubclass transitivity
rdfs12xxx rdf:type rdfs:ContainerMembershipPropertyxxx rdfs:subPropertyOf rdfs:memberContainer membership
rdfs13xxx rdf:type rdfs:Datatypexxx rdfs:subClassOf rdfs:LiteralDatatype as literal subclass
rdfs14Graph contains a triple term << (aaa bbb ccc) >><< (aaa bbb ccc) >> rdf:type rdfs:PropositionProposition typing for triple terms
Applying these rules iteratively produces the RDFS closure of a graph, which includes all entailed triples and serves as the basis for further reasoning in systems supporting RDFS entailment, such as query evaluation under entailment regimes. This closure is finite and computable, preserving the decidability of RDFS inference.

Interpretations and Closure

In the model-theoretic semantics of RDF Schema (RDFS), an interpretation II is a structure that assigns meanings to RDF terms in a way that extends the semantics of RDF itself. Specifically, an RDFS interpretation II recognizes a including the RDFS terms and satisfies a set of datatype IRIs DD, with II mapping resources to a non-empty set IRIR (the interpretation domain), literals to values via ILIL, and to binary relations via IEXTIEXT. For a triple (s,p,o)(s, p, o) to hold in II, the condition (I(s),I(p),I(o))∈IEXT(I(p))(I(s), I(p), I(o)) \in IEXT(I(p)) must be satisfied, where IEXTIEXT denotes the extension of . Additionally, RDFS introduces the class domain IC=IEXT(I(rdfs:Class))IC = IEXT(I(\mathtt{rdfs:Class})) as a of IRIR, and the domain IP=IEXT(I(rdf:Property))IP = IEXT(I(\mathtt{rdf:Property})) as a of ICIC, ensuring that are themselves classes. RDF 1.2 extends this to support triple terms, which denote propositions interpreted in IRIR and typed via rdfs:Proposition. Key mappings in RDFS interpretations enforce structural constraints on the vocabulary. The term rdfs:Class\mathtt{rdfs:Class} is interpreted such that I(rdfs:Class)∈ICI(\mathtt{rdfs:Class}) \in IC, with its extension comprising all classes in the . The rdfs:subClassOf\mathtt{rdfs:subClassOf} relation is reflexive and transitive over ICIC, meaning that if (x,y)∈IEXT(I(rdfs:subClassOf))(x, y) \in IEXT(I(\mathtt{rdfs:subClassOf})), then ICEXT(x)⊆ICEXT(y)ICEXT(x) \subseteq ICEXT(y), where ICEXTICEXT maps classes to their extensions (sets of instances in IRIR). For rdfs:domain\mathtt{rdfs:domain} and rdfs:range\mathtt{rdfs:range}, if (x,y)∈IEXT(I(rdfs:domain))(x, y) \in IEXT(I(\mathtt{rdfs:domain})) and (u,v)∈IEXT(x)(u, v) \in IEXT(x), then u∈ICEXT(y)u \in ICEXT(y); a symmetric condition applies to range, constraining the domains and ranges of properties in IPIP. These mappings enable hierarchical and constraint-based reasoning beyond plain RDF. RDFS closure is computed using fixed-point semantics, where entailment rules are applied iteratively to an RDF graph until no new can be derived, yielding the RDFS closure (or deductive closure) of the graph. This process ensures completeness for RDFS entailment, as the fixed point coincides with the set of all entailed . For ground RDF graphs (without blank nodes), RDFS entailment is decidable and can be computed in time, making it efficient for practical systems. The RDF 1.2 semantics fully align with RDF 1.2, superseding earlier versions by treating literals as denoting themselves under simple entailment and providing D-interpretations for datatypes. Literals map via lexical-to-value functions, with mandatory support for rdf:langString, rdf:dirLangString, and xsd:string; however, semantics for user-defined datatypes are partial and incomplete unless fully specified, limiting entailment guarantees for custom types. In contrast to RDF semantics, which provide only basic interpretations for without vocabulary constraints, RDFS semantics impose additional conditions on the interpretation of its built-in terms (e.g., IP⊆ICIP \subseteq IC), enabling richer entailments such as class subsumption and domain-range that are not possible in plain RDF.

Applications

Defining Custom Vocabularies

RDF Schema enables the creation of custom vocabularies by allowing users to define their own classes and , extending the basic RDF to describe domain-specific structures. The process begins with declaring a class as an instance of rdfs:Class, which groups resources that share common characteristics, and using rdf:type to identify instances of that class. Hierarchies are established through rdfs:subClassOf, a transitive that indicates one class is a specialization of another, ensuring that instances of a subclass are also instances of its superclasses. are defined as instances of rdf:Property and constrained using rdfs:domain to specify the expected class of subjects and rdfs:range to specify the expected class of objects in where the serves as the predicate. With the release of RDF Schema 1.2 in October 2025, custom vocabularies can now leverage new terms such as rdfs:Proposition (a class for RDF statements) and rdf:reifies (a property linking resources to the statements they reify), facilitating advanced modeling of provenance, annotations, and statement-level metadata in knowledge graphs and linked data applications. A practical example illustrates this process: to define a vocabulary for describing people, one might declare a Person class as a subclass of rdfs:Resource (the root class of all resources) using rdfs:subClassOf. Then, define an age property with Person as its domain and xsd:integer (from XML Schema datatypes, integrated with RDF) as its range, ensuring that only instances of Person can have an age value and that such values must be integers. This can be expressed in Turtle syntax as follows:

:Person rdf:type rdfs:Class ; rdfs:subClassOf rdfs:Resource . :age rdf:type rdf:Property ; rdfs:domain :Person ; rdfs:range xsd:integer .

:Person rdf:type rdfs:Class ; rdfs:subClassOf rdfs:Resource . :age rdf:type rdf:Property ; rdfs:domain :Person ; rdfs:range xsd:integer .

Such declarations provide a for RDF , facilitating validation and . Best practices for defining custom vocabularies include adding human-readable documentation with rdfs:label for names and rdfs:comment for descriptions to enhance reusability and understanding. For representing collections, RDF Schema leverages built-in container classes like rdf:Seq (ordered lists), rdf:Bag (unordered sets), and rdf:Alt (alternatives) to model groups of . Additionally, designs should ensure monotonicity—meaning that adding new assertions does not invalidate existing —to maintain compatibility in distributed environments. Tools such as Protégé, an open-source editor, and Apache Jena, a Java framework for RDF processing, support RDFS validation by checking data against custom schemas and performing basic entailment reasoning. Custom RDFS vocabularies are commonly used in initiatives to create domain-specific ontologies; for instance, schema.org employs RDF Schema as the foundation for its extensible set of types and properties to markup for search engines. However, RDF Schema has limitations in expressiveness; it lacks support for advanced axioms such as property symmetry, transitivity beyond subclass hierarchies, or constraints, which must be deferred to more expressive languages like .

Relation to RDF and OWL

RDF Schema (RDFS) serves as a specialized vocabulary built directly upon the (RDF), extending its foundational to enable basic schema definitions and . Specifically, RDFS is defined as an RDF vocabulary, meaning all RDFS constructs—such as classes, properties, domains, and ranges—are expressed using RDF triples, ensuring that any valid RDFS graph is inherently a valid RDF graph. This tight integration implies that RDF entailment, which handles simple graph consistency and vocabulary interpretation, forms a proper subset of RDFS entailment, where additional rules for subclassing, subproperties, and typing are applied to derive implicit knowledge from explicit RDF statements. RDFS benefits from the broad ecosystem of RDF serialization formats and query languages, which natively accommodate its structures without requiring extensions. Formats such as , Turtle, and fully support the serialization of RDFS vocabularies and data, allowing seamless exchange of RDFS-enhanced RDF across systems. Similarly, the query language includes an RDFS entailment regime, enabling queries to operate over the RDFS closure of RDF graphs—meaning inferred from RDFS rules can be considered during without materializing the closure explicitly. In relation to the Web Ontology Language (OWL), RDFS provides the semantic foundation, particularly for OWL DL, where OWL ontologies typically import the to leverage its class and mechanisms. OWL extends RDFS expressivity by introducing advanced constructs like owl:equivalentClass for class equivalence, owl:disjointWith for disjointness, and complex restrictions on properties, all while preserving all RDFS entailments to maintain . The , published as a W3C recommendation in , explicitly incorporates RDFS as a compatible profile, allowing OWL reasoners to handle pure RDFS ontologies; with RDF 1.2, core RDFS semantics remain compatible, though new features like triple reification may require future OWL updates for full integration. Any semantic mismatches, such as OWL's handling of open-world assumptions versus potential closed-world interpretations, are managed through isolated extensions rather than altering core RDFS behavior. This interoperability facilitates practical applications, where RDFS supports lightweight reasoning in OWL Lite profiles from OWL 1, bridging simple schema validation with more sophisticated ontological descriptions. OWL reasoners, such as , routinely process RDFS as a default subset of OWL 2 DL, performing classifications and consistency checks on RDFS constructs efficiently within their broader engines. Briefly, OWL extends RDFS classes and properties with additional axioms, such as restrictions, to model more intricate domain relationships.
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.