SHACL 1.2 규칙

다음의 다른 명세들은 이 문서에서 사용되는 기본 용어를 제공합니다:

• RDF 1.2 Concepts and Abstract Data Model [RDF12-CONCEPTS]
• SPARQL 1.2 Query Language [SPARQL12-QUERY]

이 문서의 일부 예제는 RDF 1.2 Turtle [RDF12-TURTLE]을 사용합니다.

이 문서 전체에서 다음 네임스페이스 접두사 바인딩이 사용됩니다:

문서 전체에서 Turtle의 RDF 그래프를 포함하는 색상 코드 상자가 나타납니다. 이러한 Turtle 문서 조각은 위에 제공된 접두사 바인딩을 사용합니다.

# This box represents rules

# This box represents input data

# This box represents inferred data

버전 레이블은 Shape Rules Language에 대한 구문 및 의미론 적합성을 식별하는 문자열입니다.

버전 선언은 문서의 앞부분에서 이루어지는 것이 SHOULD입니다.

하나의 Shape Rules Language 문서에는 여러 버전 지시문이 나타날 수 있습니다. 각 지시문은 해당 지시문 뒤의 문서 부분에 적용되며, 다른 지시문이 나타나거나 문서의 끝에 도달할 때까지 적용됩니다.

버전 레이블은 미디어 유형의 version 매개변수로도 제공될 수 있습니다. 현재 버전 지시문이 없는 경우에는 미디어 유형의 일부로 지정된 버전이 고려됩니다.

변수

변수는 트리플 패턴에서 가능한 RDF 용어를 나타냅니다. 변수는 표현식에서도 사용됩니다.

표현식

표현식은 함수 또는 함수형 형식입니다; 인수는 RDF 용어입니다. 표현식은 해 매핑과 관련하여 평가되어, 결과로 RDF 용어를 제공합니다. 표현식은 SHACL 목록 매개변수 함수 및 SPARQL 표현식과 호환됩니다.

데이터 블록

데이터 블록은 트리플의 집합입니다. 이러한 트리플은 추가 사실로서 추론 그래프에 추가되며 추론 과정에 포함됩니다.

트리플 템플릿

트리플 템플릿은 각 요소가 변수 또는 RDF 용어(트리플 용어일 수도 있음) 중 하나인 3-튜플입니다. 튜플의 두 번째 요소는 IRI 또는 변수여야 합니다. 트리플 템플릿은 규칙의 머리부에 나타납니다.

트리플 패턴

트리플 패턴은 각 요소가 변수 또는 RDF 용어(트리플 용어일 수도 있음) 중 하나인 3-튜플입니다. 튜플의 두 번째 요소는 IRI 또는 변수여야 합니다.

필터 요소

필터 요소는 표현식이며, 규칙 요소로 나타납니다. 이는 패턴 일치에서 변수 값을 제한하는 데 사용됩니다.

트리플 패턴 요소

트리플 패턴 요소는 트리플 패턴이며, 규칙 요소로 나타납니다.

부정 요소

부정 요소는 규칙 요소입니다. 이는 부정 요소 본문을 가지며, 이는 트리플 패턴 요소와 필터 요소의 시퀀스로 구성됩니다.

할당 요소

할당 요소는 규칙 요소이며, 할당 변수라고 하는 변수와, 할당 표현식이라고 하는 표현식으로 구성된 쌍입니다.

규칙 요소

규칙 요소는 트리플 패턴 요소, 필터 요소, 부정 요소, 또는 할당 요소 중 하나입니다.

규칙 머리부

규칙 머리부는 트리플 템플릿의 시퀀스입니다.

규칙 본문

규칙 본문은 규칙 요소의 시퀀스입니다; 즉, 각 시퀀스 요소는 트리플 패턴 요소, 필터 요소, 부정 요소, 또는 할당 요소 중 하나입니다.

규칙 가져오기

규칙 가져오기(흔히 단순히 "가져오기")는 평가 중에 포함될 다른 규칙 집합의 URL 모음입니다.

규칙

규칙은 규칙 머리부(흔히 단순히 "머리부")와 규칙 본문(흔히 단순히 "본문")의 쌍입니다. 규칙에는 식별에 도움이 되도록 URI를 부여할 수 있습니다.

한 번만 실행되는 규칙

한 번만 실행되는 규칙은 규칙 집합 평가의 특정 시점에 정확히 한 번 실행되는 규칙입니다.

일반 규칙

일반 규칙은 한 번만 실행되는 규칙이 아닌 규칙입니다. 일반 규칙은 규칙 집합 평가 중 두 번 이상 실행될 수 있습니다.

규칙 집합

규칙 집합은 0개 이상의 규칙 모음, 0개 이상의 데이터 블록 모음, 그리고 0개 이상의 규칙 가져오기 모음입니다. 해결된 규칙 집합은 가져오기가 없는 규칙 집합입니다. 해결된 규칙 집합은 규칙 집합에 가져오기 과정을 적용하여 생성됩니다.

기본 그래프

기본 그래프는 평가 과정에 입력으로 주어진 RDF Graph입니다.

추론 그래프

추론 그래프는 RDF Graph이며, 규칙 집합을 평가하여 생성됩니다. 이는 규칙 집합을 기본 그래프에 적용하여 추론된, 기본 그래프에 존재하지 않는 모든 트리플을 포함합니다.

Infer

Infer는 규칙 집합을 주어진 기본 그래프에 적용하고 추론된 트리플을 포함하는 추론 그래프를 생성하는 작업입니다.

Query

Query는 주어진 목표 패턴이 규칙 집합을 사용하여 기본 그래프에서 도출될 수 있는지를 판정하는 작업입니다.

트리플 패턴 또는 트리플 템플릿에서, 튜플의 위치 1은 비공식적으로 주어, 위치 2는 비공식적으로 술어, 그리고 위치 3은 비공식적으로 목적어라고 불립니다.

올바른 형식은 규칙 집합의 추상 구문에 대한 조건들의 집합입니다. 이러한 조건들은 함께 규칙의 머리부에 있는 변수가 규칙의 본문에서 정의된 값을 갖도록 하고, 필터 요소 또는 할당 표현식의 각 변수가 평가 시점에 값을 갖도록 하며, 규칙의 각 할당이 새 변수를 도입하고, 그 변수가 규칙 본문의 앞부분에서 사용되지 않았음을 보장합니다.

우리는 초기 변수 집합이 주어졌을 때 규칙 요소 시퀀스에 대한 올바른 형식을 정의합니다.

elt_i를 규칙 요소 시퀀스의 i번째 요소라고 합니다.

vars_i를 elt_i에 의해 정의되는 변수들의 집합이라고 하며, 여기서:

V₀을 시퀀스의 초기 변수라고 합니다.

V_i는 V₀와, j가 i보다 작은 모든 vars_j의 합집합입니다.

V_all은 시퀀스의 길이가 N일 때 V_N입니다.

올바른 형식의 시퀀스는 변수 집합 V₀가 주어졌을 때, 다음 조건을 만족하는 규칙 요소의 시퀀스입니다:

규칙은 규칙 본문의 시퀀스가 빈 집합인 V₀가 주어졌을 때 올바른 형식의 시퀀스이고, 규칙 머리부의 트리플 템플릿에 있는 각 변수가 V_all의 원소이면 올바른 형식의 규칙입니다.

규칙 집합은 그 규칙 집합의 모든 규칙이 올바른 형식의 규칙인 경우에만 올바른 형식의 규칙 집합입니다.

규칙 R1은 두 번째 규칙의 출력이 첫 번째 규칙의 본문 평가에 영향을 미치는 경우 규칙 R2에 의존합니다. 즉, R2의 머리부에는 R1의 본문 안에 있는 트리플 패턴과 일치하는 트리플을 생성할 수 있는 트리플 템플릿이 있습니다. 이는 트리플 패턴 요소로서든 부정 요소 내부에서든 해당됩니다.

의존성에는 두 가지 종류가 있습니다: 닫힌 의존성과 열린 의존성입니다. 닫힌 의존성은 규칙 R1이 실행되기 전에 규칙 R2가 가능한 모든 출력을 생성했음을 보장합니다. 규칙 의존성이 닫힌 것이 아니면 열린 의존성이며, 이는 규칙 R2가 추가 트리플을 생성하기 위해 다시 실행될 수 있는 동안에도 첫 번째 규칙 R1이 실행될 수 있게 하고, 그러면 R2의 새 트리플로 인해 R1이 다시 평가될 수 있습니다.

이 첫 번째 예제에서 첫 번째 규칙은 두 번째 규칙에 대해 열린 의존성을 가집니다.

이 두 번째 예제에서 첫 번째 규칙은 두 번째 규칙에 대해 닫힌 의존성을 가집니다.

트리플 패턴 일치

트리플 패턴은 트리플 템플릿이 트리플 패턴과 일치하는 트리플을 생성할 수 있는 경우 트리플 템플릿과 일치합니다.

트리플 패턴 의존성

트리플 패턴은 해당 트리플 패턴이 트리플 템플릿과 일치할 가능성이 있는 경우 트리플 템플릿에 의존합니다.

트리플 패턴은 규칙 머리부에 있는 트리플 템플릿 중 어느 하나에 대해 의존성이 있는 경우 규칙에 의존합니다.

규칙 의존성

규칙 R1은 R1의 본문 안에 있는 어떤 트리플 패턴이, 트리플 패턴 요소로서든 부정 요소 내부에서든, R2의 머리부 안에 있는 트리플 템플릿에 의존하는 경우 규칙 R2에 의존합니다.

닫힌 의존성

규칙 R1이 규칙 R2에 갖는 규칙 의존성은 다음 조건 중 하나가 성립하면 닫힌 의존성입니다:

• R1의 부정 요소 내부에 나타나는 트리플 패턴이 R2의 규칙 머리부에 있는 트리플 템플릿과 일치합니다.
• 규칙 R1이 규칙 R2에 의존하고, R1에 할당 요소가 있습니다.
• 규칙 R1이 규칙 R2에 의존하고, R1의 규칙 머리부에 빈 노드가 있습니다.

열린 의존성

규칙 R1이 규칙 R2에 갖는 규칙 의존성은 그 의존성이 닫힌 의존성이 아닌 경우 열린 의존성입니다. 즉, R2에 의존하는 R1의 모든 트리플 패턴은 트리플 패턴 요소로서만 나타납니다.

define mergeLabel(oldLabel, newLabel):
    ## Closed dependency overrides open dependency.
    if oldLabel == "open" and newLabel == "open":
        return "open"
    else:
        return "closed"
    endif
enddefine

## output -- Dependency graph with rule vertices and labeled edges.
define buildDependencyGraph(ruleSet):
    ## edgeLabelMap maps (R1, R2) to "open" or "closed"
    let edgeLabelMap be a map from pair (rule, rule) to label

    foreach rule R1 in ruleSet:
        ## Classify each triple pattern TP in the rule as requiring "open" or "closed"
        ## depending on whether it is in a negation element or not.
        let bodyDependencies = {}
        foreach rule element RBE in the body of R1:
            if RBE is a negation element:
                foreach triple pattern TP in RBE:
                    let item be a pair (TP, "closed")
                    add item to bodyDependencies
                endfor
            else if RBE is a triple pattern element of triple pattern TP:
                let item be a pair (TP, "open")
                add item to bodyDependencies
            else if RBE is a condition element:
                ## Do nothing
            else if RBE is an assignment element:
                ## Do nothing
            endif
        endfor

        foreach pair (triple pattern TP, depLabel) in bodyDependencies:
            if R1 has an assignment element:
              set depLabel to "closed"
            endif
            if R1 has a triple template with a blank node:
              set depLabel to "closed"
            endif
            ## Find depenencies for this triple pattern element or negation element.
            foreach rule R2 in ruleSet:
                foreach triple template TT in head of R2:
                    ## "possibly generate" / matching is defined in
                    ## section 3.3 
                    if TT can possibly match triple pattern TP:
                        let key = (R1, R2)
                        if edgeLabelMap contains key:
                            let oldLabel = edgeLabelMap.get(key)
                            let merged = mergeLabel(oldLabel, depLabel)
                            edgeLabelMap.set(key, merged)
                        else:
                            edgeLabelMap.set(key, depLabel)
                        endif
                    endif
                endfor
            endfor
        endfor
    endfor

    let DP = { }
    foreach entry ((R1, R2), label) in edgeLabelMap:
        add edge (R1 -> R2) labeled label to DP
    endfor

    the result is DP
    enddefine

예:

계층화는 규칙 집합을 계층화 층(또한 "strata", 단수 "stratum"이라고도 함)의 순서 있는 시퀀스로 분할하는 과정입니다. 더 낮은 strata의 규칙은 더 높은 strata의 규칙보다 먼저 평가됩니다.

계층화는 규칙 간의 의존성에 제약을 부과하여 부정 요소, 할당 요소, 그리고 규칙 머리부에서 생성된 빈 노드가 더 이른(낮은) strata와 기본 그래프를 사용해 계산된 결과에만 의존하도록 보장합니다. 이는 주어진 기본 그래프에 대한 규칙 집합의 평가에서 단일하고 잘 정의되며 유한한 결과를 보장합니다.

계층화 층

계층화 층 SL은 서로소인 규칙 집합 두 개(SL.once, SL.general)의 쌍입니다. SL.once는 한 번만 실행되는 규칙을 포함하며, 이는 할당 요소를 사용하거나 규칙 머리부에 빈 노드를 생성하는 규칙입니다; 이러한 규칙은 계층화 층 평가의 시작 시 각각 정확히 한 번 평가됩니다. SL.general은 남은 규칙을 포함하며, 이 규칙들은 새로운 트리플이 더 이상 추론되지 않을 때까지 반복적으로 평가됩니다.

계층화

규칙 집합의 계층화는 계층화 층의 시퀀스입니다. 규칙 집합의 각 규칙은 계층화 층 중 하나의 집합 중 정확히 하나에 나타납니다.

## output -- Map: Integer -> Set of rules.

define stratification(ruleSet):

    let DP = Dependency graph for the rule set.
    let stratumMap be a map from rule to integer

    ## The dependency graph should satisfy the stratification condition.
    ## The check for unbounded stratification is a guard 
    ## due to a violation of the stratification condition.
    let limit = num rules + 1
    let maxStratum = 0

    ## initialize stratumMap
    foreach rule in ruleSet:
        stratumMap.set(rule, 0)
        endfor

    boolean changed = true;
    while changed:
        changed = false;
        foreach edge E in DP:
            ## Edge from pRule to qRule with a label
            let pRule = source of edge
            let qRule = destination of the edge
            let label = edge label

            if label == "open" :
                if stratumMap.get(pRule) < stratumMap.get(qRule) :
                    stratumMap.set(pRule, stratumMap.get(qRule))
                    changed = true;
                endif
            endif
            if label == "closed" :
                if stratumMap.get(pRule) <= stratumMap.get(qRule) :
                    let xStratum = 1 + stratumMap.get(qRule)
                    if ( xStratum > limit )
                        ## Stratification requirement violated
                        error "Stratification error"
                        endif
                    stratumMap.set(pRule, xStratum)
                    maxStratum = max(maxStratum, xStratum)
                    changed = true;
                endif
            endif
        endfor
    endwhile

    ## Initialize the result map.
    let stratumRules be a map from integer to rules.
    for i = 0 to maxStratum
        stratumRules.set(i, {})
    endfor

    ## Gather rules in stratumMap with the same level number
    for rule R in map stratumMap:
        let stratumNum = stratumMap.get(R)
        add R to stratumRules.get(stratumNum)
    endfor

    ## Partition each level into once and general
    let stratumLevels be a sequence of pairs of sets of rules.
    for i = 0 to maxStratum:
        let rules = stratumRules.get(i)
        let once = { R in rules | R is a run-once rule }
        let general = rules \ once
        stratumLevels.set(i, pair(once, general))
    endfor

    the result is stratumLevels
enddefine

문법은 아래에 제공됩니다.

어휘: rdf-syntax-vocab.ttl
SHACL 셰이프: rdf-syntax-shapes.ttl

@@ 그림: 텍스트 및 RDF 구문의 SHACL 규칙 집합: 모든 기능:

PREFIX :        <http://example/>

DATA { :s :p :o }
RULE { ?x :q :o } WHERE { ?x :p :o }
RULE { ?x :q :o } WHERE { ?x :p :o1 ; :p :o2 }
RULE { ?x :q :o } WHERE { ?x :p ?o . FILTER (?o < 18) }
RULE { ?x :q ?o } WHERE { ?x :p :o . SET (?o := 18) }
RULE { ?x :q ?o } WHERE { ?x :p :o . NOT { ?s :p ?o . FILTER(?o < 18) } }

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

:ruleSet-1
  rdf:type srl:RuleSet;
  srl:data (
    [ srl:subject :s ; srl:predicate :p; srl:object :o ; ]
  );
  srl:rules (
    [
      rdf:type srl:Rule;
      srl:body (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :p ; srl:object :o ; ]
      ) ;
      srl:head (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :q ; srl:object :o ; ]
      )
    ]
    [
      rdf:type srl:Rule ;
      srl:body (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :p ; srl:object :o1 ; ]
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :p ; srl:object :o2 ; ]
      ) ;
      srl:head (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :q ; srl:object :o ; ]
      )
    ]
    [
      rdf:type srl:Rule ;
      srl:body (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :p ; srl:object [ srl:varName "o" ] ; ]
        [
          srl:filter [
            sparql:less-than (
              [ srl:varName "o" ]
              18
            )
          ]
        ]
      ) ;
      srl:head (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :q ; srl:object :o ; ]
      )
    ]
    [
      rdf:type srl:Rule ;
      srl:body (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :p ; srl:object :o ; ]
        [
          srl:assign [
            srl:assignValue 18 ;
            srl:assignVar [ srl:varName "o" ]
          ]
        ]
      ) ;
      srl:head (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :q ; srl:object [ srl:varName "o" ] ; ]
      )
    ]
    [
      rdf:type srl:Rule ;
      srl:body (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :p ; srl:object :o ; ]
        [
          srl:not (
            [ srl:subject [ srl:varName "s" ] ;     srl:predicate :p ;     srl:object [ srl:varName "o" ] ; ]
            [
              srl:filter [
                sparql:less-than (
                  [ srl:varName "o" ]
                  18
                )
              ]
            ]
          )
        ]
      ) ;
      srl:head (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :q ; srl:object [ srl:varName "o" ] ; ]
      )
    ]
  ) .

해 매핑

해 매핑 μ는 부분 함수 μ : V → T이며, 여기서 V는 모든 변수의 집합이고 T는 모든 RDF 용어의 집합입니다. μ의 정의역은 dom(μ)로 표시하며, 이는 μ가 정의되어 있는 V의 부분집합입니다. 명확하게 해 매핑을 의미하는 경우에는 해라는 용어를 사용합니다. dom(μ0)가 공집합인 해 매핑을 μ₀로 씁니다.

대입 함수

대입 함수, 또는 단순히 대입은 함수 subst(μ, triple pattern) 이며, 트리플 패턴을 반환합니다. 여기서 트리플 패턴 안에서 dom(μ)에 속한 변수의 각 출현은 var에 대한 해 매핑이 주는 RDF 용어로 대체됩니다. 그 결과 트리플 패턴에 변수가 없으면 이는 RDF 트리플입니다.

평가 그래프

평가 그래프는 RDF Graph이며, 기본 그래프와 규칙 집합의 평가 중에 생성된 모든 트리플을 결합한 것입니다.

그래프 일치

그래프 일치는 트리플 패턴을 RDF Graph 안의 트리플에 매핑하는 방법을 찾습니다.

G를 RDF 그래프라고 하고 TP를 트리플 패턴이라고 합니다. 함수 graphMatch(G, TP)는 트리플 패턴에 적용되었을 때 평가 그래프 안에 있는 트리플을 생성하는 모든 가능한 해의 집합을 반환합니다.

G를 RDF 그래프라고 하고 TP를 트리플 패턴이라고 합니다.

graphMatch(G, TP) = { μ | subst(μ, TP) is a triple in G }

해 호환

두 해 S1과 S2는 공통 변수에 대해 일치하는 경우 호환됩니다.

S1과 S2를 해라고 합니다.

compatible(μ1, μ2) = true
                      if forall v in dom(μ1) intersection dom(μ2)
                          μ1(v) = μ2(v)
compatible(μ1, μ2) = false otherwise

해 시퀀스

해 시퀀스는 해의 다중집합입니다. 시퀀스에 정의된 순서는 없습니다. 이는 순서 없는 목록과 동등하며 중복을 포함할 수 있습니다.

해 병합

두 해가 호환되는 경우, 두 해의 병합은 각 해의 변수를 한 해 또는 다른 해에서 온 RDF 용어에 매핑하는 해입니다.

μ₁, μ₂를 해 매핑이라고 하고, S1과 S2를 해 시퀀스라고 합니다.

merge(μ1, μ2) = { μ |
                    μ(v) = μ1(v) if v in dom(μ1)
                    μ(v) = μ2(v) otherwise }

merge(S1, S2) = { μ |
                    μ1 in S1, μ2 in S2
                    and compatible(μ1, μ2)
                    μ(v) = merge(μ1, μ2) }

편집자 주

정의역이 dom(S1) ∪︀ dom(S2)라고 말합니다.

공통 변수가 없는 두 해는 호환된다고 말합니다.

규칙 집합을 평가하는 첫 단계는 하나의 유효한 규칙 집합을 준비하는 것입니다. 여기에는 가져온 모든 규칙 집합을 모으고, 하나의 결합된 규칙 집합을 만든 다음, 결합된 규칙 집합에 대한 계층화를 계산하는 것이 포함됩니다.

MR.rules = RS1.rules ∪︀ RS2.rules
MR.data = merge(RS1.data, RS2.data)
MR.imports = {}

define imports(rule set RS, set of URLs V), returning rule set
    let I = the set of import URLs declared for the rule set RS
    let RS2 be a rule set formed from RS.rules and RS.data
    foreach URL x in I:
        if x ∉ V:
            V = V ∪︀ { x }
            read rule set RS3 from URL x
            RS2 = rulesetMerge(RS2, imports(RS3, V))
        endif
    endfor
    result is RS2
enddefine

let RS be a rule set
let V = {}
if RS has a location, V = { location of RS }
result is imports(RS, V)

필터 요소 또는 할당 요소에서 사용되는 표현식은, 표현식 안의 각 변수에 대해 RDF 용어인 값을 제공하는 해 매핑과 관련하여 평가됩니다. 4.2 올바른 형식 조건의 올바른 형식 요구사항은 표현식 안의 모든 변수가 해 매핑에 나타나도록 보장합니다.

define evalFunction(F, μ):
    ## F is an expression: an RDF term, a variable, or op(expr1, ..., exprN)
    ## where op is a function or a functional form.
    if F is an RDF term:
        return F
    if F is a variable:
        ## By well-formedness, F ∈ dom(μ).
        return μ(F)
    ## F is of the form F= op(expr1, ..., exprN)
    if op is a functional form (e.g. IF, logical-or):
        ## Evaluated specifically for op; op may evaluate only some arguments.
        ## For example, IF(c, t, f) evaluates c, then exactly one of t or f.
        return the value defined for op over expr1, ..., exprN under μ
    ## op is an ordinary function: evaluate all arguments first.
    return F(evalFunction(expr1, row), ..., evalFunction(exprN, row))
enddefine

함수 EBV(x)는 RDF 용어에 대한 유효 불리언 값을 반환합니다.

규칙은 규칙 본문으로부터 해 시퀀스를 계산한 다음, 해 시퀀스의 각 해 매핑을 사용하여 규칙 머리부를 통해 트리플을 생성함으로써 평가됩니다.

let R be a well-formed rule.

let rule R = (H, B) where
             H is the sequence of triple templates in the head
             B is the sequence of triple pattern elements,
                condition elements, negation elements,
                and assignment elements in the body

# Solution sequence of one solution that does not map any variables.
let SEQ0: Solution sequence = { μ0 }

let G = evaluation graph

# Evaluate rule body
# This function returns a sequence of solutions
define evalRuleElements(B, SEQ, G):

    for each rule element rElt in B:

        if rElt is a triple pattern TP:
            X = graphMatch(G, TP)
            SEQ1 = {}
            for each μ1 in X:
                for each μ2 in SEQ:
                    if compatible(μ1, μ2)
                      μ3 = merge(μ1, μ2)
                      add μ3 to SEQ1
                    endif
                endfor
            endfor
        endif

        if rElt is a condition element with expression F:
            SEQ1 = {}
            for each solution μ in SEQ:
                let x = evalFunction(F, μ)
                if EBV(x) is true:
                    add μ to SEQ1
                endif
            endfor
        endif

        if rElt is a negation expression with body elements N:
            SEQ1 = {}
            for each solution μ in SEQ:
                S = sequence{ μ }
                NEG = evalRuleElements(N, S, G)
                if NEG is empty
                    add μ to SEQ1
                endif
            endfor
        endif

        if rElt is an assignment with variable V and expression expr
            SEQ1 = {}
            for each solution μ in SEQ:
                let x = evalFunction(expr, μ)
                if x is not an error:
                    ## Add mapping V -> x to solution μ
                    let μ2 be a solution mapping μ ∪︀ { (V, x) }
                    add μ2 to SEQ1
                else
                    # Error: drop solution μ
                endif
            endfor
        endif

        if SEQ1 is empty
            SEQ = {}
            return SEQ
        endif

        SEQ = SEQ1
    endfor

    return SEQ
enddefine

let SEQ = evalRuleElements(B, SEQ0, G)

# Evaluate rule head
let OUT = empty set
for each μ in SEQ:
    let S = {}
    for each triple template TT in H:
        let triple = subst(μ, TT)
        Add triple to S
    endfor
    OUT = OUT union S
endfor

result eval(R, G) is OUT

OUT은 데이터 그래프에도 있는 트리플을 포함할 수 있음에 유의하십시오.

규칙 집합의 평가는 규칙 집합의 계층화에 있는 각 stratum의 실행으로 정의됩니다. 여기서 각 stratum은 다음 stratum으로 이동하기 전에 완전히, 그리고 순서대로 실행됩니다. stratum은 먼저 해당 stratum의 한 번만 실행되는 규칙 각각을 평가한 다음, 새로운 트리플이 생성되지 않을 때까지 그 stratum의 일반 규칙을 반복적으로 평가함으로써 평가됩니다.

let G0 be the input base graph
let RS be the rule set
let D be the graph of all DATA triples in RS

Apply stratification to RS

let LS be the sequence of layers after stratification

# Inference graph
let GI = { t ∈ D | t ∉ G0 }

# Evaluation graph.
let GE = G0 ∪︀ D

for each stratum ST in LS:
    for each rule R in ST.once:
        let X = eval(R, GE)
        let Y = { t ∈ X | t ∉ GE }
        GI = Y ∪︀ GI
        GE = Y ∪︀ GE
    endfor

    let finished = false
    while !finished:
        finished = true
        for each rule R in ST.general:
            let X = eval(R, GE)
            let Y = { t ∈ X | t ∉ GE }
            if Y is not empty:
                finished = false
                GI = Y ∪︀ GI
                GE = Y ∪︀ GE
            endif
        endfor
    endwhile
endfor
the result is GI

공백 (생성 규칙 WS)은 그렇지 않으면 하나의 터미널로 (잘못) 인식될 수 있는 두 터미널을 분리하는 데 사용됩니다. 아래에서 대문자로 된 규칙 이름은 공백이 중요한 곳을 나타내며, 이는 Shape Rules Language 파서를 구성하기 위한 터미널의 가능한 선택을 이룹니다.

공백은 String 생성 규칙에서 중요합니다.

주석은 IRIREF, STRING_LITERAL1, STRING_LITERAL2, STRING_LITERAL_LONG1, 또는 STRING_LITERAL_LONG2 밖에 있는 #로 시작하며, LF 또는 CR로 표시되는 행 끝까지 계속되거나, 주석 표시 뒤에 행 끝이 없는 경우 파일 끝까지 계속됩니다. 주석은 공백으로 처리됩니다.

상대 IRI 참조는 Uniform Resource Identifier (URI): Generic Syntax [RFC3986]에 따라 기본 알고리즘인 5.2절만 사용하여 Base IRI로 해석됩니다. RFC3986의 6.2.2절과 6.2.3절에 설명된 Syntax-Based Normalization 또는 Scheme-Based Normalization은 수행되지 않습니다. IRI 참조에서 추가로 허용되는 문자는 Internationalized Resource Identifiers (IRIs) [RFC3987]의 6.5절에 따라 URI 참조의 예약되지 않은 문자가 처리되는 것과 같은 방식으로 처리됩니다.

BASE 지시문은 [RFC3986] 5.1.1절, "Base URI Embedded in Content"에 따라 상대 IRI 참조를 해석하는 데 사용되는 Base IRI를 정의합니다. 5.1.2절, "Base URI from the Encapsulating Entity"는 SOAP envelope의 xml:base 지시문이나 MIME multipart 문서의 Content-Location 헤더와 같은 캡슐화 문서에서 In-Scope Base IRI가 어떻게 올 수 있는지 정의합니다. 5.1.3, Base "URI from the Retrieval URI"에서 식별된 "Retrieval URI"는 특정 Shape Rules Language 문서가 검색된 URL입니다. 위의 어느 것도 Base URI를 지정하지 않으면 기본 Base URI(5.1.4절, "Default Base URI")가 사용됩니다. 각 BASE 지시문은 이전 것에 상대적으로 새로운 In-Scope Base URI를 설정합니다.

Shape Rules 문서에서 사용되는 이스케이프에는 세 가지 형식이 있습니다:

• 숫자 이스케이프 시퀀스는 유니코드 코드 포인트의 값을 나타냅니다.

  숫자 이스케이프 시퀀스는 유니코드 서러게이트 범위인 U+D800에서 U+DFFF까지의 코드 포인트 값을 생성해서는 MUST NOT 됩니다.

  이스케이프 시퀀스	유니코드 코드 포인트
  \u hex hex hex hex	가장 유효한 자리부터 가장 덜 유효한 자리까지 해석한 네 개의 16진수 숫자로 인코딩된 값에 대응하는, U+0000에서 U+D7FF 및 U+E000에서 U+FFFF 범위의 유니코드 코드 포인트
  \U hex hex hex hex hex hex hex hex	가장 유효한 자리부터 가장 덜 유효한 자리까지 해석한 여덟 개의 16진수 숫자로 인코딩된 값에 대응하는, U+0000에서 U+D7FF 및 U+E000에서 U+10FFFF 범위의 유니코드 코드 포인트

  여기서 hex는 16진수 문자입니다

  HEX ::= [0-9] | [A-F] | [a-f]

• 문자열 이스케이프 시퀀스는 문자열 리터럴에서 전통적으로 이스케이프되는 문자를 나타냅니다:

  이스케이프 시퀀스	유니코드 코드 포인트
  \t	U+0009
  \b	U+0008
  \n	U+000A
  \r	U+000D
  \f	U+000C
  \"	U+0022
  \'	U+0027
  \\	U+005C

• 예약 문자 이스케이프 시퀀스는 \ 뒤에 문자 ~.-!$&'()*+,;=/?#@%_ 중 하나가 오는 것으로 구성되며, \ 오른쪽의 문자를 나타냅니다.

여기서 사용되는 EBNF는 XML 1.0 [EBNF-NOTATION]에 정의되어 있습니다.

이 문법의 텍스트 버전은 여기에서 사용할 수 있습니다.

이 문서는 몇몇 특정 터미널 리터럴 문자열 [EBNF-NOTATION]을 사용합니다. 이러한 터미널 리터럴 문자열에 사용되는 유니코드 코드 포인트를 명확히 하기 위해, 다음 표는 이 절에서 사용되는 특정 문자를 설명합니다.