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。

1つのShape Rules Language文書には、複数のバージョン指令が現れることがある。 各指令は、その指令に続く文書の部分に適用され、 別の指令に遭遇するか、文書の終わりに達するまで有効である。

バージョンラベルは、 メディアタイプの versionパラメータによっても与えられる。現在有効な バージョン指令がない場合、メディアタイプの一部として指定されたバージョンが 考慮される。

変数

変数は、トリプルパターン内のあり得る RDF 用語を表す。 変数は式でも使用される。

式

式とは、関数または関数形式であり、 引数はRDF用語である。 式は解写像に関して評価され、 結果としてRDF用語を与える。 式は、 SHACLリストパラメータ関数 およびSPARQL式と互換性がある。

データブロック

データブロックとは、トリプルの集合である。 これらのトリプルは追加の事実として推論グラフに追加され、 推論過程に含められる。

トリプルテンプレート

トリプルテンプレートとは、各要素が 変数またはRDF 用語（トリプル用語である可能性がある）のいずれかである3タプルである。 タプルの2番目の要素は、IRIまたは 変数でなければならない。 トリプルテンプレートは、規則のヘッドに現れる。

トリプル パターン

トリプルパターンとは、各要素が 変数またはRDF 用語（トリプル用語である可能性がある）のいずれかである3タプルである。 タプルの2番目の要素は、IRIまたは 変数でなければならない。

フィルター要素

フィルター要素とは、式であり、 規則要素として現れる。 これは、パターン照合における変数の値を制限するために使用される。

トリプルパターン要素

トリプルパターン要素とは、 トリプルパターンであり、 規則要素として現れる。

否定要素

否定要素とは、 規則要素である。 それは、トリプルパターン要素および フィルター要素の列から構成される 否定要素ボディをもつ。

代入要素

代入要素とは、 規則要素であり、 代入変数と呼ばれる 変数と、 代入式と呼ばれる 式からなる対である。

規則要素

規則要素とは、 トリプルパターン要素、 フィルター要素、 否定要素、または 代入要素のいずれかである。

規則ヘッド

規則ヘッドとは、トリプル テンプレートの列である。

規則ボディ

規則ボディとは、規則要素の列である。 すなわち、各列要素は トリプルパターン要素、 フィルター要素、 否定要素、 または代入要素のいずれかである。

規則インポート

規則インポート（しばしば単に「imports」）とは、 評価中に含められる他の規則集合のURLの集合である。

規則

規則とは、規則ヘッド（しばしば単に 「head」）と 規則ボディ（しばしば単に「body」）の対である。 規則には、それを識別しやすくするためにURIを与えることができる。

一度だけ実行される規則

一度だけ実行される規則とは、規則集合の評価の特定の時点で 正確に一度だけ実行される規則である。

一般規則

一般規則とは、 一度だけ実行される規則ではない規則である。 一般規則は、規則集合の評価中に複数回実行されることがある。

規則集合

規則集合とは、0個以上の規則の集合、 0個以上のデータブロックの集合、 および0個以上の規則インポートの集合である。 解決済み 規則集合とは、インポートを持たない 規則集合である。 解決済み規則集合は、別の 規則集合から、 インポート処理を適用することで作成される。

基底グラフ

基底グラフとは、 評価過程への入力として与えられるRDFグラフである。

推論 グラフ

推論グラフとは、 規則集合を評価することで生成される RDFグラフである。 それは、規則集合を 基底グラフに適用することによって推論される、 基底グラフに存在しないすべてのトリプルを含む。

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は、2番目の規則の出力が最初の規則のボディの評価に 影響する場合、規則R2に依存する。すなわち、R2のヘッドに、 R1のボディ内の トリプルパターンに一致するトリプルを生成し得る トリプルテンプレートがあり、 それがトリプルパターン要素として、または 否定要素内に現れる場合である。

依存関係には2種類ある: 閉じた依存関係と 開いた 依存関係である。 閉じた依存関係は、規則R1が実行される前に、 規則R2がその可能なすべての出力を生成していることを保証する。 規則依存関係が閉じていない場合、それは開いた依存関係であり、 最初の規則R1を、規則R2がさらにトリプルを生成するために 再度実行される可能性がある間に実行することを許し、 その後R2からの新しいトリプルによってR1が再評価され得る。

この最初の例では、最初の規則は2番目の規則に対して 開いた依存関係をもつ。

この2番目の例では、最初の規則は2番目の規則に対して 閉じた依存関係をもつ。

トリプル パターン照合

トリプルパターンは、 トリプルテンプレートがそのトリプルパターンに一致するトリプルを生成できる場合、 トリプルテンプレートに一致する。

トリプルパターン依存関係

トリプルパターンは、 そのトリプルパターンが トリプルテンプレートに一致する可能性がある場合、 トリプルテンプレートに依存する。

トリプルパターンは、その トリプルパターンが 規則のヘッド内の トリプルテンプレートのいずれかに依存する場合、 規則に依存する。

規則依存関係

規則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"としても知られる）に分割する過程である。 低い層の規則は、 高い層の規則よりも前に評価される。

層化は、規則間の依存関係に制約を課し、 否定要素、 代入 要素、および 規則ヘッド内に作成される空白ノードが、 より前の（より低い）層と 基底グラフを用いて計算された結果にのみ依存することを保証する。 これは、与えられた基底グラフ上での 規則集合の評価から、 単一の明確に定義された有限の結果が得られることを保証する。

層化層

層化層SLは、互いに素な規則集合 （SL.once、SL.general）の対である。 SL.onceは、 一度だけ実行される規則を含む。 これは、代入要素を使用する規則、または 規則ヘッド内で空白ノードを生成する規則であり、 これらの規則はそれぞれ、層化層の評価の開始時に 正確に一度だけ評価される。 SL.generalは残りの規則を含み、それらは 新しいトリプルが推論されなくなるまで繰り返し評価される。

層化

層化とは、 規則集合の 層化層の列である。 規則集合内の各規則は、 層化層のいずれかの集合の1つに 正確に一度現れる。

## 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(μ, 三元组模式)， 它返回一个三元组模式， 其中三元组模式中每个属于 dom(μ) 的变量出现处，都被该 var 的 解映射给出的 RDF 术语替换。 如果所得三元组模式没有变量，那么它就是一个 RDF 三元组。

求值 图

求值图是一个 RDF 图，它组合了 基础图 以及规则集求值期间产生的所有三元组。

图匹配

图匹配查找将三元组模式映射到 RDF 图中三元组的方式。

令 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 可能包含数据图中已有的三元组。

规则集的求值被定义为执行该规则集 分层中的每个 分层； 其中每个分层都会先按顺序完整执行， 然后再进入下一个分层。 对一个分层求值时，首先对该分层中的每个 只运行一次规则求值，然后反复求值该分层中的 一般规则，直到不再产生新的三元组。

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）用于 分隔两个否则会被（错误地）识别为一个终结符的终结符。 下方以大写表示的规则名指示空白具有重要意义的位置； 这些规则构成了用于构造形状规则语言解析器的一种可能终结符选择。

空白在产生式 String 中具有重要意义。

注释以位于 IRIREF、 STRING_LITERAL1、 STRING_LITERAL2、 STRING_LITERAL_LONG1 或 STRING_LITERAL_LONG2 之外的 # 开始， 并持续到行尾（由 LF 或 CR 标记）， 如果注释标记之后没有行尾，则持续到文件结尾。 注释被视为空白。

相对 IRI 引用按照 统一资源标识符（URI）：通用 语法 [RFC3986]， 使用第 5.2 节中的基本算法，通过基准 IRI 进行解析。 不执行基于语法的规范化或基于方案的规范化 （RFC3986 第 6.2.2 和 6.2.3 节中所述）。 IRI 引用中额外允许的字符，按 国际化资源标识符 （IRI） [RFC3987] 第 6.5 节所述，以与 URI 引用中未保留字符相同的方式处理。

BASE 指令定义用于解析 相对 IRI 引用的基准 IRI，依据 [RFC3986] 第 5.1.1 节，“内容中嵌入的基准 URI”。 第 5.1.2 节，“来自封装实体的基准 URI” 定义作用域内基准 IRI 如何来自封装文档， 例如带有 xml:base 指令的 SOAP 信封，或带有 Content-Location 标头的 MIME multipart 文档。 5.1.3，来自检索 URI 的基准 URI中标识的“检索 URI”， 是特定形状规则语言文档 被检索自的 URL。 如果以上均未指定基准 URI，则使用默认 基准 URI（第 5.1.4 节，“默认基准 URI”）。 每个 BASE 指令都会相对于前一个基准 URI 设置新的作用域内基准 URI。

形状规则文档中使用三种形式的转义：

• 数字转义序列表示 一个 Unicode 码点的值。

  数字转义序列 MUST NOT 产生 U+D800 到 U+DFFF 范围内的码点值， 该范围是 Unicode 代理项范围。

  转义序列	Unicode 码点
  \u hex hex hex hex	位于 U+0000 到 U+D7FF 以及 U+E000 到 U+FFFF 范围内的 Unicode 码点， 对应于按从最高有效位到最低有效位解释的四个十六进制数字所编码的值。
  \U hex hex hex hex hex hex hex hex	位于 U+0000 到 U+D7FF 以及 U+E000 到 U+10FFFF 范围内的 Unicode 码点， 对应于按从最高有效位到最低有效位解释的八个十六进制数字所编码的值。

  其中 hex 是一个十六进制字符

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

• 字符串转义序列表示传统上在字符串字面量中 被转义的字符：

  转义序列	Unicode 码点
  \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]。为阐明这些 终结符字面字符串所使用的 Unicode 码点， 下表描述了本节中使用的特定字符。