vocabulary by an RDF datatype.

### RDF Semantics

RDF gives a semantics to graphs.  It defines four entailment regimes where

the concepts of a *valid graph* and *entailment* are defined.  An entailment

is a similar concept to an implication, when we interpret graphs as statements

about the world.  A graph G entails E, if in any world where G is "true", E is

also "true".

In order to prove an entailment, we need to check the validity of the claims of

every triples of E, with regards to G.  There is only one rule common to every

entailment regime: any triple is valid with regards to G if it is not valid.

#### The Simple Entailment Regime

The first entailment regime is the *simple entailment regime*, defined in

`(rdf entailment simple)`.  In this regime, any graph is valid, so we canot

derive False.  Since E can contain blank nodes, we need to create a mapping

from blank nodes in E to nodes (or blank nodes) in G.  G entails E if and

only if such a mapping exists and is valid, i. e. every mapped triple of E is

a triple of G.

The following procedures are available:

**Scheme Procedure**: `consistent-graph? graph`

Returns whether a graph is consistent in the simple entailment regime.

**Scheme Procedure**: `entails? G E`

Returns whether a graph G entails another graph E.

#### The D Entailement Regime

The second entailment regime is the *D entailment regime*, defined in

`(rdf entailment d)`.  This regime is parameterized by a vocabulary D (defined

datatypes).  A graph is valid if and only if all its recognized literals

(whose type is in D) have their lexical value in their lexical space.

For instance the following is not a valid graph:

```

_:a1 <http://example.org/prop> "ten"^^xsd:integer .

```

because the lexical space of `xsd:integer` does not include `"ten"`.

Entailments work in a similar fasion to the simple entailment regime, but,

for literals of a recognized datatype, it is sufficient to have the same value

(the simple entailment regime restricts literals to having the same lexical

form).  For instance, the two triples are equivalent in the D entailment regime:

```

_:a1 <http://example.org/prop> "010"^^xsd:integer .

_:a1 <http://example.org/prop> "10"^^xsd:integer .

```

because their objects both have the same value `10` (but a different lexical

form).

The following procedures are available:

**Scheme Procedure**: `consistent-graph? graph vocabulary`

Returns whether a graph is D-consistent, with regards to the vocabulary, an

`rdf-vocabulary` object.

**Scheme Procedure**: `entails? G E vocabulary`

Returns whether a graph G D-entails another graph E, with regards to the

vocabulary, an `rdf-vocabulary` object.

#### The RDF Entailment Regime

The third entailment regime is the *RDF entailment regime*, defined in

`(rdf entailment rdf)`.  This regime is parameterized by a vocabulary.  A graph

is valid if it is D-valid and if the types of every nodes are compatible.

In RDF, a node can have zero, one or more types.  When it has more than one type,

it is only valid if its types are compatible, meaning that there is at least

one value (in the value space, not the lexical space) that is in the value

space of all its types.  For instance, a node can be both an integer and a

decimal because `10` is in the value space of both types.  A node cannot be

a decimal and a boolean because no value is in both spaces at the same time.

Entailment in this regime is more complex and we will not describe it here.

Suffices to say that some derivation rules are added, and we can implement them

by first extending the graph G with new facts about the world that can

be derived from it.  Once we have exhausted all possible extension of G, we can

apply the D entailment regime.

The following procedures are available:

**Scheme Procedure**: `consistent-graph? graph vocabulary`

Returns whether a graph is RDF-consistent, with regards to the vocabulary, an

`rdf-vocabulary` object.

**Scheme Procedure**: `entails? G E vocabulary`

Returns whether a graph G RDF-entails another graph E, with regards to the

vocabulary, an `rdf-vocabulary` object.

#### The RDFS Entailment Regime

The last entailment regime is the *RDFS entailment regime*, defined in

`(rdf entailment rdfs)`.  this regime is parameterized by a vocabulary.  A graph

is valid if it is RDF-valid and if the subclasses are compatible.

In RDFS, nodes can have a class, and a class system exists that orders classes

in terms of subclasses.  The class system is valid if and only if, for any type

B which is a subclass of A, its value space is included in that of B.  For instance,

xsd:int is a subclass of xsd:integer (because its value space, a finite interval,

is a subset of the value space of xsd:integer, which is infinite), but

xsd:int is not a subclass of xsd:string.

As with RDF, the RDFS entailment regime adds more deduction rules and we use them

to exted the graph G.  When the graph is fully extended, we use the D-entailment

regime to check whether the extended G entails E.

The following procedures are available:

**Scheme Procedure**: `consistent-graph? graph vocabulary`

Returns whether a graph is RDFS-consistent, with regards to the vocabulary, an

`rdf-vocabulary` object.

**Scheme Procedure**: `entails? G E vocabulary`

Returns whethe a graph G RDFS-entails another graph E, with regards to the

vocabulary, an `rdf-vocabulary` object.

### Turtle Format

Turtle is a textual format to represent RDF graphs.  We include a parser and

a generator in guile-rdf.  The `(turtle tordf)` module defines a parser:

#### **Scheme Procedure**: `turtle->rdf str-or-file base`

Generates an RDF graph from the file or string passed as first argument

(we first check whether the string is a file on the filesystem, then we

parse it as a string).  The `base` is the document base or `#f` if there is

none.  When a document is downloaded from the internet, the base is typically

the URl of that document, or the value of a base header.

#### **Scheme Procedure**: `rdf->turtle graph`

Generates a string representing a turtle document for the `graph`.  This is more

accurately a N-Triples representation of the graph, but that format is a subset

of Turtle.