add section about 'unstar' mapping

spec/ex-classicize-input.ttl

@@ -0,0 +1,5 @@
+PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+PREFIX ex: <http://example.org/>
+
+<< ex:s ex:p ex:o >> ex:q "some value".
+

spec/ex-classicize-input2.ttl

@@ -0,0 +1,5 @@
+PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+PREFIX ex: <http://example.org/>
+
+_:r1 rdf:reifies <<( ex:s ex:p ex:o )>>.
+_:r1 ex:q "some value".

spec/ex-classicize-output.ttl

@@ -0,0 +1,11 @@
+PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+PREFIX ex: <http://example.org/>
+
+_:r1 rdf:reifies _:gen1.
+_:r1 ex:q "some value".
+
+_:gen1 a rdf:TripleTerm ;
+  rdf:ttSubject ex:s;
+  rdf:ttPredicate ex:p;
+  rdf:ttObject ex:o.
+

spec/index.html

@@ -38,7 +38,8 @@
       github: "https://github.com/w3c/rdf-concepts/",
       group:           "rdf-star",
       doJsonLd:     true,
-      wgPublicList: "public-rdf-star-wg"
+      wgPublicList: "public-rdf-star-wg",
+      maxTocLevel: 2,
     };
   </script>
   <style>
@@ -49,6 +50,19 @@
     .grammar-literal { color: gray;}
     code {color: #ff4500;}  /* Old W3C Style */
     div.abnf {margin-left: 1em;}
+
+  .algorithm ol {
+    counter-reset: numsection;
+    list-style-type: none;
+  }
+  .algorithm ol>li {
+    margin: 0.5em 0;
+  }
+  .algorithm ol>li:before {
+    font-weight: bold;
+    counter-increment: numsection;
+    content: counters(numsection, ".") ") ";
+  }
   </style>
 </head>
 
@@ -502,12 +516,12 @@ <h3>RDF Documents and Syntaxes</h3>
   <p>This specification establishes two conformance levels:</p>
 
   <ul>
-    <li><dfn class="no-export lint-ignore">Full conformance</dfn>
+    <li><dfn class="no-export lint-ignore" data-lt="full">Full conformance</dfn>
       supports <a data-lt="RDF graph">graphs</a> and <a data-lt="RDF dataset">datasets</a>
       with <a>triples</a> that contain <a>triple terms</a>.
       Concrete syntaxes in which such graphs and datasets can be expressed include
       [[RDF12-N-TRIPLES]], [[RDF12-N-QUADS]], [[RDF12-TURTLE]], and [[RDF12-TRIG]].</li>
-    <li><dfn class="no-export lint-ignore">Classic conformance</dfn>
+    <li><dfn class="no-export lint-ignore" data-lt="classic">Classic conformance</dfn>
       only supports <a data-lt="RDF graph">graphs</a> or <a data-lt="RDF dataset">datasets</a>
       with <a>triples</a> that do not contain <a>triple terms</a>.</li>
   </ul>
@@ -895,7 +909,6 @@ <h3>Triple Terms</h3>
       Every <a>triple</a> whose <a>object</a> is not a <a>triple term</a> SHOULD NOT
       use <code>http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies</code> (<code>rdf:reifies</code>)
       as its <a>predicate</a>.</p>
-
   </section>
 
   <section id="graph-isomorphism">
@@ -1489,6 +1502,253 @@ <h2>Generalizations of RDF Triples, Graphs, and Datasets</h2>
 </section>
 
 
+<section id="section-classic-full-interop" class="informative">
+  <h2>Interoperability between RDF [=Classic=] and RDF [=Full=]</h2>
+
+  <p class=issue>Should we make this section normative?</p>
+
+  <p>This section provides transformations between [=Full=] [=RDF graphs=] (respectively, [=RDF datasets=]) and [=Classic=] [=RDF graphs=] (respectively, [=RDF datasets=]),
+  to provide some level of interoperability between the different classes of <a href="#conformance">Conformance</a>.
+
+  <p class=issue>Should we go even further and aim to provide interoperability between <em>RDF 1.1</em> and RDF 1.2 [=Full=]?</p>
+
+  <p class=issue>AT RISK: The Working Group may decide to replace the terms `rdf:TripleTerm`, `rdf:ttSubject`, `rdf:ttPredicate`, and `rdf:ttObject` used in this section with other terms, possibly in a different namespace.</p>
+
+  <p>These transformation are designed to be:</p>
+
+  <dl>
+    <dt>Information preserving</dt>
+    <dd>It must be possible to reconstruct the input graph (respectively, dataset) from the output graph (respectively, dataset).
+      Note, however, that these transformations are not designed to preserve semantics:
+      the output graph is not semantically [=equivalent=] to the input graph,
+      at least not in the entailment regimes defined in [[RDF12-SEMANTICS]].
+    </dd>
+    <dt>Idempotent</dt>
+    <dd>Applying a transformation several times to a graph (respectively, dataset) should have the same effect as applying it once.
+      Moreover, [=classicizing=] a graph (respectively, dataset) that is already complying with RDF [=Classic=] (i.e., containing no [=triple term=]) must result in the same graph (respectively, dataset).
+    </dd>
+    <dt>Universal</dt>
+    <dd>It should be possible to transform any [=Full=] graph (respectively, dataset) to a [=Classic=] graph (respectively, dataset) using this method.
+      There is actually <a href="#section-classicize-caveat">a minor caveat</a> to this property.
+    </dd>
+  </dl>
+
+  <section id="section-classicize-definition">
+    <h2>From [=Full=] to [=Classic=]</h2>
+
+    <p>
+      Encoding an [=RDF graph=] to ensure that it is consumable by an RDF [=Classic=] implementation is called <dfn data-lt="classicize|classicized">classicizing</dfn> it.
+      [=Classicizing=] consists of repeating the following steps until no [=triple term=] [=appears=] in the graph, and the graph is therefore compliant with RDF [=Classic=]: picking a [=triple term=] <var>tt</var> that [=appears=] in the graph; minting a fresh [=blank node=] <var>b</var>
+      (i.e., a blank node not yet in use in the graph); replacing all occurrences of <var>tt</var> [=appearing=] in the graph with <var>b</var>;
+      and then adding the following triples to the graph (where <var>s</var>, <var>p</var>, and <var>o</var> are respectively the [=subject=], [=predicate=] and [=object=] of <var>tt</var>):
+    </p>
+    <ul>
+      <li>(<var>b</var>, `rdf:type`, `rdf:TripleTerm`)
+      <li>(<var>b</var>, `rdf:ttSubject`, <var>s</var>)
+      <li>(<var>b</var>, `rdf:ttPredicate`, <var>p</var>)
+      <li>(<var>b</var>, `rdf:ttObject`, <var>o</var>)
+    </ul>
+
+    <p>Note that this transformation is <em>information preserving</em> only when the input graph either has no [=triple term=] [=appearing=] in it,
+      or contains no [=asserted=] triple (<var>b</var>, `rdf:type`, `rdf:TripleTerm`) where <var>b</var> is a [=blank node=].
+      Implementations encountering this situation MUST report an error.
+      This limitation is discussed in Section <a href="#section-classicize-caveat"></a>.
+    </p>
+
+    <p class=note>The blank nodes generated to replace [=triple terms=] should not be confused with the [=reifiers=] that are typically associated with these [=triple terms=].</p>
+
+    <p>
+      [=Classicizing=] an [=RDF dataset=] consists of [=classicizing=] its [=default graph=] and each of its [=named graph=].
+      In this case, the fresh [=blank node=] assigned to each [=triple term=] must not be used in any graph of the dataset.
+    </p>
+
+    <p>
+      A detailed algorithm of the transformation is found in Section <a href="#section-classicize-algo"></a>.
+    </p>
+
+    <section id="section-classicize-example">
+      <h2>Example</h2>
+
+      <p>The examples in this section are expressed in the Turtle concrete syntax [[RDF12-TURTLE]].</p>
+
+      <pre id="ex-classicize-input"
+       class="example nohighlight"
+       title="An input Full RDF graph"
+       data-include="./ex-classicize-input.ttl"
+       data-include-format="text"
+      ></pre>
+
+      <pre id="ex-classicize-input2"
+       class="example nohighlight"
+       title="The same graph as above, with reifiers made explicit"
+       data-include="./ex-classicize-input2.ttl"
+       data-include-format="text"
+      ></pre>
+
+      <pre id="ex-classicize-output"
+       class="example nohighlight"
+       title="The result of classicizing the dataset above"
+       data-include="./ex-classicize-output.ttl"
+       data-include-format="text"
+      ></pre>
+
+    </section>
+
+  </section>
+
+  <section id="section-unclassicize-definition">
+    <h2>From [=Classic=] to [=Full=]</h2>
+
+    <p>Reverting a [=classicized=] graph to its original form consists of locating
+      each [=asserted=] triple (<var>b</var>, `rdf:type`, `rdf:TripleTerm`)
+      that has a [=blank node=] <var>b</var> as its subject,
+      along with the three associated [=asserted=] triples
+      that have the same [=blank node=] <var>b</var> as their subjects, i.e.,
+      (<var>b</var>, `rdf:ttSubject`, <var>s</var>),
+      (<var>b</var>, `rdf:ttPredicate`, <var>p</var>),
+      and (<var>b</var>, `rdf:ttObject`, <var>o</var>);
+      removing these four triples from the graph;
+      and replacing all remaining occurrences of <var>b</var> [=appearing=] in the graph
+      with the triple term (<var>s</var>, <var>p</var>, <var>o</var>).
+    </p>
+
+    <p>An implementation MUST report an error if, for a given <var>b</var>,
+      it can not unambiguously determine <var>s</var>, <var>p</var>, or <var>o</var>
+      (i.e., if one of the properties of <var>b</var>
+      — `rdf:ttSubject`, `rdf:ttPredicate`, or `rdf:ttObject` —
+      is missing or duplicated).
+      An implementation MUST also report an error if the input graph contains
+      at the same time a [=triple term=] and an [=asserted triple=]
+      (<var>b</var>, `rdf:type`, `rdf:TripleTerm`)
+      where <var>b</var> is the same [=blank node=].
+      Note that none of these situations can occur if the input graph was produced by the [=classicize=] transformation.
+    </p>
+
+    <p>To revert a [=classicized=] [=RDF dataset=] to its original form, the transformation above is applied to its [=default graph=] and to each of its [=named graphs=].
+    </p>
+
+    <p>Note that this transformation has no effect on any [=RDF graph=] or [=RDF dataset=] that does not use the `rdf:TripleTerm` type,
+      including [=Full=] graphs or datasets containing [=triple terms=].
+      This makes this transformation <em>idempotent</em> as intended.
+    </p>
+  </section>
+
+  <section id="section-classicize-caveat">
+    <h2>Limitations</h2>
+
+    <p>The two transformations above explicitly do not support graphs or datasets containing at the same time a [=triple term=] and an [=asserted triple=]
+      (<var>b</var>, `rdf:type`, `rdf:TripleTerm`)
+      where <var>b</var> is a [=blank node=].
+      This means that the [=classicize=] transformation is not <em>strictly</em> universal.
+    </p>
+
+    <p>This limitation should not be an issue in practice.
+      The `rdf:TripleTerm` type is unlikely to be in used in any published graph or dataset,
+      as it was not defined prior to this specification.
+      For this reason, using it would actually have been bad practice.
+      For future graphs and datasets, this type should be considered to be reserved for use within the [=classicize=] transformation, and not used otherwise.
+    </p>
+
+    <p class=note>
+      This is one reason why this transformation introduces new vocabulary terms
+      (`rdf:TripleTerm`, `rdf:ttSubject`, `rdf:ttPredicate`, `rdf::ttObject`),
+      rather than repurposing the existing <a data-cite="RDF12-SCHEMA#ch_reificationvocab">reification vocabulary</a>
+      (`rdf:Statement`, `rdf:subject`, `rdf:predicate`, `rdf:object`).
+      Unlike `rdf:TripleTerm`, `rdf:Statement` is known to be found in
+      widely used datasets (e.g., <a href="https://www.uniprot.org/">Uniprot</a>),
+      so reserving its use for the [=classicize=] transformation was not an option.
+    </p>
+
+    <p>Another consequence of this restriction is that implementers will need to be aware and careful when merging graphs in an application that [=classicizes=] graphs or datasets.
+      The concern is that merging a [=Full=] [=RDF graph=] containing at least one [=triple term=]
+      with a [=classicized=] [=RDF graph=] (which might contain [=blank node=] instances of `rdf:TripleTerm`)
+      could result in a "hybrid" graph that cannot be transformed to a consistent [=Full=] nor [=Classic=] [=RDF graph=].
+      Therefore, such applications should [=classicize=] every graph prior to merging them.
+      Conversely, applications supporting RDF [=Full=] should make sure to apply the reverse transformation
+      to any graph that is known or likely to have been [=classicized=],
+      to avoid creating such "hybrid" graphs.
+      Since these transformations are designed to be <em>idempotent</em>, there is no harm in applying them more than necessary.
+    </p>
+  </section>
+
+  <section>
+    <h2>Algorithms</h2>
+
+    <section id="section-classicize-algo" class="algorithm">
+      <h2>The `classicize` algorithm</h2>
+
+      <p>The algorithm expects one input variable <var>Gᵢ</var> which is an [=RDF graph=]. It returns a [=Classic=] [=RDF graph=].
+      </p>
+
+      <ol>
+        <li>Let <var>Gₒ</var> be an empty [=RDF graph=].</li>
+        <li>Let <var>M</var> be an empty map from [=triple terms=] to [=blank nodes=].</li>
+        <li>Let <var>inputKind</var> be `null`.</li>
+        <li>For each triple (<var>s</var>, <var>p</var>, <var>o</var>) in <var>Gᵢ</var>:<ol>
+          <li>If <var>s</var> is a [=blank node=], <var>p</var> is `rdf:type` and <var>o</var> is `rdf:TripleTerm`, then:<ol>
+            <li id="classicize-error1">If <var>inputKind</var> is `"full"` then exit with an error.</li>
+            <li>Otherwise, set <var>inputKind</var> to `"classic"`.</li>
+          </ol></li>
+          <li>If <var>o</var> is a [=triple term=], then:<ol>
+            <li id="classicize-error2">If <var>inputKind</var> is `"classic"` then exit with an error.</li>
+            <li>Otherwise, set <var>inputKind</var> to `"full"`.</li>
+            <li>Let <var>b</var>, <var>M'</var> and <var>G'</var> be the result of invoking <a href="#section-ctt-algo">`classicize-triple-term`</a> passing <var>o</var> as <var>t</var> and <var>M</var> as <var>Mi</var>.</li>
+            <li>Merge <var>M'</var> into <var>M</var>.
+            <li>Merge <var>G'</var> into <var>Gₒ</var>.
+            <li>Set <var>o</var> to <var>b</var>.
+          </ol></li>
+          <li>Add the triple (<var>s</var>, <var>p</var>, <var>o</var>) to <var>Gₒ</var>.</li>
+        </ol></li>
+        <li>Return <var>Gₒ</var>.</li>
+      </ol>
+    </section>
+
+    <section id="section-ctt-algo" class="algorithm">
+      <h2>The `classicize-triple-term` algorithm</h2>
+
+      <p>This algorithm is responsible for incrementally populating the mapping <var>M</var> and the graph <var>G</var> used internally by the <a href="#section-classicize-algo">`classicize`</a> algorithm. It receives a [=triple term=] as input and processes it recursively (in case its object is itself a [=triple term=]). It returns, among other things, the [=blank node=] minted to replace the [=triple term=] in the transformed [=Classic=] [=RDF graph=].</p>
+
+      <p>This algorithm expects two input variables:
+        a [=triple term=] <var>t</var>,
+        and a map <var>Mᵢ</var> from [=triple terms=] to [=blank nodes=].
+        It returns a [=blank node=] <var>b</var>,
+        a map <var>Mₒ</var> from [=triple terms=] to [=blank nodes=],
+        and a [=Classic=] [=RDF graph=] <var>G</var>.
+      </p>
+
+      <ol>
+        <li>Let <var>Mₒ</var> be an empty map.</li>
+        <li>Let <var>G</var> be an empty [=RDF graph=].</li>
+        <li>Let <var>b</var> be the [=blank node=] associated with <var>t</var> in <var>Mᵢ</var>, if any.
+        <li>Otherwise:<ol>
+          <li>Let <var>s</var>, <var>p</var> and <var>o</var> be the subject, predicate and object of <var>t</var>, respectively.</li>
+          <li>If <var>o</var> is a [=triple term=], then:<ol>
+            <li>Let <var>b'</var>, <var>M'</var> and <var>G'</var> be the result of invoking <a href="#section-ctt-algo">`classicize-triple-term`</a> passing <var>o</var> as <var>t</var> and <var>Mᵢ</var>.</li>
+            <li>Set <var>o</var> to <var>b'</var>.
+            <li>Merge <var>M'</var> into <var>Mₒ</var>.
+            <li>Merge <var>G'</var> into <var>G</var>.
+          </ol></li>
+          <li id="qtt-fresh-bnode">Let <var>b</var> be a fresh blank node.</li>
+          <li>Add the association (<var>t</var>, <var>b</var>) to <var>Mₒ</var>.</li>
+          <li>Add the triples (<var>b</var>, `rdf:type`, `rdf:TripleTerm`), (<var>b</var>, `rdf:ttSubject`, <var>s</var>), (<var>b</var>, `rdf:ttPredicate`, <var>p</var>), and (<var>b</var>, `rdf:ttObject`, <var>o</var>) in <var>G</var>.</li>
+        </ol></li>
+        <li>Return <var>b</var>, <var>Mₒ</var> and <var>G</var>.</li>
+      </ol>
+
+    </section>
+
+    <section id="section-unclassicize-algo" class="algorithm">
+      <h2>The `revert-classicize` algorithm</h2>
+
+      <p class=issue>Write this algorithm</p>
+    </section>
+
+
+  </section>
+
+
+</section>
+
 <section id="section-additional-datatypes" class="appendix">
   <h2>Additional Datatypes</h2>
   <p>This section defines additional <a>datatypes</a> that RDF implementations MAY support.</p>
@@ -1945,6 +2205,8 @@ <h3>Acknowledgments for RDF 1.2</h3>
   <h2>Changes between RDF 1.1 and RDF 1.2</h2>
 
   <ul>
+    <li>Added <a href="#section-classic-full-interop" class="sectionRef"></a>
+      for informative mappings between RDF [=Full=] and RDF [=Classic=].</li>
     <li>Added <a href="#section-dataset-quad" class="sectionRef"></a>
       for informative definition of a <a>quad</a>.</li>
    <li>Added <a href="#section-triple-terms-reification" class="sectionRef"></a>