SPARQL 1.2 RL

次の他の仕様では、この文書で使用される 基本的な用語を定めています：

• RDF 1.2の概念および抽象データモデル [RDF12-CONCEPTS]
• SPARQL 1.2クエリ言語 [SPARQL12-QUERY]

この文書のRDFデータの例では、 RDF 1.2 Turtle [RDF12-TURTLE]を使用します。

この文書では、次の名前空間接頭辞のバインディングを使用します：

文書全体を通じて、Turtle形式のRDFグラフを含む色分けされた ボックスが表示されます。これらのTurtle文書の断片では、上記の接頭辞 バインディングを使用します。

# このボックスはルールを表します

# このボックスは入力データを表します

# このボックスは推論データを表します

変数

変数は、トリプルパターン内の可能なRDF 項を表します。 変数は式でも使用されます。

式

式は、関数または関数形式です。 引数はRDF項です。 式は解マッピングに関して評価され、その結果として RDF項を返します。 式は、 SPARQL式 および SHACLリストパラメーター関数と互換性があります。

データブロック

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

トリプルテンプレート

トリプルテンプレートは、各要素が 変数またはRDF 項（トリプル項の場合もあります）のいずれかである3タプルです。 タプルの第2要素は、IRIまたは変数でなければなりません。 トリプルテンプレートは、ルールのヘッドに現れます。

トリプルパターン

トリプルパターンは、各要素が 変数またはRDF 項（トリプル項の場合もあります）のいずれかである3タプルです。 タプルの第2要素は、IRIまたは変数でなければなりません。

フィルター要素

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

トリプルパターン要素

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

否定要素

否定要素は、 ルール要素です。 これには、トリプルパターン要素および フィルター要素のシーケンスで構成される 否定要素ボディがあります。

代入要素

代入要素は、 ルール要素であり、 代入変数と呼ばれる 変数と、 代入式と呼ばれる 式からなるペアです。

ルール要素

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

ルールヘッド

ルールヘッドは、トリプル テンプレートのシーケンスです。

ルールボディ

ルールボディは、ルール要素のシーケンスです。 すなわち、各シーケンス要素は、 トリプルパターン要素、 フィルター要素、 否定要素、 または代入要素のいずれかです。

ルールセットインポート

ルールセットインポート（多くの場合、単に「インポート」）は、評価中に 組み込まれる他のルールセットの URLの集合です。

ルール

ルールは、ルールヘッド（多くの場合、単に 「ヘッド」）と ルールボディ（多くの場合、単に「ボディ」）のペアです。 ルールには、それを識別しやすくするためにURIを指定できます。

1回実行ルール

1回実行ルールは、ルールセットの評価中の 特定の時点で正確に1回実行されるルールです。

一般ルール

一般ルールは、1回実行ルールではないルールです。 一般ルールは、ルールセットの評価中に複数回実行される場合があります。

ルールセット

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

ベースグラフ

ベースグラフは、評価処理への入力として指定される RDF グラフです。

推論 グラフ

推論グラフは、 RDF グラフであり、 ルールセット評価によって生成されます。 これには、ルールセットを ベースグラフに適用することによって推論された、 ベースグラフには 存在しないすべての推論済みトリプルが含まれます。

ルールセット 評価

ルールセット評価は、 ルールセットを ベースグラフに適用して、 推論 グラフを生成する処理です。 ルール 評価は、ルールを1回評価する処理です。 ルールを評価すると、ルールボディの評価に基づいて、 ルールヘッドによって指定されるすべてのトリプルが生成されます。 これは、トリプルがベースグラフ内にあるか、 ルールセット評価中にすでに推論されているか、 または新しい推論済みトリプルであるかにかかわりません。 ルールセット評価中に、ルールが複数回評価される場合が あります。

SPARQL-RLは、inferおよびqueryという2つの操作を提供します。

推論

推論は、指定された ベースグラフにルールセットを適用し、推論された トリプルを含む推論グラフを生成する操作である。これは完全なルールセット評価を適用する。

クエリ

クエリは、指定されたゴール パターンを、ベースグラフからルールセットを使用して導出できるかどうかを判定する操作である。 すべてのルールを評価するとは限らず、代わりに、クエリのゴールに回答するために 必要なルールのみを評価してもよい。

クエリは、推論操作を実行し、 続いて、ゴールパターンを結合された ベースグラフおよび推論 グラフに照合することと等価である。

SPARQL-RL プロセッサー

SPARQL-RL プロセッサーは、 SPARQL-RL 仕様を実装し、ルールセットを評価でき、推論およびクエリの操作の一方または両方を提供するシステムである。

トリプルパターンまたはトリプル テンプレートでは、 タプルの位置 1 は非形式的に主語、 位置 2 は非形式的に述語、そして 位置 3 は非形式的に目的語と呼ばれる。

ルールセットおよびルールの各種コンポーネントには、次の表記を使用する。

整形式性とは、 ルールセットの抽象構文に対する一連の条件です。これらの条件は総合的に、 ルールのヘッド内の 変数が、そのルールの ボディ内で定義された値を持つこと、 フィルター要素 または代入式内の各変数が、 評価時点で値を持つこと、 およびルール内の各 代入が、ルールボディ内でそれ以前に使用されていない 新しい変数を導入することを保証します。

初期変数集合が指定されたルール要素の シーケンスについて、整形式性を定義します。

elt_iを、ルール要素のシーケンスのi番目の要素とします。

vars_iを、 elt_iによって定義される変数の集合とします。ここで：

V₀を、シーケンスの初期変数とします。

V_iを、 V₀と、i未満のjについての すべてのvars_jとの和集合とします。

V_allをV_Nとします。 ここで、Nはシーケンスの長さです。

整形式 シーケンスとは、変数集合V₀が指定された ルール要素のシーケンスであり、 次の条件を 満たすものです：

ルールは、 ルールボディのシーケンスが、空集合である V₀を指定された 整形式シーケンスであり、 ルールヘッドの トリプルテンプレート内の各変数が V_allの要素である場合、整形式 ルールです。

ルールセットは、そのルールセットのすべてのルールが 整形式ルールである場合に限り、 整形式ルールセットです。

第2のルールの出力が第1のルールのボディの評価に影響する場合、 ルールR1はルールR2に依存します。すなわち、R2のヘッドには、 R1のボディ内のトリプルパターンと一致するトリプルを生成する可能性がある トリプルテンプレートがあります。 これは、トリプルパターン要素として、または 否定要素の内部にあります。

依存関係には2種類あります： 閉鎖依存関係と開放 依存関係です。 閉鎖依存関係は、ルールR1が実行される前に ルールR2が可能なすべての出力を生成したことを保証します。 ルールの依存関係が閉鎖されていない場合、それは開放依存関係であり、 ルールR2がさらにトリプルを生成するために再実行される可能性がある間に、 第1のルールR1を実行できます。 その後、R2からの新しいトリプルによってR1が再評価される場合があります。

この最初の例では、第1のルールは 第2のルールに対して開放依存関係を持ちます。

この第2の例では、第1のルールは第2のルールに対して閉鎖依存関係を持ちます。 トリプルパターン?x :status :criticallyExposedは、 第1のルールの否定要素内に現れ、 第2のルールのヘッド内のトリプルテンプレートと一致します。 第1のルールは、第2のルールが可能なすべての出力を 生成するまで評価できません。

トリプル パターン照合

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

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

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

トリプルパターンが ルールに依存する のは、トリプルパターンが、ルールのトリプルテンプレートのいずれかに依存している 場合であり、それらのトリプルテンプレートはルールのヘッド内にある。

ルールの依存関係

R1のボディ内のいずれかの トリプルパターンが、 トリプルパターン要素として、または 否定要素の内部にあるかにかかわらず、 R2のヘッド内の トリプルテンプレートに 依存する場合、 ルールR1はルールR2に 依存します。

閉鎖依存関係

ルールR1のルールR2に対する ルールの依存関係は、 次のいずれかの条件を満たす場合、 閉鎖依存関係です：

• R1の否定要素内に現れる トリプルパターンが、 R2のルールヘッド内の トリプルテンプレートと一致する。
• ルールR1がルールR2に 依存し、 R1が 代入要素を持つ。
• ルールR1がルールR2に 依存し、 R1のルールヘッドが空白ノードを持つ。

開放依存関係

ルールR1のルールR2に対する ルールの依存関係は、その依存関係が 閉鎖依存関係でない場合、 開放依存関係です。 すなわち、R2に依存するR1の トリプルパターンは、すべて トリプルパターン要素としてのみ現れます。

define mergeLabel(oldLabel, newLabel):
    ## 閉鎖依存関係は開放依存関係を上書きします。
    if oldLabel == "open" and newLabel == "open":
        return "open"
    else:
        return "closed"
    endif
enddefine

## 出力 -- ルールの頂点およびラベル付き辺を持つ依存関係グラフ。
define buildDependencyGraph(ruleSet):
    ## edgeLabelMapは(R1, R2)を"open"または"closed"に対応付けます
    let edgeLabelMap be a map from pair (rule, rule) to label

    foreach rule R1 in ruleSet.rules:
        ## ルール内の各トリプルパターンTPを、"open"または"closed"を必要とするものとして分類します
        ## 否定要素内にあるかどうかによって分類します。
        let bodyDependencies = {}
        foreach rule element RBE in R1.body:
            if RBE is a negation element:
                foreach triple pattern TP in RBE.inner
                    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:
                ## 何もしません
            else if RBE is an assignment element:
                ## 何もしません
            endif
        endfor

        foreach pair (triple pattern TP, depLabel) in bodyDependencies:
            if R1.body has an assignment element:
              set depLabel to "closed"
            endif
            if R1.head has a triple template with a blank node:
              set depLabel to "closed"
            endif
            ## このトリプルパターン要素または否定要素の依存関係を検索します。
            foreach rule R2 in ruleSet.rules:
                foreach triple template TT in R2.head:
                    if triple pattern TP matches triple template TT:
                        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 an edge (R1 -> R2) labeled with label to DP
    endfor

    the result is DP
    enddefine

層別化は、 ルールセットを、 層別化レイヤー（「strata」、単数形は 「stratum」とも呼ばれます）の順序付きシーケンスに分割する処理です。より低い 層のルールは、 より高い層のルールより前に評価されます。

層別化は、 否定要素、 代入 要素、および ルールヘッド内で作成される空白ノードが、 より前の（低い）層および ベースグラフを使用して計算された結果のみに依存することを保証するため、 ルール間の依存関係に制約を課します。 これにより、指定されたベースグラフに対する ルールセットの評価から、 単一で明確に定義された有限の結果が得られることを保証します。

層別化レイヤー

層別化レイヤーSLは、 互いに素な2つのルール集合 （SL.once、SL.general）のペアです。 SL.onceには、 1回実行ルールが含まれます。これは、 代入要素を使用するか、 ルールヘッド内に空白ノードを 生成するルールです。これらのルールはそれぞれ、 層別化レイヤーの評価開始時に正確に1回 評価されます。 SL.generalには残りのルールが含まれ、それらは 新しいトリプルが推論されなくなるまで繰り返し評価されます。

層別化

ルールセットの 層別化は、 層別化レイヤーのシーケンスです。 ルールセット内の各ルールは、 いずれかの層別化レイヤーのいずれか1つの集合に正確に1回現れます。

## 出力 -- マップ：整数 -> ルールの集合。

define stratification(ruleSet):

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

    ## 依存関係グラフは層別化条件を満たす必要があります。
    ## 無制限の層別化の検査は、層別化条件への違反による 
    ## 問題を防ぐための保護手段です。
    let limit = num rules + 1
    let maxStratum = 0

    ## stratumMapを初期化します
    foreach rule in ruleSet.rules:
        stratumMap.set(rule, 0)
        endfor

    boolean changed = true;
    while changed:
        changed = false;
        foreach edge E in DP:
            ## ラベルを持つpRuleからqRuleへの辺
            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 )
                        ## 層別化要件への違反
                        error "Stratification error"
                        endif
                    stratumMap.set(pRule, xStratum)
                    maxStratum = max(maxStratum, xStratum)
                    changed = true;
                endif
            endif
        endfor
    endwhile

    ## 結果マップを初期化します。
    let stratumRules be a map from integer to rules.
    for i = 0 to maxStratum
        stratumRules.set(i, {})
    endfor

    ## stratumMap内の同じレベル番号を持つルールを収集します
    for rule R in map stratumMap:
        let stratumNum = stratumMap.get(R)
        add R to stratumRules.get(stratumNum)
    endfor

    ## 各レベルをonceと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

Webから文書を読み取ることには、セキュリティ上の影響があります。 ルールセットのインポートのサポートは、SRLプロセッサーでは任意です。 さらに、実装は、一部のルールセットのインポートのみをサポートし、 その他をサポートしないなど、部分的なサポートを提供してもよく、 検証済みのコピーからインポートする場合もあります。

インポート処理には、次の条件が適用されます：

• ルールセットのインポートをサポートしない実装は、必ず IMPORTS文を含むルールセットを拒否し、エラーを通知しなければなりません。
• 部分的なサポートを提供する実装は、 サポートしていないインポートを検出した場合、必ずエラーを 通知しなければなりません。
• 実装は、インポート文書を解決できない場合、 または文書が構文的に有効でない場合、必ずエラーを通知しなければなりません。
• プロセッサーは、IMPORTS文を処理する際の無限ループを回避するため、 必ずルールセットを1回だけインポートしなければなりません。

解決済みルールセットは、別のルールセットの インポートで言及されたすべてのルールセットを 再帰的に読み取ることによって、その別のルールセットから生成されます。

アルゴリズムの例については、A. インポートアルゴリズムの例を参照してください。

解マッピング

解マッピングμは、部分 関数 μ : 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をトリプルパターン、 VをTP内に現れる変数の集合とします。

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

解の互換性

2つの解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

解 シーケンス

解シーケンスは、解の多重集合です。 シーケンスには定義された順序がありません。 これは順序なしリストと同等であり、重複を含めることができます。

解のマージ

2つの解に互換性がある場合、それらの解のマージとは、 各解の変数を、いずれかの解から得られた 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) }

注記

merge(S1, S2)の定義域はdomain(S1) ∪︀ domain(S2)です。

2つの解に共通する変数がない場合、それらには互換性があり、 2つの解のマージはS1と S2の和集合です。

実効ブール値

関数EBV(x)は、 RDF項の実効ブール値を返します。

ルールセットの評価では、インポートされたすべてのルールセットを収集し、 4.5 インポートの 処理で説明されているように、単一の結合されたルールセットを構築する。

次に、以下の手順によって、結合されたルールセットを 評価用に準備する。

1. 4.2 適格性 条件で説明されているように、各ルールが適格なルールであることを確認する。
2. 4.3.2 依存関係グラフアルゴリズムで説明されているように、 依存関係グラフを計算する。
3. 4.4.2 階層化アルゴリズムで説明されているように、結合されたルールセットの階層化を計算する）。

式は、フィルター要素または 代入要素のいずれで使用される場合でも、 式内の各変数に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

ルールは、ルール本体から 解 シーケンスを計算し、その後、解シーケンスの各 解マッピングを使用して、 ルールヘッドを使用してトリプルを生成することによって評価されます。

トリプルパターン内の空白ノードは、変数のように動作します。 これは、 SPARQL グラフパターンマッチングと互換性があります。

# Evaluate rule body
# This function returns a sequence of solutions

define evalRuleElements(B, SEQ, G, GD):
    where 
        B is a sequence of rule elements
        SEQ is a solution sequence 
        G and GD are RDF graphs

    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 F:
            SEQ1 = {}
            for each solution μ in SEQ:
                let x = evalFunction(F.expr, μ)
                if EBV(x) is true:
                    add μ to SEQ1
                endif
            endfor
        endif

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

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

        SEQ = SEQ1
    endfor

    return SEQ
enddefine

define evalRule(R, G, GD):
    where 
        R is a well-formed rule
        G and GD are RDF graphs
    let B be R.body 
        where each blank node in a triple pattern in R.body
        is replaced by a variable which is not used in the rule. 
        The same variable is used for each occurrence of the
        same blank node, and a different variable is used for 
       each different blank node.

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

    if R.data:
        let SEQ = evalRuleElements(B, SEQ0, GD, GD)
    else
        let SEQ = evalRuleElements(B, SEQ0, G, GD)
    
    # Evaluate rule head
    let OUT = empty set
    for each μ in SEQ:
        let S = {}
        for each triple template TT in R.head:
            let triple = subst(μ, TT)
            Add triple to S
        endfor
        OUT = OUT union S
    endfor
    return OUT
enddefine

ルールセットの評価は、ルールセットの 階層化の各階層を実行することとして定義され、各階層は、 次の階層に進む前に、順番に完全に実行される。 階層は、まずその階層の各単回実行ルールを評価し、次に新しいトリプルが 生成されなくなるまで、その階層の一般ルールを繰り返し評価することによって評価される。

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 }

let GD = G0 ∪︀ D

# Evaluation graph.
let GE = GD

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

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

バージョンラベルとは、SPARQL-RLの構文および意味論への 適合性を識別する文字列です。

バージョン宣言は文書の早い段階で行われるべきです。

1つのSPARQL-RL文書内に、 複数のVERSIONディレクティブが 現れる場合があります。 各ディレクティブは、そのディレクティブより後の文書部分に適用され、 別のディレクティブが現れるか、文書の末尾に達するまで有効です。

バージョンラベルは、 メディアタイプのversion パラメーターによって指定することもできます。現在有効な VERSIONディレクティブがない場合は、 メディアタイプの一部として指定されたバージョンが考慮されます。

空白 （生成規則WS）は、 それ以外では1つの終端記号として（誤）認識される2つの終端記号を 分離するために使用されます。以下に大文字で示されるルール名は、 空白が重要となる箇所を示します。これらは、SPARQL-RLパーサーを構築するための 終端記号として使用可能な選択肢を構成します。

生成規則 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 ディレクティブは、 [RFC3986]に従って 相対IRI 参照を解決するために使用するベースIRIを定義します。 第5.1.1節「コンテンツに 埋め込まれたベースURI」。 第5.1.2節「カプセル化 エンティティからのベースURI」では、 スコープ内ベースIRIを、xml:baseディレクティブを持つSOAPエンベロープや Content-Locationヘッダーを持つMIMEマルチパート文書などの カプセル化文書から取得する方法を定義しています。 第5.1.3節「取得URIからのベース URI」で識別される「取得URI」は、 特定のSPARQL-RL文書を取得したURLです。 上記のいずれによってもベースURIが指定されない場合は、 デフォルトのベースURI（第5.1.4節「デフォルトのベースURI」）が 使用されます。 各BASEディレクティブは、 直前のベースURIを基準として、新しいスコープ内ベースURIを設定します。

SRL文書では、 3つの形式のエスケープを使用します：

• 数値エスケープシーケンスは、 Unicodeコードポイントの値を表します。

  数値エスケープシーケンスは、次の範囲のコードポイント値を生成してはなりません： U+D800からU+DFFFまで。 これはUnicode サロゲートの範囲です。

  エスケープシーケンス	Unicodeコードポイント
  \u hex hex hex hex	最上位桁から最下位桁の順に解釈される4桁の16進数によって 符号化された値に対応する、 U+0000からU+D7FFまで、および U+E000からU+FFFFまでの範囲にある Unicodeコードポイント。
  \U hex hex hex hex hex hex hex hex	最上位桁から最下位桁の順に解釈される8桁の16進数によって 符号化された値に対応する、 U+0000から U+D7FFまで、および U+E000からU+10FFFFまでの範囲にある Unicodeコードポイント。

  ここで、hexは16進文字です

  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 コードポイントを明確にするため、 次の表では、このセクションで使用される特定の 文字について説明します。