Semantic Web Reasoning by Swarm Intelligence
Kathrin Dentler
Dept. of Computer Science
Stefan Schlobach
Vrije Universiteit Amsterdam
Christophe Guéret
{kdr250,schlobac,cgueret}@few.vu.nl
ABSTRACT
Semantic Web reasoning systems are confronted with the
task to process growing amounts of distributed, dynamic
resources. We propose a novel way of approaching the chal-
lenge by RDF graph traversal, exploiting the advantages of
Swarm Intelligence. Our nature-inspired methodology is re-
alised by self-organising swarms of autonomous, light-weight
entities that traverse RDF graphs by following paths, aiming
to instantiate pattern-based inference rules.
Reasoning and Swarm Intelligence. It is widely recog-
nised that new adaptive approaches towards robust, scaleable
and distributed reasoning are required to exploit the full
value of ever growing amounts of dynamic Semantic Web
data. Local reasoning is an interesting option that supports
decentralised publishing and has the potential to respect
the provenance of the data and to allow users to keep con-
trol over their privacy and the ownership and dissemination
of their information. Another advantage of decentralised
reasoning is its capability to naturally integrate constantly
changing data.
Adaptiveness, robustness and scaleability are among the
main properties of swarms and can be attributed to the ba-
sic principles lack of central control, locality and simplicity.
That is why the combination of reasoning and Swarm Intelli-
gence can be a promising approach to obtain optimised rea-
soning performance by basic means. We introduce a swarm-
based reasoning methodology and provide an initial evalua-
tion of its feasibility and major characteristics. A model of a
decentralised system is presented, which allows light-weight
entities, that according to the employed swarm metaphor
are referred to as beasts in the remainder, to traverse RDF
graphs in order to calculate the deductive closure of these
graphs w.r.t. the RDFS semantics. We investigate whether
Swarm Intelligence can contribute to reduce the computa-
tional costs that the model implies, and make this new rea-
soning paradigm a real alternative to current approaches.
Methodology. In order to calculate the RDFS closure over
an RDF graph G, a set of entailment rules has to be applied
repeatedly to the triples in the graph. These rules consist
of a precondition, usually containing one or two triples as
arguments, and an action, typically to add a triple to the
graph. The following is an exemplary rule:
rdfs3: If p rdfs:range x . and s p o . 2 G add o rdf:type x .
This process is usually done by indexing all triples and join-
ing the results of two queries. With swarm-based reasoning
we provide an index-free alternative for reasoning over large
distributed dynamic networks of RDF(S) graphs. The idea
is that swarms of light-weight beasts autonomously traverse
the graph, each representing a reasoning rule, which might
be (partially) instantiated. Beasts communicate only locally
and indirectly. Whenever the conditions of a rule match the
node a beast is on, it locally adds the newly derived triple.
Our proposed paradigm envisages the Semantic Web as a
connected collection of networks of data, which is constantly
updated by beasts. In this set-up, only the active reason-
ing rules are moving in the network and not the data, min-
imising network trac, as schema-data is typically far less
numerous than instance-data. Given some added transition
capability between graph-boundaries, our method converges
towards closure. We claim that swarm-based reasoning is
more adaptive and robust than other Semantic Web rea-
soning approaches, as recurrently revisiting beasts can more
easily deal with added (and even deleted) information than
index-based approaches.
Reasoning Model. Our beasts move through the graph by
following its edges.1 RDFS reasoning can naturally be de-
composed by distributing complementary entailment rules
on the members of the swarm, so that each individual is
only responsible for the application of one rule. Therefore,
we introduce dierent types of beasts, one type per RDF(S)
entailment rule containing schema information.
Beasts are automatically instantiated by considering the sche-
ma information in the graph. If a concrete schema triple of
a certain pattern is found, a reasoning beast is generated.
Take for example the rule rdfs3 for range restrictions: when-
ever in the schema an axiom p rdfs:range x is encountered,
a beast of type rb3 is created with memory fp; xg. Table 1
lists some RDFS entailment rules, with the patterns that
are to be recognised in column 2, and the generated beasts
with their memory in column 3.
A beast rb3 is dened as a function rb3 (rb stands for rea-
soning beast) with memory fp; xg. Let us assume that while
traversing a graph G, the instantiated range-beast arrives at
node o from a node s via an edge (s; e; o). If e = p, it adds
the triple (o, rdf:type, x) to G.2 It moves on to a node
n, where (o; ei; n) 2 G.
1There are alternatives such as random jumps to avoid local
maxima, or guided jumps to locations where other beasts
have been successful.
2Our beasts can walk both directions of the directed graph.

Rule Pattern of schema
triple
Beast:
memory
rdfs2 p rdfs:domain x . rb2: p x
rdfs3 p rdfs:range x . rb3: p x
rdfs5 p1 rdfs:subPropertyOf p .
p rdfs:subPropertyOf p2 .
rb7: p1 p2
rdfs7 p1 rdfs:subPropertyOf p2 rb7: p1 p2
rdfs9 c1 rdfs:subClassOf c2 . rb9: c1 c2
rdfs11 c1 rdfs:subClassOf c .
c rdfs:subClassOf c2 .
rb9: c1 c2
Table 1: Instantiation of reasoning beasts
Table 2 shows some beasts needed for RDFS reasoning with
their pattern-based inference rules. Underlined elements
correspond to the memory. Reasoning beasts rb2 and rb3
apply the semantics of rdfs:domain and rdfs:range, while
rb7 and rb9 generate the inferences of rdfs:subPropertyOf
and rdfs:subClassOf. We will refer to them as domain-
beast, range-beast, subproperty-beast and subclass-beast.
Memory If matches Then add
rb2 : fp,xg s p o . s rdf:type x .
rb3 : fp,xg s p o . o rdf:type x .
rb7 : fp1,p2 g s p1 o . s p2 o .
rb9 : fc1,c2 g s rdf:type c1 . s rdf:type c2 .
Table 2: Inference patterns of reasoning beasts
The deductive closure C contains all triples that can be de-
rived from the input data. Our method is sound, with the
degree of completeness monotonically increasing over time.
Example. To illustrate the idea, let us consider two simple
RDF graphs in Turtle about publications cg:ISWC08 and
fvh:SWP of members of our Department, maintained sepa-
rately by respective authors and linked to public ontologies
pub and people about publications and people.
cg:ISWC08
pub:title \Anytime Query Answering" ;
pub:publishedAs pub:InProceedings ;
pub:author people:Gueret ;
pub:author people:Oren ;
pub:cites fvh:SWP .
fvh:SWP
pub:title \Semantic Web Primer" ;
pub:author people:Antoniou ;
pub:author people:vanHarmelen ;
pub:publishedAs pub:Book .
These two graphs denote two publications cg:ISWC08 and
fvh:SWP by dierent sets of authors. The graphs are physi-
cally distributed over the network and can be reasoned and
queried over directly. Their information is extended with
schema information:
pub:InProceedings rdfs:subClassOf pub:Publication
people:Person rdfs:subClassOf people:Agent
pub:author rdfs:range people:Person
Given the standard RDF(S) semantics one can derive that
cg:ISWC08 is a publication, and that the authors are also in-
stances of class people:Person and thus people:agent. The
formal semantics of RDFS and OWL enable the automation
of such reasoning. Fig. 1 shows the RDF graph for the
rst publication. Red lines denote implicit links derived by
reasoning.
people:Person people:Agentrdfs:subClassOf
pub:Publicationpub:InProceedings rdfs:subClassOf
Gueret rdf:type rdf:type
Oren rdf:type rdf:typeISWC08
pub:publishedAs
pub:author
pub:author
SWP
pub:cites
Anytime Query...
pub:title
SW Primerpub:title
Figure 1: An RDF graph for our previous example
For the three schema axioms of our previous example, beasts
are created. For the triple people:Person rdfs:subClassOf
people:Agent a beast rb91 is created, which is instanti-
ated with memory people:Person and people:Agent. (The
other subclass-beast is generated accordingly.) For the range-
triple pub:author rdfs:range people:Person, a beast rb3
is created with memory pub:author and people:Person. In
our example, only one beast per instantiated type is created,
in practise there will be more. The beasts are randomly dis-
tributed over the graph, say rb3 to node fvh:SWP, and sim-
ilarly the other two beasts. Beast rb3 has now two options
to walk. Moving to \SW Primer" will get it to a cul-de-
sac, which means it needs to walk back via cg:ISWC08 to-
wards, eg. person:Oren. At node person:Oren, the walked
path is cg:ISWC08 pub:author person:Oren which means
rb3's condition matches with its pattern, and it will add a
triple person:Oren rdf:type people:Person to the graph.
When, after walking other parts of the graph, the subclass-
beast rb91 chooses to follow the rdf:type link from per-
son:Oren to people:Person, it nds its memory condition
matched, and adds person:Oren rdf:type people:Agent
to the graph, and so forth.
Research questions. The price for our adaptive, index-free
approach is redundancy: beasts have to traverse parts of the
graph which would otherwise never be searched. The trade-
o that needs to be investigated is thus whether the compu-
tational overhead of repeated exhaustive graph-traversal can
be reduced by Swarm Intelligence so that the method oers
both adaptive and
exible, as well as ecient reasoning.
Implementation and Experiments. We implemented our
method based on the AgentScape platform, where each beast
is implemented as an agent, and each distributed graph as an
AgentScape dataprovider, linked with other dataproviders.
Findings. Our experiments had two goals: proof of con-
cept, and to obtain a better understanding of the intrinsic
potential and challenges of our new method. For the former,
we run an RDF(S) reasoning system based on fully decen-
tralised agents to calculate the semantic closure of a number
of distributed RDF(S) datasets. From the latter perspec-
tive, the lessons learned were less clear-cut, as the results
basically conrmed that tuning a system based on compu-
tational intelligence is a highly complex problem. However,
the experiments gave us crucial insights in how to proceed
in future work: most importantly on how to improve our
attract/repulse methods for guiding swarms to interesting
locations within the graph.