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

This specification is published by the Data Shapes Working Group .

Introduction

This document introduces the concept of Inference Rules for SHACL 1.2, a mechanism for deriving new RDF triples from existing data using declarative rules defined in shapes graphs. This extends SHACL’s capabilities beyond validation, enabling reasoning and data enrichment.

This document complements other SHACL 1.2 specifications, such as SHACL Core, by defining the syntax and semantics of rule-based inference. While SHACL Core focuses on constraint validation, the Inference Rules specification provides a standardized way to express and evaluate rules that generate new data.

        # 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 `:childOf` `:A` and `:B`, and that `:X` is `:descendedFrom` `:C`

Shape Rules Abstract Syntax

The Shape Rules Abstract Syntax

?? Abstract Rules Syntax

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 (which might be 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 (which might be 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=] and a collection of zero or more [=data blocks=].

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, and 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.

Change the name away from "compact" and leave that free for SHACL-C.

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 shr     <http://www.w3.org/ns/shacl-rules#>
PREFIX sh:     <http://www.w3.org/ns/shacl#>
PREFIX sparql: <http://www.w3.org/ns/sparql#>

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

Drafting Notes

Shapes Rules Language Grammar

Productions for terminals: