You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jena.apache.org by gi...@apache.org on 2020/04/29 09:57:26 UTC
[jena-site] branch asf-site updated: Updated site from master
(12ce614a8b2523f9bd8deec40792f958d3613f4a)
This is an automated email from the ASF dual-hosted git repository.
git-site-role pushed a commit to branch asf-site
in repository https://gitbox.apache.org/repos/asf/jena-site.git
The following commit(s) were added to refs/heads/asf-site by this push:
new 89978c1 Updated site from master (12ce614a8b2523f9bd8deec40792f958d3613f4a)
89978c1 is described below
commit 89978c10936edc04cd203d776ea4a68f28dc8a6a
Author: jenkins <bu...@apache.org>
AuthorDate: Wed Apr 29 09:57:22 2020 +0000
Updated site from master (12ce614a8b2523f9bd8deec40792f958d3613f4a)
---
content/.htaccess | 5 ++
content/documentation/inference/index.html | 84 +++++++++++++++---------------
content/sitemap.xml | 4 +-
3 files changed, 49 insertions(+), 44 deletions(-)
diff --git a/content/.htaccess b/content/.htaccess
index cf075b8..4e4b6f8 100644
--- a/content/.htaccess
+++ b/content/.htaccess
@@ -7,3 +7,8 @@ AddType application/owl+xml .owl
AddType text/trig .trig
AddType application/n-quads .nq
+
+RewriteEngine on
+# Switch http to https
+RewriteCond %{HTTPS} !=on
+RewriteRule ^(.*)$ https://%{SERVER_NAME}%{REQUEST_URI} [L,R]
diff --git a/content/documentation/inference/index.html b/content/documentation/inference/index.html
index 177c67b..5d15422 100644
--- a/content/documentation/inference/index.html
+++ b/content/documentation/inference/index.html
@@ -265,7 +265,7 @@
</li>
</ol>
<h3 id="reasonerAPI">Generic reasoner API</h3>
-<p>####Finding a reasoner</p>
+<h4 id="finding-a-reasoner">Finding a reasoner</h4>
<p>For each type of reasoner there is a factory class (which conforms to the interface
<code><a href="/documentation/javadoc/jena/org/apache/jena/reasoner/ReasonerFactory.html">ReasonerFactory</a></code>)
an instance of which can be used to create instances of the associated
@@ -289,7 +289,7 @@
<p>Similarly, if all you want is a plain RDF Model with RDFS inference included
then the convenience methods <code>ModelFactory.createRDFSModel</code> can be
used. </p>
-<p>####Configuring a reasoner</p>
+<h4 id="configuring-a-reasoner">Configuring a reasoner</h4>
<p>The behaviour of many of the reasoners can be configured. To allow arbitrary
configuration information to be passed to reasoners we use RDF to encode the
configuration details. The <code>ReasonerFactory.create</code> method can be
@@ -304,7 +304,7 @@
<p>The parameter value can normally be a String or a structured value. For example,
to set a boolean value one can use the strings "true" or "false",
or in Java use a Boolean object or in RDF use an instance of xsd:Boolean</p>
-<p>####Applying a reasoner to data</p>
+<h4 id="applying-a-reasoner-to-data">Applying a reasoner to data</h4>
<p>Once you have an instance of a reasoner it can then be attached to a set of
RDF data to create an inference model. This can either be done by putting all
the RDF data into one Model or by separating into two components - schema and
@@ -319,14 +319,14 @@
<p>To bind the reasoner to the final data set to create an inference model see
the <a href="/documentation/javadoc/jena/org/apache/jena/rdf/model/ModelFactory.html"><code>ModelFactory</code></a>
methods, particularly <code>ModelFactory.createInfModel</code>. </p>
-<p>####Accessing inferences</p>
+<h4 id="accessing-inferences">Accessing inferences</h4>
<p>Finally, having created a inference model then any API operations which access
RDF statements will be able to access additional statements which are entailed
from the bound data by means of the reasoner. Depending on the reasoner these
additional <i>virtual</i> statements may all be precomputed the first time the
model is touched, may be dynamically recomputed each time or may be computed
on-demand but cached.</p>
-<p>####Reasoner description</p>
+<h4 id="reasoner-description">Reasoner description</h4>
<p>The reasoners can be described using RDF metadata which can be searched to
locate reasoners with appropriate properties. The calls <code>Reasoner.getCapabilities</code>
and <code>Reasoner.supportsProperty</code> are used to access this descriptive
@@ -408,7 +408,7 @@ InfModel inf = ModelFactory.createInfModel(boundReasoner, data);
from the combination of the two. Any updates to the InfModel will be reflected
in updates to the underlying data model - the schema model will not be affected.</p>
<p>[<a href="#api">API index</a>] [<a href="#index">main index</a>]</p>
-<p>###Operations on inference models {#operationsOnInferenceModels}</p>
+<h3 id="operationsOnInferenceModels">Operations on inference models</h3>
<p>For many applications one simply creates a model incorporating some inference
step, using the <code>ModelFactory</code> methods, and then just works within
the standard Jena Model API to access the entailed statements. However, sometimes
@@ -479,7 +479,7 @@ if (validity.isValid()) {
an additional method <code>Report.isClean()</code> which returns true if the
ontology is both valid (logically consistent) and generated no warnings (such
as inconsistent classes).</p>
-<p>####<a name="extendedListStatements"></a>Extended list statements</p>
+<h4 id="extendedListStatements">Extended list statements</h4>
<p>The default API supports accessing all entailed information at the level of
individual triples. This is surprisingly flexible but there are queries which
cannot be easily supported this way. The first such is when the query needs
@@ -498,7 +498,7 @@ if (validity.isValid()) {
preloading your data with expressions you might need to query over. However,
for some external reasoners, especially description logic reasoners, we anticipate
restricted uses of this form of listStatement will be important.</p>
-<p>####<a name="directRelations"></a>Direct and indirect relationships</p>
+<h4 id="directRelations">Direct and indirect relationships</h4>
<p>The second type of operation that is not obviously convenient at the triple
level involves distinguishing between direct and indirect relationships. If
a relation is transitive, for example rdfs:subClassOf, then we can define the
@@ -519,7 +519,7 @@ if (validity.isValid()) {
<p>Typically the easiest way to work with such indirect and direct relations is
to use the <a href="../ontology/index.html">Ontology API</a> which hides the
grubby details of these property aliases.</p>
-<p>####<a name="derivations"></a>Derivations</p>
+<h4 id="derivations">Derivations</h4>
<p>It is sometimes useful to be able to trace where an inferred statement was
generated from. This is achieved using the <code>InfModel.getDerivation(Statement)</code>
method. This returns a iterator over a set <a href="/documentation/javadoc/jena/org/apache/jena/reasoner/Derivation.html"><code>Derviation</code></a>
@@ -568,7 +568,7 @@ out.flush();
Fact (eg:B eg:p eg:C)
Fact (eg:C eg:p eg:D)</i>
</pre>
-<p>####<a name="rawAccess"></a>Accessing raw data and deductions</p>
+<h4 id="rawAccess">Accessing raw data and deductions</h4>
<p>From an <code>InfModel</code> it is easy to retrieve the original, unchanged,
data over which the model has been computed using the <code>getRawModel()</code>
call. This returns a model equivalent to the one used in the initial <code>bind</code>
@@ -577,7 +577,7 @@ out.flush();
<p>Some reasoners, notably the forward chaining rule engine, store the deduced
statements in a concrete form and this set of deductions can be obtained separately
by using the <code>getDeductionsModel()</code> call. </p>
-<p>####<a name="processingControl"></a>Processing control</p>
+<h4 id="processingControl">Processing control</h4>
<p>Having bound a <code>Model</code> into an <code>InfModel</code> by using a
<code>Reasoner</code> its content can still be changed by the normal <code>add</code>
and <code>remove</code> calls to the <code>InfModel</code>. Any such change
@@ -604,7 +604,7 @@ out.flush();
call. It there are any outstanding queries (i.e. StmtIterators which have not
been read to the end yet) then those will be aborted (the next hasNext() call
will return false).</p>
-<p>####<a name="tracing"></a>Tracing</p>
+<h4 id="tracing">Tracing</h4>
<p>When developing new reasoner configurations, especially new rule sets for the
rule engines, it is sometimes useful to be able to trace the operations of the
associated inference engine. Though, often this generates too much information
@@ -617,14 +617,14 @@ out.flush();
its underlying InfGraph and calling <code>setTraceOn()</code> call. If you need
to make use of this see the full javadoc for the relevant InfGraph implementation.</p>
<p>[<a href="#api">API index</a>] [<a href="#index">main index</a>]</p>
-<p>##<a name="rdfs"></a>The RDFS reasoner</p>
+<h2 id="rdfs">The RDFS reasoner</h2>
<ol>
<li><a href="#RDFSintro">RDFS reasoner - introduction and coverage</a></li>
<li><a href="#RDFSconfiguration">RDFS Configuration</a></li>
<li><a href="#RDFSexamples">RDFS Example</a></li>
<li><a href="#RDFSnotes">RDFS implementation and performance notes</a></li>
</ol>
-<p>###<a name="RDFSintro"></a>RDFS reasoner - intro and coverage</p>
+<h3 id="RDFSintro">RDFS reasoner - intro and coverage</h3>
<p>Jena includes an RDFS reasoner (<code>RDFSRuleReasoner</code>) which supports
almost all of the RDFS entailments described by the RDF Core working group [<a href="https://www.w3.org/TR/rdf-mt/">RDF
Semantics</a>]. The only omissions are deliberate and are described below.</p>
@@ -652,7 +652,7 @@ _:anon1 rdf:type datatype .
additional bNode triples, even in <i>virtual</i> triple form, is negligible
and so this has been deliberately omitted from the reasoner. </p>
<p>[<a href="#rdfs">RDFS index</a>] [<a href="#index">main index</a>]</p>
-<p>###<a name="RDFSconfiguration"></a>RDFS configuration</p>
+<h3 id="RDFSconfiguration">RDFS configuration</h3>
<p>The RDFSRuleReasoner can be configured to work at three different compliance
levels: </p>
<dl>
@@ -740,7 +740,7 @@ Reasoner reasoner = RDFSRuleReasonerFactory.theInstance()Create(config);
</tr>
</table>
<p>[<a href="#rdfs">RDFS index</a>] [<a href="#index">main index</a>]</p>
-<p>###<a name="RDFSexamples"></a>RDFS Example</p>
+<h3 id="RDFSexamples">RDFS Example</h3>
<p>As a complete worked example let us create a simple RDFS schema, some instance
data and use an instance of the RDFS reasoner to query the two.</p>
<p>We shall use a trivial schema:</p>
@@ -820,7 +820,7 @@ that is not compatible with 13</i></pre>
<p>because the age was given using an RDF plain litera where as the schema requires
it to be a datatyped literal which is compatible with xsd:integer.</p>
<p>[<a href="#rdfs">RDFS index</a>] [<a href="#index">main index</a>]</p>
-<p>###<a name="RDFSnotes"></a>RDFS implementation and performance notes</p>
+<h3 id="RDFSnotes">RDFS implementation and performance notes</h3>
<p>The RDFSRuleReasoner is a hybrid implementation. The subproperty and subclass
lattices are eagerly computed and stored in a compact in-memory form using the
TransitiveReasoner (see below). The identification of which container membership
@@ -878,7 +878,7 @@ that is not compatible with 13</i></pre>
on adapting the rule engines to exploit the capabilities of the more sophisticated
database backends will be considered.</p>
<p>[<a href="#rdfs">RDFS index</a>] [<a href="#index">main index</a>]</p>
-<p>##<a name="owl"></a>The OWL reasoner</p>
+<h2 id="owl">The OWL reasoner</h2>
<ol>
<li><a href="#OWLintro">OWL reasoner introduction</a></li>
<li><a href="#OWLcoverage">OWL coverage</a></li>
@@ -895,7 +895,7 @@ an external DL reasoner such as Pellet, Racer or FaCT. Performance (especially m
configuration still leaves something to be desired and will the subject of future work - time permitting.</p>
<p>See also <a href="#OWLnotes">subsection 5</a> for notes on more specific limitations
of the current implementation. </p>
-<p>###<a name="OWLcoverage"></a>OWL coverage</p>
+<h3 id="OWLcoverage">OWL coverage</h3>
<p>The Jena OWL reasoners could be described as instance-based reasoners. That
is, they work by using rules to propagate the if- and only-if- implications of
the OWL constructs on instance data. Reasoning about classes is done indirectly
@@ -1114,7 +1114,7 @@ configuration still leaves something to be desired and will the subject of futur
restriction.</li>
</ul>
<p>[<a href="#owl">OWL index</a>] [<a href="#index">main index</a>]</p>
-<p>###<a name="OWLconfiguration"></a>OWL Configuration</p>
+<h3 id="OWLconfiguration">OWL Configuration</h3>
<p>This reasoner is accessed using <code>ModelFactory.createOntologyModel</code>
with the prebuilt <a href="/documentation/javadoc/jena/org/apache/jena/ontology/OntModelSpec.html"><code>OntModelSpec</code></a>
<code>OWL_MEM_RULE_INF</code> or manually via <code>ReasonerRegistery.getOWLReasoner()</code>.</p>
@@ -1151,7 +1151,7 @@ configuration still leaves something to be desired and will the subject of futur
of the rule-based approach we imagine useful subsets of functionality emerging
- like that supported by the RDFS reasoner in the form of the level settings.</p>
<p>[<a href="#owl">OWL index</a>] [<a href="#index">main index</a>]</p>
-<p>###<a name="OWLexamples"></a>OWL Example</p>
+<h3 id="OWLexamples">OWL Example</h3>
<p>As an example of using the OWL inference support, consider the sample schema
and data file in the data directory - <a href="data/owlDemoSchema.xml">owlDemoSchema.xml</a>
and <a href="data/owlDemoData.xml">owlDemoData.xml</a>. </p>
@@ -1244,8 +1244,8 @@ Implicated node: eg:bigNameSpecialMB</i>
referencing two motherboards which are explicitly defined to be different resources
and thus violate the FunctionProperty nature of <code>hasMotherBoard</code>.</p>
<p>[<a href="#owl">OWL index</a>] [<a href="#index">main index</a>]</p>
-<p>###<a name="OWLnotes"></a>OWL notes and limitations</p>
-<p>####Comprehension axioms</p>
+<h3 id="OWLnotes">OWL notes and limitations</h3>
+<h4 id="comprehension-axioms">Comprehension axioms</h4>
<p>A critical implication of our variant of the instance-based approach is that
the reasoner does not directly answer queries relating to dynamically introduced
class expressions.</p>
@@ -1273,12 +1273,12 @@ class B = cardinality(P,1)</pre>
Jena rule reasoner passes these tests only after they have been rewritten to
avoid the comprehension requirements.<br>
</p>
-<p>####Prototypes</p>
+<h4 id="prototypes">Prototypes</h4>
<p>As noted above the current OWL rule set introduces prototypical instances for
each defined class. These prototypical instances used to be visible to queries.
From release 2.1 they are used internally but should not longer be visible.
</p>
-<p>####Direct/indirect</p>
+<h4 id="directindirect">Direct/indirect</h4>
<p>We noted <a href="#directRelations">above</a> that the Jena reasoners support
a separation of direct and indirect relations for transitive properties such
as subClassOf. The current implementation of the full and mini OWL reasoner
@@ -1286,7 +1286,7 @@ class B = cardinality(P,1)</pre>
reasoner, which is but a small extension of RDFS, does support the direct queries.</p>
<p>This does not affect querying though the Ontology API, which works around this
limitation. It only affects direct RDF accesses to the inference model.</p>
-<p>####Performance</p>
+<h4 id="performance">Performance</h4>
<p>The OWL reasoners use the rule engines for all inference. The full and mini
configurations omit some of the performance tricks employed by the RDFS reasoner
(notably the use of the custom transitive reasoner) making those OWL reasoner
@@ -1314,7 +1314,7 @@ class B = cardinality(P,1)</pre>
and oversights. We intend that the reasoner should be sound (all inferred triples
should be valid) but not complete. </p>
<p>[<a href="#owl">OWL index</a>] [<a href="#index">main index</a>]</p>
-<p>##<a name="transitive"></a>The transitive reasoner</p>
+<h2 id="transitive">The transitive reasoner</h2>
<p>The TransitiveReasoner provides support for storing and traversing class and
property lattices. This implements just the <i>transitive</i> and <i>symmetric</i>
properties of <code>rdfs:subPropertyOf</code> and <code>rdfs:subClassOf</code>.
@@ -1330,7 +1330,7 @@ class B = cardinality(P,1)</pre>
used in the default RDFS reasoner.</p>
<p>It has no configuration options.</p>
<p>[<a href="#index">Index</a>]</p>
-<p>##<a name="rules"></a>The general purpose rule engine</p>
+<h2 id="rules">The general purpose rule engine</h2>
<ol>
<li><a href="#RULEoverview">Overview of the rule engine(s)</a></li>
<li><a href="#RULEsyntax">Rule syntax and structure</a></li>
@@ -1344,7 +1344,7 @@ class B = cardinality(P,1)</pre>
<li><a href="#RULEnotes">Notes</a></li>
<li><a href="#RULEextensions">Extensions</a></li>
</ol>
-<p>###<a name="RULEoverview"></a>Overview of the rule engine(s)</p>
+<h3 id="RULEoverview">Overview of the rule engine(s)</h3>
<p>Jena includes a general purpose rule-based reasoner which is used to implement
both the RDFS and OWL reasoners but is also available for general use. This
reasoner supports rule-based inference over RDF graphs and provides forward
@@ -1363,7 +1363,7 @@ class B = cardinality(P,1)</pre>
The current release includes a starting set of primitives which are sufficient
for the RDFS and OWL implementations but is easily extensible.</p>
<p>[<a href="#rules">rule index</a>] [<a href="#index">main index</a>]</p>
-<h3 id="a-namerulesyntaxarule-syntax-and-structure"><a name="RULEsyntax"></a>Rule syntax and structure</h3>
+<h3 id="RULEsyntax">Rule syntax and structure</h3>
<p>A rule for the rule-based reasoner is defined by a Java <code><a href="/documentation/javadoc/jena/org/apache/jena/reasoner/rulesys/Rule.html">Rule</a></code>
object with a list of body terms (premises), a list of head terms (conclusions)
and an optional name and optional direction. Each term or <a href="/documentation/javadoc/jena/org/apache/jena/reasoner/rulesys/ClauseEntry.html"><code>ClauseEntry</code></a>
@@ -1471,7 +1471,7 @@ a single extra rule is:
</code></pre>
</p>
<p>[<a href="#rules">Rule index</a>] [<a href="#index">main index</a>]</p>
-<h3 id="a-nameruleforwardaforward-chaining-engine"><a name="RULEforward"></a>Forward chaining engine</h3>
+<h3 id="RULEforward">Forward chaining engine</h3>
<p>If the rule reasoner is configured to run in forward mode then only the forward
chaining engine will be used. The first time the inference Model is queried
(or when an explicit <code>prepare()</code> call is made, see <a href="#processingControl">above</a>)
@@ -1509,7 +1509,7 @@ a single extra rule is:
engine is likely to be eliminated in a future release once more tuning has been
done to the default RETE engine.</p>
<p>[<a href="#rules">Rule index</a>] [<a href="#index">main index</a>]</p>
-<p>###<a name="RULEbackward"></a>Backward chaining engine</p>
+<h3 id="RULEbackward">Backward chaining engine</h3>
<p>If the rule reasoner is run in backward chaining mode it uses a logic programming
(LP) engine with a similar execution strategy to Prolog engines. When the inference
Model is queried then the query is translated into a goal and the engine attempts
@@ -1575,7 +1575,7 @@ triple(s1, p1, o1) :- triple(sb1, pb1, ob1), ...
might be run in either backward or forward mode then they should be limited to a single consequent each.
</p>
<p>[<a href="#rules">Rule index</a>] [<a href="#index">main index</a>]</p>
-<p>###<a name="RULEhybrid"></a>Hybrid rule engine</p>
+<h3 id="RULEhybrid">Hybrid rule engine</h3>
<p>The rule reasoner has the option of employing both of the individual rule engines
in conjunction. When run in this <i>hybrid</i> mode the data flows look something
like this: </p>
@@ -1615,7 +1615,7 @@ might be run in either backward or forward mode then they should be limited to a
forward rules still work incrementally, including incrementally asserting or
removing backward rules in response to the data changes.</p>
<p>[<a href="#rules">Rule index</a>] [<a href="#index">main index</a>]</p>
-<p>###<a name="RULEconfiguration"></a>GenericRuleReasoner configuration</p>
+<h3 id="RULEconfiguration">GenericRuleReasoner configuration</h3>
<p>As with the other reasoners there are a set of parameters, identified by RDF
properties, to control behaviour of the <code>GenericRuleReasoner</code>. These
parameters can be set using the <code>Reasoner.setParameter</code> call or passed
@@ -1716,7 +1716,7 @@ Reasoner reasoner = new GenericRuleReasoner(rules);</pre>
</tr>
</table>
<p>[<a href="#rules">Rule index</a>] [<a href="#index">main index</a>]</p>
-<h3 id="a-namerulebuiltinsabuiltin-primitives"><a name="RULEbuiltins"></a>Builtin primitives</h3>
+<h3 id="RULEbuiltins">Builtin primitives</h3>
<p>The procedural primitives which can be called by the rules are each implemented
by a Java object stored in a registry. Additional primitives can be created
and registered - see below for more details.</p>
@@ -1937,7 +1937,7 @@ do not "pollute" the inference results.</div>
</tr>
</table>
<p>[<a href="#rules">Rule index</a>] [<a href="#index">main index</a>]</p>
-<h3 id="a-nameruleexamplesaexample"><a name="RULEexamples"></a>Example</h3>
+<h3 id="RULEexamples">Example</h3>
<p>As a simple illustration suppose we wish to create a simple ontology language
in which we can declare one property as being the concatenation of two others
and to build a rule reasoner to implement this.</p>
@@ -1968,7 +1968,7 @@ while (list.hasNext()) {
<pre><i>A * * =>
- [urn:x-hp:eg/A, urn:x-hp:eg/p, urn:x-hp:eg/B]
- [urn:x-hp:eg/A, urn:x-hp:eg/r, urn:x-hp:eg/C]</i></pre>
-<p>####Example 2</p>
+<h4 id="example-2">Example 2</h4>
<p>As a second example, we'll look at ways to define a property as being both
symmetric and transitive. Of course, this can be done directly in OWL but there
are times when one might wish to do this outside of the full OWL rule set and,
@@ -2030,7 +2030,7 @@ System.out.println(” - " + PrintUtil.print(i.nextStatement()));
[ (?A ?P ?C) <- (?A ?P ?B), (?B ?P ?C) ]
] </pre></p>
<p>[<a href="#rules">rule index</a>] [<a href="#index">main index</a>]</p>
-<p>###<a name="RDFSPlusRules"></a>Combining RDFS/OWL with custom rules</p>
+<h3 id="RDFSPlusRules">Combining RDFS/OWL with custom rules</h3>
<p>Sometimes one wishes to write generic inference rules but combine them
with some RDFS or OWL inference. With the current Jena architecture limited forms of this
is possible but you need to be aware of the limitations.</p>
@@ -2087,7 +2087,7 @@ InfModel inf = ModelFactory.createInfModel(reasoner, data);
[rdfs9: (?x rdfs:subClassOf ?y), (?a rdf:type ?x) -> (?a rdf:type ?y)]
</pre>
<p>[<a href="#rules">rule index</a>] [<a href="#index">main index</a>]</p>
-<p>###<a name="RULEnotes"></a>Notes</p>
+<h3 id="RULEnotes">Notes</h3>
<p>One final aspect of the general rule engine to mention is that of validation
rules. We described earlier how reasoners can implement a <code>validate</code>
call which returns a set of error reports and warnings about inconsistencies
@@ -2117,7 +2117,7 @@ InfModel inf = ModelFactory.createInfModel(reasoner, data);
<p>Future extensions will improve the formatting capabilities and flexibility
of this mechanism. </p>
<p>[<a href="#rules">Rule index</a>] [<a href="#index">main index</a>]</p>
-<p>###<a name="RULEextensions"></a>Extensions</p>
+<h3 id="RULEextensions">Extensions</h3>
<p>There are several places at which the rule system can be extended by application
code.</p>
<h4 id="rule-syntax">Rule syntax</h4>
@@ -2149,7 +2149,7 @@ InfModel inf = ModelFactory.createInfModel(reasoner, data);
and the <a href="/documentation/javadoc/jena/org/apache/jena/reasoner/rulesys/RulePreprocessHook.html"><code>RulePreprocessHook</code></a>
class for more details.</p>
<p>[<a href="#index">Index</a>]</p>
-<p>##<a name="extensions"></a>Extending the inference support</p>
+<h2 id="extensions">Extending the inference support</h2>
<p>Apart from the extension points in the rule reasoner discussed above, the intention
is that it should be possible to plug external inference engines into Jena.
The core interfaces of <code>InfGraph</code> and <code>Reasoner</code> are kept
@@ -2160,7 +2160,7 @@ InfModel inf = ModelFactory.createInfModel(reasoner, data);
freely available, reasoner to both validate the machinery and to provide an
example of how this extension can be done.</p>
<p>[<a href="#index">Index</a>]</p>
-<p>##<a name="futures"></a>Futures</p>
+<h2 id="futures">Futures</h2>
<p>Contributions for the following areas would be very welcome:</p>
<ul>
<li>Develop a custom equality reasoner which can handle the "owl:sameAs"
diff --git a/content/sitemap.xml b/content/sitemap.xml
index 1f77b97..2b0561d 100644
--- a/content/sitemap.xml
+++ b/content/sitemap.xml
@@ -299,7 +299,7 @@
<url>
<loc>https://jena.apache.org/documentation.html</loc>
- <lastmod>2020-04-22T11:21:55-05:00</lastmod>
+ <lastmod>2020-04-28T17:30:14+01:00</lastmod>
</url>
<url>
@@ -664,7 +664,7 @@
<url>
<loc>https://jena.apache.org/documentation/inference/</loc>
- <lastmod>2020-02-28T13:09:12+01:00</lastmod>
+ <lastmod>2020-04-28T17:30:14+01:00</lastmod>
</url>
<url>