Examples of RDF Validation

SPARQL

SPARQL has been used to validate data, e.g. to test the results of parsing RDFa (see RDFa Test Harness). This SPARQL query produces a table showing the validation results testing a representative sample of the identified validation errors:

PREFIX : <http://www.w3.org/2012/12/rdf-val/SOTA-ex#>
PREFIX foaf: <http://xmlns.com/foaf/0.1/'>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>

SELECT DISTINCT ?issue
  (if(BOUND(?t), "passed", "missing") AS ?typeArc)
  (if(BOUND(?state) && (?state=:unassigned || ?state=:assigned),
      "passed", "invalid") AS ?stateValue)
  (if(BOUND(?reportedBy), "passed", "missing") AS ?reportedByArc)
  (if(BOUND(?reportedOn), "passed", "missing") AS ?reportedOnArc)
  (if(!BOUND(?reportedByCount), "expected 1, got 0", 
   if(?reportedByCount=1, "passed", 
      CONCAT("expected 1, got ", STR(?reportedByCount)))) AS ?reportedByArcCount)
  (if(!BOUND(?reproducedOn) || ?reproducedOn > ?reportedOn,
      "passed", "bad sequence") AS ?reproducedOnSequence)
  (if(BOUND(?reportedOn), "passed", "missing") AS ?reportedOnArc)
  (if(BOUND(?missingRelatedIssuesStr), ?missingRelatedIssuesStr, "passed")
      AS ?missingRelatedIssues)

  WHERE {

  # Get all viable :Issues by use of related predicates.
  { SELECT DISTINCT ?issue WHERE {
           { ?issue a :Issue }
     UNION { ?issue :reportedBy|:reportedOn|:reproducedBy|:reproducedOn|:related ?rprt }
    }
  }

  # Test for a type arc and state.
  OPTIONAL { ?issue a ?t FILTER (?t = :Issue) }
  OPTIONAL { ?issue :state ?state }

  # Must have 1 reportedBy.
  OPTIONAL { SELECT ?issue
      (SAMPLE(?reportedBy1) AS ?reportedBy)
      (COUNT(?reportedBy1) AS ?reportedByCount)
     WHERE {
      OPTIONAL { ?issue :reportedBy ?reportedBy1 }
    } GROUP BY ?issue
  }
  OPTIONAL { ?issue :reportedOn ?reportedOn }
  OPTIONAL { ?issue :reproducedBy ?reproducedBy }
  OPTIONAL { ?issue :reproducedOn ?reproducedOn }

  # All :related issues must be known entities.
  OPTIONAL {
    SELECT ?issue
      (GROUP_CONCAT(CONCAT("<", STR(?referent), ">"))
       AS ?missingRelatedIssuesStr) {

          # List of missing issues related to ?issue.
          SELECT ?issue ?referent
             (SUM(if(BOUND(?referentP), 1, 0)) AS ?referentCount)
           WHERE {
            ?issue :related ?referent
               OPTIONAL { ?referent ?referentP ?referentO }
          } GROUP BY ?issue ?referent
          HAVING (SUM(if(BOUND(?referentP), 1, 0)) = 0)
    } GROUP BY ?issue
  }
}

The query results associates pass/fail/error messages with validation tests for each tested entity:

OWL Conventional Use

The Web Ontology Language offers a fairly complex language for declaring restrictions on the use of predicates on a given type, as well as the equivalence or disjointness of given resources and classes.

@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix : <http://www.w3.org/2012/12/rdf-val/SOTA-ex#> .
@prefix foaf: <http://xmlns.com/foaf/0.1/'> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .


:Issue a owl:Class ;
    rdfs:subClassOf
        [ owl:onProperty :state        ; owl:cardinality 1 ] ,
        [ owl:onProperty :reportedBy   ; owl:cardinality 1 ] ,
        [ owl:onProperty :reportedOn   ; owl:cardinality 1 ] ,
        [ owl:onProperty :reproducedBy ; owl:minCardinality 0 ] ,
        [ owl:onProperty :reproducedOn ; owl:minCardinality 0 ] ,
        [ owl:onProperty :related      ; owl:minCardinality 0 ] .

:state        a owl:ObjectProperty ,
                owl:FunctionalProperty ; rdfs:domain :Issue ; rdfs:range :ValidState .
:related      a owl:ObjectProperty     ; rdfs:domain :Issue ; rdfs:range :Issue .
:reportedBy   a owl:ObjectProperty     ; rdfs:domain :Issue ; rdfs:range foaf:Person .
:reportedOn   a owl:DatatypeProperty   ; rdfs:domain :Issue ; rdfs:range xsd:dateTime .
:reproducedBy a owl:ObjectProperty     ; rdfs:domain :Issue ; rdfs:range foaf:Person .
:reproducedOn a owl:DatatypeProperty   ; rdfs:domain :Issue ; rdfs:range xsd:dateTime .
:ValidState owl:oneOf ( :unassigned :assigned ) .

foaf:Person rdfs:subClassOf foaf:Agent ;
    rdfs:subClassOf
        [ owl:onProperty foaf:givenName  ; owl:minCardinality 1 ] ,
        [ owl:onProperty foaf:familyName ; owl:cardinality 1 ] ,
        [ owl:onProperty foaf:phone      ; owl:minCardinality 0 ] ,
        [ owl:onProperty foaf:mbox       ; owl:cardinality 1 ] .

foaf:givenName  a owl:DatatypeProperty ; rdfs:domain foaf:Person ; rdfs:range xsd:string .
foaf:familyName a owl:DatatypeProperty ; rdfs:domain foaf:Person ; rdfs:range xsd:string .
foaf:phone      a owl:DatatypeProperty ; rdfs:domain foaf:Person ; rdfs:range xsd:anyURI .
foaf:mbox       a owl:ObjectProperty   ; rdfs:domain foaf:Person ; rdfs:range rdfs:Resource .


[ a owl:AllDisjointClasses ;
  owl:members ( :Issue foaf:Agent ) ] .

[ a owl:AllDisjointProperties ;
  owl:members ( :state :related
                :reportedBy :reportedOn
                :reproducedOn ) ] .

[ a owl:AllDifferent ;
  owl:members ( <issue3> <issue4>  <issue7>
                <user2> <user6>
                :unassigned :assigned :unsinged ) ] .

Resource Shapes

OSLC Resource Shape provides a vocabulary for describing the properties of typed nodes.

@prefix ex: <http://www.w3.org/2012/12/rdf-val/SOTA-ex#> .
@prefix rs: <http://www.w3.org/2012/12/rdf-val/SOTA-RS#> .
@prefix : <http://open-services.net/ns/core#> .
@prefix foaf: <http://xmlns.com/foaf/0.1/'> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

<#IssueShape> a :ResourceShape ;
    :property [
        :name "state" ; :propertyDefinition ex:state ;
        :valueType xsd:string ;
        :occurs :Exactly-one ;
    ] ;

    :property [
        :name "reportedBy" ; :propertyDefinition ex:reportedBy ;
        :range foaf:Person ;
        :valueShape <#UserShape> ;
        :occurs :Exactly-one ;
        :representation :Either 
    ] ;

    :property [
        :name "reportedOn" ; :propertyDefinition ex:reportedOn ;
        :valueType xsd:dateTime ;
        :occurs :Exactly-one ;
    ] ;

    :property [
        :name "reproducedBy" ; :propertyDefinition ex:reproducedBy ;
        :range foaf:Person ;
        :valueShape <#UserShape> ;
        :occurs :Zero-or-many
        :representation :Either 
    ] ;

    :property [
        :name "reproducedOn" ; :propertyDefinition ex:reproducedOn ;
        :valueType xsd:dateTime ;
        :occurs :Zero-or-many
    ] ;

    :property [
        :name "related" ; :propertyDefinition ex:related ;
        :range ex:Issue ;
        :valueShape <#IssueShape> ;
        :occurs :Zero-or-many
        :representation :Either 
    ] ;
.

<#UserShape> a :ResourceShape ;
    :property [
        :name "givenName" ; :propertyDefinition foaf:givenName ;
        :valueType xsd:string ;
        :occurs :One-or-many ;
    ] ;

    :property [
        :name "familyName" ; :propertyDefinition foaf:familyName ;
        :valueType xsd:string ;
        :occurs :Exactly-one ;
    ] ;

    :property [
        :name "phone" ; :propertyDefinition foaf:phone ;
        :range rdf:Resource ;
        :occurs :Zero-or-many ;
    ] ;

    :property [
        :name "mbox" ; :propertyDefinition foaf:mbox ;
        :range rdf:Resource ;
        :occurs :Exactly-one ;
    ] ;
.

Note that the range identifies the RDF type of the object of a property while its valueShape locates the Resource Shape. This permits re-use of common vocabularies, e.g. FOAF for users, and even context-sensitive rules, for instance if the user who reproduced an issue had different validation constraints than the user who reported one.

SPARQL Inferencing Notation (SPIN)

The SPIN's (spin:constraint) connects a class to a query which validates an instance of that class, e.g. this excerpt from Holger Knublauch's write up of the SPIN validating this use case:

:Issue a owl:Class ;
  spin:constraint [ a sp:Ask ;
      sp:text """# Issue was reproduced before being reported
ASK WHERE {
    ?this <http://www.w3.org/2012/12/rdf-val/SOTA-ex#reproducedOn> ?reproducedOn .
    ?this <http://www.w3.org/2012/12/rdf-val/SOTA-ex#reportedOn> ?reportedOn .
    FILTER (?reproducedOn < ?reportedOn) .
}"""^^xsd:string ;             # returning TRUE signals an error.
    ] ;
  spin:constraint [ a spl:ObjectCountPropertyConstraint ;
      arg:maxCount 1 ;
      arg:property :reportedBy ;
    ] ;
        

The constraint on :reporetedBy at the bottom is a providing additional cardinality constraints. See spl:Attribute and spl:ObjectCountPropertyConstraint in the supporting library, e.g.

ASK {
  { FILTER (
      ?minCount &&
      spin:objectCount(spin:_this, ?predicate) < ?minCount) }
  UNION
  { FILTER (
      ?maxCount &&
      spin:objectCount(spin:_this, ?predicate) > ?maxCount) }
  UNION
  { FILTER (BOUND(?valuetype)) 
    spin:_this ?predicate ?value
    FILTER (spl:instanceOf(?value, ?valueType)) }
}        

A SPIN engine may then evaluate those constraint checks for one or all instances of those classes via sets of rules like:

# Assign a type arc where there is none.
rdfs:Resource
  spin:rule [
      rdf:type sp:Construct ;
      sp:text """CONSTRUCT {
    ?instance a ?domain .
}
WHERE {
    ?property <http://www.w3.org/2000/01/rdf-schema#domain> ?domain .
    ?instance ?property ?anyValue .
    FILTER NOT EXISTS {
        ?instance a ?anyType .
    } .
}"""^^xsd:string ;
    ] ;
.
        

These can be combined with OWL restrictions interpreted with closed world and unique name assumptions (see the earlier discussion of OWL - Validation with UNA and Closed-World).

:state a owl:ObjectProperty ;
  rdfs:domain :Issue ;
  rdfs:label "state"^^xsd:string ;
  rdfs:range :ValidState .

:ValidState a owl:Class ; rdfs:subClassOf owl:Thing .
:assigned a :ValidState .
:unassigned a :ValidState .
        

Specialized Grammar

It is theoretically possible, though yet unimplemented, to define RDF patterns as a BNF-like grammar. RelaxNG compact syntax demonstrates the applicability of such a grammar to a non-character-based model. Such a syntax could capture the expressivity of something like Resource Shapes. Here's an example inspired by RelaxNG Compact Syntax and SPARQL.

PREFIX ex: <http://www.w3.org/2012/12/rdf-val/SOTA-ex#>
PREFIX rs: <http://www.w3.org/2012/12/rdf-val/SOTA-RS#>
PREFIX: <http://open-services.net/ns/core#>
PREFIX foaf: <http://xmlns.com/foaf/0.1/'>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>

IssueShape (
    ex:state ( xsd:string )
    ex:reportedBy ( foaf:Person @UserShape )
    ex:reportedOn ( xsd:dateTime )
    ex:reproducedBy ( foaf:Person @UserShape )*
    ex:reproducedOn ( xsd:dateTime )*
    ex:related ( ex:Issue @IssueShape )*
)

UserShape (
    foaf:givenName ( xsd:string )+
    foaf:familyName ( xsd:string )
    foaf:phone ( rdf:Resource )*
    foaf:mbox ( rdf:Resource )
)

possible features

Here are some ideas for features that people have mentioned so far:

• namespace-sensitivity - rules that apply to everything in a specified namespace, e.g. foaf:*. This is similar to the nsName and anyName name classes in RelaxNG.

RDF Schema with no Inference

RDFS defines the types expected for the subject or object of a predicate. It would be possible to insist that all nodes in "valid" documents list their types. This approach of validation would report an error every time RDF Schema inference added a new type. This would make some errors moderately visible to the user.

Eyeball

While schema-alone doesn't tell us about missing properties, we can assume the schema to be a complete list of the available terms. Eyeball uses parsed schemas to spell-check the properties and class names in an RDF graph. Eyeball also sanity checks the schema implied by the document for IRI validity and reachability (e.g. no file: URLs), language tag validity, and adherence to prefix conventions (don't use dc: to refer to FOAF).