This poster paper presents the design and implementation of an RDFS reasoner based on a backward chaining approach and implemented on a clustered RDF triplestore. The system presented, called 4sr, uses 4store as base infrastructure. In order to achieve a highly scalable system we implemented the reasoning at the lowest level of the quad store, the bind operation. The bind operation in 4sr traverses the quad store indexes matching or expanding the query variables with awareness of the RDFS semantics.
http://4sreasoner.ecs.soton.ac.uk/demo.html
The Semantic Web community is promoting RDF stores (or triple stores) as the data storage technology for the Web of Data. RDF stores implement some extra features that make them very attractive for certain type of applications. For instance, data is not bound to a schema and it can be asserted directly from RDF sources (e.g. RDF/XML or Turtle les) due to their native support of Semantic Web data standards. But the most attractive characteristic is the possibility of implementing an entailment regime. Having entailment regimes in a triple store allows us to infer new facts, exploiting the semantics of properties and the information asserted in the knowledge base.
Today, it is still a challenge to query datasets with a few hundred of millions of triples following the RDFS regime for datasets subject to frequent changes. If we want semantic databases to handle big volumes of data transactions then we need to nd backward chained approaches that do not add excessive overhead to the query phase.
4sr 1 has been implemented on the 4store [
To summarize, the main characteristics of 4sr are: 1 4sr is available from http://4sreasoner.ecs.soton.ac.uk/ under GNU GPL license { Low level RDFS Backward Chained reasoning implementation. { Duplicate entailment detection and elimination. { Named graph management. { Client applications can disable/enable the RDFS entailment regime via parameters in the HTTP SPARQL endpoint. { 4sr doesn't add overhead at the import phase keeping intact 4store's import throughput (100kT/s). 2
In the context of distributed techniques, [
[
Obviously, in the last 2-3 years there has been a signi cant advance on materialization of closure for both RDFS and OWL languages. However very little work has been presented on how to actually query vast amounts of data and how to connect those solutions with SPARQL engines. 3
The RDFS inferencing in 4sr is based on two new components that have been incorporated into 4store's architecture: { RDFS Sync: A new processing node to replicate RDFS statements called RDFS sync. This node gathers all RDFS statements from all the storage nodes and keeps a synchronized copy of such information accessible to the bind operation in all the segments. After every import, update, or delete, this process extracts the new set of RDFS statements in the KB and sends it to the Storage Nodes. Even for large KBs this synchronization is fast because RDFS statements tend to be a very small proportion of the dataset. This node is also responsible for ltering out entailed duplicates. { bind': The new bind function matches the quads not just taking into account the explicit knowledge but also the extensions from the RDFS semantics.
AAppplpicliactaiotinosns ApApplpicliactaiotinosns
SPARQL Processing Node
QE bind'(M,S,P,O)
bind'(M,S,P,O) Storage Node 0
Storage Node 1 RDFS statements
RDFS statements
RDFS sync
The current version of 4sr implements the RDFS rule entailments related to
rdfs:subClassOf, rdfs:subPropertyOf, rdfs:domain and rdfs:range. These
semantics include the rules rdfs2, rdfs3, rdfs5, rdfs7, rdfs9, rdfs11, ext1, ext2, ext3 and
ext4 of the RDFS Rule Entailment Regime (see section 7.3 in [
The bind' takes a super set of 4 elements < M; S; P; O > to match the
segment quads. The rst goal in bind' is to expand P and O sets so as to broaden
the index coverage. After this, the algorithm iterates over the M; S; P; O patterns
applying not just an explicit match but a match where the members of the quads
are compared taking into account RDFS semantics. Every matched solution with
p or/and o unbound will be expanded according to the RDFS entailment regime.
As a nal step, duplicates are detected and eliminated. This approach has been
presented in [
This architecture has been implemented in ANSI C 99 using a custom TCP/IP protocol to communicate Storage Nodes and the RDFS Sync Node. Figure 2 gives an overview of how the previous phases are implemented.
seg M S P O
P & O loop modification
P & O closured match
P & O solution expansion duplicate detection segment result M,S,P,O loops domain & range when 'p' is rdf:type
RDFS_2&3
Fig. 2. Bind' processing
Due to the lack of space, we refer the committee to [
In this poster paper we present a backward chained decentralized implementation of the RDFS entailment. The novelty of our work is to implement such reasoning in the bind operation of an RDF decentralized database. 4sr o ers a good balance between import throughput and query performance over the RDFS entailment regime. In that sense, 4sr will support the development of Semantic Web applications where data can change frequently and RDFS inference is required. This poster paper will be accompanied with a demo on site similar to the one available online at:
http://4sreasoner.ecs.soton.ac.uk/demo.html 6
This work was supported by the EnAKTing project funded by the Engineering and Physical Sciences Research Council under contract EP/G008493/1.