Project site

Boundz - a vocabulary for expressing reservations about incoming data

Abstract

Boundz is a vocabulary which defines generic constraints useful for expressing dependencies between source and target datasets in situations where a source dataset is to be merged with a target dataset and the target is particular with what data it is willing to accept. These constraints, are called bounds and are based on the graph-like triple structure of RDF graphs and draws ideas from of bisimulation from modal logic, conservative extensions of ontologies, and relational peer database exchange. Although simple and generic, bounds still have powerful and practical natural interpretations, and favorable computational properties. This vocabulary is designed to allow bounds to be specified, published, composed and re-used.

Contents

• Vocabulary
• Prototype implementation
  • Evaluation
• References

Vocabulary

Vocabulary URI

http://sws.ifi.uio.no/vocab/boundz

Vocabulary definition

http://sws.ifi.uio.no/vocab/boundz.owl

Vocabulary documentation

http://sws.ifi.uio.no/vocab/boundz.html

Boundz Library

http://sws.ifi.uio.no/vocab/boundzLibrary

Prototype implementation

A test prototype for checking bound is available: boundzer.jar.

Quick start

Run the program with the command

java -jar boundzer.jar myExchangeSchemas.rdf outputExchanges.rdf outputTime.txt

where

• myExchangeSchemas.rdf is your RDF file containing one or more ExchangeSchema specifications.
• outputExchanges.rdf is where you want the computed Exchange to be written.
• outputTime.txt is where you want evaluation output to be written.

More details

The prototype is written in Java and uses the Jena framework and Pellet reasoner.

It takes as input an RDF file containing one or more ExchangeSchema, and computes and outputs an Exchange instance for every schema.

After the input file is read into memory, reasoning is applied to the exchange schemas to reveal possible inconsistencies and allow for a simpler parsing of the vocabulary model using, e.g., superproperties to discover the different schemas settings. For each exchange schema, the specified source and target graphs are read into memory, and saturated if this is specified. Exchanges are then computed and written to output according to settings in the schema. Bounds are checked by a simple algorithm which straight-forwardly loops through all possible triples matches to the bounds and reports if a violation is found.

Evaluation

We have done a simple evaluation of the prototype giving promising results. As test data we used the Lehigh University Benchmark data generator producting source graphs of various sizes. Different combinations of graphs where used as source graphs in a exchange setting, all using the same bounds and against the same target.

The running times of the experiment are presented in the graph on the right and table below. The graph plots the size of the sources and the times of all the individual runs. The time clocked is the time to parse the exchange schema specification, compute bounds and payload and violations, not to load the sources and target into memory.

The complete evaluation script, input data and bound specification, and test exchange specimen is available for download: evaluation.tgz (70MB).

References

1. M. G. Skjæveland and A. Stolpe. Bounds: Expressing Reservations about Incoming Data. Accepted for the Fourth International Workshop on Consuming Linked Data (COLD2013) at the International Semantic Web Conference (ISWC). 2013.
2. M. G. Skjæveland and A. Stolpe. Bounds: Expressing Reservations about Incoming Data. Position paper for W3C's RDF Validation Workshop—Practical Assurances for Quality RDF Data. 10-11 September 2013, Cambridge, MA, USA. 2013.