This document describes Shapes Constraint Language (SHACL) Inference Rules.

This specification is published by the Data Shapes Working Group .

Introduction

Inference Rules

        # This box represents a shapes graph

        # This box represents a data graph.

        # This box represents an output results graph

          # This box contains textual definitions. 

Outline

SHACL rules infer new triples. The input is a data graph and a shape graph with rules, the output is a graph of inferred triples that do not occur in the data graph.

Data:

   :A :fatherOf :X .
   :B :motherOf :X .
   :C :motherOf :A .

Rules:

RULE { ?x :childOf ?y } WHERE { ?y :fatherOf ?x }
RULE { ?x :childOf ?y } WHERE { ?y :motherOf ?x }

RULE { ?x :descendedFrom ?y } WHERE { ?x :childOf ?y }
RULE { ?x :descendedFrom ?y } WHERE { ?x :childOf ?z . ?z :childOf ?y }

will conclude that: :X is the child of :a and :B. and that :X is descendedFrom :C

Shape Rules Data Model

The Shape Rules Data Model

"Abstract syntax" and "data model" are synonymous so this could be "Rules Abstract Syntax". "Rules Data model" has the advantage that "syntax" is left for the concrete syntaxes. Downside - it's "rules data" not "data".

variable

[ sh:var "name" ]

node expression

Link to shacl12-node-expr#? -- needs to be single value, list arguments. Often called an expression.

data block

A data block is a set of triples. These form extra facts that are included in the inference process.

triple template

A triple template is 3-tuple where each element is either a variable or an RDF term (including being a triple term). [=Triple templates=] appear in the [=head=] of a [=rule=].

triple pattern

A triple pattern is 3-tuple where each element is either a variable, or an RDF term (including being a triple term). [=Triple patterns=] appear in the [=body=] of a [=rule=].

condition expression

A condition expression is a function, or functional form, that evaluates to true or false. [=Condition expressions=] appear in the [=body=] of a [=rule=].

assignment

An assignment is a pair of a variable, called the assignment variable, and an expression, called the assignment expression. [=Assignments=] appear in the [=body=] of a [=rule=].

rule

A rule is a pair of a [=rule head=] (often just "head") and a [=rule body=] (often just "body").

rule head

A rule head is a sequence where each element of the sequence is a [=triple template=].

rule body

A rule body is a sequence where each element of the sequence is a [=triple pattern=], a [=condition expression=] or an [=assignment=].

rule set

A rule set is a collection of zero or more rules.

In a [=triple pattern=] or a [=triple template=], position 1 of the tuple is informally called the subject; position 2 is informally called the predicate position 3 is informally called the object.

Concrete Syntax forms for Shapes Rules

• RDF Rules Syntax
• Compact Rules Syntax>

The compact syntax has an equivalent RDF syntax form.
Well-formed RDF syntax can be translated to the compact syntax.

Compact:

PREFIX : <http://example/>

DATA { :x :p 1 ; :q 2 . }

RULE { ?x :bothPositive true . } 
WHERE { ?x :p ?v1  FILTER ( ?v1 > 0 )  ?x :q ?v2  FILTER ( ?v2 > 0 )  }

RULE { ?x :oneIsZero true . } 
WHERE { ?x :p ?v1 ;  :q ?v2  FILTER ( ( ?v1 = 0 ) || ( ?v2 = 0 ) )  }

RDF:

PREFIX :       <http://example/>
PREFIX rdf:    <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX sh:     <http://www.w3.org/ns/shacl#>
PREFIX sparql: <http://www.w3.org/ns/sparql#>

:ruleSet-1
  rdf:type sh:RuleSet;
  sh:data (
    <<( :x :p 1 )>>
    <<( :x :q 2 )>>
  );
  sh:ruleSet (
    [
      rdf:type sh:Rule;
      sh:head (
        [ sh:subject [ sh:var "x" ] ; sh:predicate :bothPositive; sh:object true ]
      )
      sh:body (
        [ sh:subject [ sh:var "x" ]; sh:predicate :p; sh:object [ sh:var "v1" ] ]
        [ sh:expr [ sparql:greaterThan ( [ sh:var "v1" ] 0 ) ] ]
        [ sh:subject [ sh:var "x" ] ; sh:predicate :q; sh:object [ sh:var "v2" ] ]
        [ sh:expr [ sparql:greaterThan ( [ sh:var "v2" ] 0 ) ] ]
      );
    ]
    [
      rdf:type sh:Rule;
      sh:head (
        [ sh:subject [ sh:var "x" ] ; sh:predicate :oneIsZero ; sh:object true ]
      )
      sh:body (
        [ sh:subject [ sh:var "x" ] ; sh:predicate :p ; sh:object [ sh:var "v1" ] ]
        [ sh:subject [ sh:var "x" ] ; sh:predicate :q ; sh:object [ sh:var "v2" ] ]
        [ sh:expr [ sparql:function-or (
              [ sparql:equals ( [ sh:var "v1" ] 0 ) ]
              [ sparql:equals ( [ sh:var "v2" ] 0 ) ]
            ) ]
        ]
      );
    ]
  ) .

Shape Rules Evaluation

This section defines the outcome of evaluating a rule set on given data. It does not prescribe the algorithm as the method of implementation. An implementation can use any algorithm that generates the same outcome.

Inputs: data graph G and a rule set RS.
Output: an RDF graph GI of inferred triples

The inferred triples does not include any triple present in the set of triples of G.

Let F(arg1, arg2, ...) be an expression.
where arg1, arg2 are RDF terms.

Let [x/row] be
    if x is an RDF term, the [x/row] is x
    if x is a variable then [x/row] is the value of x in the row 
    ## By well-formedness, it is an error if x is not in the row.

eval(F(expr1, expr2), row) = F(eval(expr1, row), eval(expr2, row))
eval(FF(expr1, expr2) , row) = ... things that are not functions like IF

let R be a well-formed rule.
let rule R = (head, body) where
             H is the sequence of triple templates in the head
             B is the sequence of triple patterns, condition expressions,
                and assignments in the body

let R : map variable to RDF term as a set of pairs (variable, RDF term)

# "solution"
let T :list of B

Initial T = empty list

# Evaluate rule body
for each rule element rElt:
    if rElt is a triple pattern:
        T1 = empty list
    for each row in T:
      T1 = empty list
      for each matches m set of (var,term)
          row1 = row union (var, term)
          add row1 to T1
          endfor
    T = T1
    endif   

    if rElt is a condition expression F:
        T1 = empty list
        for each row in T:
            if ( eval(F,B) )
                add R to T1
                endif   
        endfor
    T = T1
    endif

    if rElt is an assignment(V, expr)
        T1 = empty list
        for each row in T:
            let x = eval(expr, row)
            let R1 = R union (V, x)
            add R1 to T1
            endfor
        T = T1
        endif
    endfor

# Evaluate rule head
let H = empty set
for each R in T:
    Let S = set of triples obtained by replacing variables 
            in the triple templates of the head with values from R
    define [head(R)/row]
    H = H union S
    endfor

result eval(R, G) is H

Let G be the input RDF graph.
Let I be the set of triples generated by evaluation
Let RS be a rule set
Let finished = false

while !finished:
    finished = true
    foreach rule in RS
        let GI = G union I
        let X = eval(rule, GI)
        let Y = those triples in X that are not in GI
        if Y is not empty:
            finished = false
            endif
        let I = Y union I
        endfor
    endwhile

result is GI

Shapes Rules Language Grammar

Productions for terminals: