Shape Expressions Schemas

We present Shape Expressions (ShEx), an expressive schema language for RDF designed to provide a high-level, user friendly syntax with intuitive semantics. ShEx allows to describe the vocabulary and the structure of an RDF graph, and to constrain the allowed values for the properties of a node. It includes an algebraic grouping operator, a choice operator, cardinalitiy constraints for the number of allowed occurrences of a property, and negation. We define the semantics of the language and illustrate it with examples. We then present a validation algorithm that, given a node in an RDF graph and a constraint defined by the ShEx schema, allows to check whether the node satisfies that constraint. The algorithm outputs a proof that contains trivially verifiable associations of nodes and the constraints that they satisfy. The structure can be used for complex post-processing tasks, such as transforming the RDF graph to other graph or tree structures, verifying more complex constraints, or debugging (w.r.t. the schema). We also show the inherent difficulty of error identification of ShEx.

💡 Research Summary

The paper introduces Shape Expressions (ShEx), a high‑level schema language specifically designed for RDF graphs. ShEx provides a concise, human‑readable syntax together with a well‑defined semantics that allow developers to describe both the vocabulary (the set of predicates) and the structural constraints (how those predicates may be combined around a node). The language supports a rich set of operators: grouping (comma), choice (vertical bar), cardinality (*, +, {m,n}), negation (!), and two modifiers—CLOSED/ˆCLOSED and EXTRA—that control the openness of a shape with respect to forward and inverse properties.

A “shape” is the central notion: it is a collection of triple constraints that must be satisfied by the neighbourhood of a focus node. Each triple constraint can be forward (prop K) or inverse (ˆprop K) and the value class K may be a literal datatype, an IRI, or a reference to another shape (using @). By nesting shapes with grouping, choice, and repetition, ShEx can express complex patterns such as “a node must have a foaf:name string and either a foaf:givenName and foaf:lastName pair or a single foaf:name”, or “an Issue node must be reported by an entity that satisfies both UserShape and ClientShape, be reproduced by at least one TesterShape and one or more ProgrammerShape, and have incoming is:affectedBy arcs from Users”.

The authors present a detailed running example based on a bug‑tracking system, defining five shapes (TesterShape, ProgrammerShape, UserShape, ClientShape, IssueShape) and showing how the various operators are combined to capture real‑world constraints, including repeated properties, inverse arcs, and optional extra properties. The EXTRA modifier is illustrated as a way to relax the default closed‑world assumption for selected predicates, while CLOSED and ^CLOSED enforce strict closed‑world semantics for forward and inverse arcs respectively.

The core technical contribution is a validation algorithm that, given a focus node and a shape, recursively checks the node’s neighbourhood against the shape’s constraints. The algorithm produces a “proof” object—a set of trivially verifiable associations of the form (node, constraint) that can be inspected by humans or consumed by downstream tools. This proof enables post‑processing tasks such as graph‑to‑tree transformations, additional constraint checking, or debugging of schema violations. The algorithm handles recursion, negation, and the CLOSED/EXTRA modifiers, and the paper provides practical implementation guidelines (caching, ordering of constraint checks, etc.).

Complexity analysis shows that full ShEx validation (with negation and CLOSED/EXTRA) is NP‑complete, confirming that the problem is as hard as SAT. However, the authors identify tractable fragments, notably deterministic single‑occurrence shape expressions, for which validation can be performed in polynomial time. They also prove that the error‑identification problem—determining a minimal set of offending triples—is NP‑hard, implying that efficient exact solutions are unlikely and that heuristic or approximate methods are needed in practice.

Implementation aspects are covered briefly: several open‑source validators exist, supporting both the compact ShExC syntax and the JSON‑based ShExJ representation. An extension mechanism allows embedding executable “semantic actions” within a schema, enabling calls to external services, complex value range checks, or generation of output in other formats (e.g., XML).

In summary, the paper delivers a comprehensive treatment of ShEx: a expressive yet approachable schema language for RDF, a rigorous semantics, a practical validation algorithm with proof generation, and an analysis of computational limits. ShEx fills a gap between the open‑world flexibility of OWL and the need for precise structural validation in many real‑world RDF applications, offering a toolset that can be adopted both by developers building data pipelines and by researchers exploring graph data quality.