OWL 2

RacerPro now supports the latest developments of the Web Ontology Language OWL. The future OWL 2 standard introduces additional class constructors such as qualified number restrictions on properties (the Q constructor) whose optimized treatment are a traditional strength of RacerPro. Moreover, OWL2 introduces new axiom types which are supported by RacerPro. However, for the time being, certain new OWL2 axiom types are ignored or only approximated for reasoning. A future version will bring a more complete semantic coverage of these new axiom types.

New Syntaxes

RacerPro now supports OWL2 RDF/XML, OWL2 XML, as well as the older OWL 1.1 functional syntax (to be upgraded to OWL2 functional syntax soon). Traditionally, RacerPro supports its own native syntax (which is an extended KRSS syntax).

OWLAPI support

The OWLAPI is the de-facto Java framework for Java programmers that want to work programmatically with OWL knowledge bases, e.g. create OWL ontologies programmatically as Java objects, populate them programmatically with axioms represented as Java objects, parse or render various OWL syntaxes, transmit and perform reasoning with the help of a reasoner, etc.

Together with DOCOMO Euro Labs and Olaf Noppens from the University of Ulm Racer Systems GmbH & Co. KG has developed the so-called "NOSA" API, the "new OWLAPI support API" in order to support the OWLAPI framework. On the Java side, a reasoner adapter is required in order to attach the OWLAPI to the services of a reasoner. For RacerPro, Olaf Noppens from Ulm university has developed such an adapter. It can be downloaded from here. Installation instructions are available from that web site.

Protégé 4 Support

The favourite ontology editor Protégé 4 also relies on the OWLAPI in order to access the inference facilities of a reasoner for OWL reasoning. Olaf Noppens from Ulm University has developed a RacerPro adapter for Protégé 4 which exploits the new NOSA-API. The adapter can be downloaded from his website. Installation instructions are available from that web site. Please note that adapter requires this new RacerPro 2.0 preview version.

In order to use the ontology editor Protégé 4, simply download Protégé 4 and the RacerPro adapter. Put the adapter (a jar file) into the plugins directory of the Protégé 4 directory. Download your copy of RacerPro 2.0 preview and put it (or an approriate shortcut/alias) into the directory "racer" in the Protégé 4 adapter. When you (re-)start Protégé 4 the RacerPro adapter will automatically launch the RacerPro server as soon as you select "RacerPro 2.0" from the "Reasoners" menu of Protégé 4.

OWLlink

Members of Racer Systems GmbH & Co. KG were actively involved in the development of OWLlink, the successor of the new standard protocol for accessing OWL reasoner. OWLlink is the successor of the DIG 1.1 interface, which is still supported by RacerPro. Simply start RacerPro with the -protocol OWLlink command line option to enjoy the new de-facto protocol for OWL communication. OWLlink is HTTP based, and features a OWL2 XML-based message syntax, making it easy to write reasoner clients in all conceivable programming languages (not only Java as OWLAPI) which offer HTTP / XML processing frameworks.

Persistency built in - with AllegroGraph!

RacerPro now integrates the high-performance Web 3.0 RDFS++ database of Franz Inc: the AllegroGraph triple store. The utilization of a triple store as additional and persistent memory brings a number of synergetic effects:

RacerPro can load OWL ontologies from AllegroGraph triple store databases. These databases can also accessed from other tools of Franz Inc., e.g. the RDF graph visualizer "Gruff". Thus, AllegroGraph serves as a ontology repository for OWL ontologies and RDF data sets.

RacerPro can load such ontologies or RDF data sets and perform reasoning on them. The inference results achieved by RacerPro can be written back into the AllegroGraph repository, thus enhancing the inference-awareness of RDF query answering as performed with Franz Inc tools, e.g. SPARQL queries posed from Gruff to AllegroGraph.

Please note that that this kind of query answering works on secondary memory, i.e. the database. Query answering is thus not limited to main memory size. However, in order to perform reasoning on an AllegroGraph database, at least parts of it must fit in main memory at one time in order to enable RacerPro to perform OWL reasoning on it.

Server extensibility

MiniLisp

RacerPro's flexibility has been increased. Using the MiniLisp functional expression-language for server-sided scripting, it is now possible to do all kinds of flexible things ad hoc — be it generation of HTML pages from query results or programmatic creation of knowledge bases (similar to the OWLAPI, but directly on the server-side, incrementally, and with much less verbosity).

Through the RacerPorter IDE, it is very easy and convenient to incrementally and rapidly add new functionality to RacerPro by adding new server functions. These extensions are efficiently executed on the server. Moreover, termination and safeness of these MiniLisp expressions is guaranteed, since MiniLisp does not allow the creation of unbounded (infinite) loops. Simply send some MiniLisp expressions to a RacerPro server, which will execute your code!

Plugins

Whereas MiniLisp permits the user of RacerPro to incrementally and rapidly extend the server API ad hoc, or to work programmatically and incrementally with the server, there is also a new plugin mechanism. Thus, if you want a custom server function which computes with utmost performance, you can contract Racer Systems GmbH & Co. KG to implement a so-called Racer plugin for you. We will design and implement a plugin and deploy it as a plugin file for you which then smoothly loads into your RacerPro server, extending its API (or altering it, if necessary). In a similar way, Racer Systems GmbH & Co. KG will also supply patches that fix minor glitches (e.g., to correct broken functions in the server API).

New innovative inference services

RacerPro offers some new and innovate non-standard inference services not found in other reasoners, e.g. abductive query answering (w.r.t. a set of non-recursive Horn rules), an experimental ABox difference operator, etc. Support for reasoning and querying with special-purpose representations (e.g., reasoning with qualitative spatial representations, such as RCC) is supplied. A new event recognition facility has been added (the so-called timenet). Please refer to the release notes in PDF format for more details.

Query & rule language extensions

RacerPro's native and powerful nRQL query and rule language has been extended: nRQL now offers simple standard aggregation operators in nRQL query heads, such as count and sum. Moreover, nRQL is the only implemented semantic web and ABox query language which is able to express a kind of epistemic ("closed domain") universal quantification, due to its unique availability of negation and projection (the (neg (project-to ...)) construction).

This expressivity is very handy, e.g. for temporal event recognition in order to verify that certain state properties of events hold (e.g., to make sure that between start and end state / time of an event, all states witness a certain state property, or that the event is maximal or minimal). These epistemic first-order features can also be used in nRQL rules.

Moreover, it is now possible to use user-defined atoms in queries and rules. These atoms are defined as MiniLisp lambda expressions, which are efficiently executed on the server. Similar to advanced expert system rules, nRQL rules can now, by using MiniLisp expressions in rule conclusions, add computed items to a knowledge base / ontology. The concise syntax of MiniLisp makes this very easy and flexible, and results in a good performance. For example, the famous qualitative temporal relationships between time intervals, the Allen relations, can easily and efficiently be computed with such a rule containing a programmatic MiniLisp lambda expression in its conclusion, relating two events with the corresponding Allen relationship computed on the basis of the start and end points of these intervals.

Due to the integrated AllegroGraph RDFS++ query answering engine, a complete SPARQL interface is available which covers the full W3C standard and works on the secondary memory. Furthermore, nRQL ABox queries can be posed in SPARQL syntax; however, query answering is limited to main memory then.

The SWRL interface has be extended to some extent in order to also support some standard SWRL built-ins better. SWRL is mapped to nRQL rules and thus only provides a different syntax here.

Performance improvements

The scalability and performance of RacerPro's reasoning has been enhanced drastically. For example, dedicated optimizations for the OWL fragment ELH (a description logic) have been added, enabling practical reasoning with the very large medical ontology SNOMED which only dedicated special-purpose reasoners could handle only two years ago.

Support for external formats and locales

The RacerPro server now supports the so-called external formats, e.g., asian character sets. UTF8 is now supported as well. Simply start the server with the -ef @UTF8 command line option. RacerPorter, however, currently only supports the standard latin-1 character set. A future version of RacerPorter will support the full UTF8 character set.

RacerPorter

A lot of efforts have been put into the further development of RacerPorter. This version offers a much more user friendly shell for interactive and rapid knowledge base inspection, modification authoring, e.g., the completion facility now also works for file names and optional arguments of RacerPro functions (so-called keyword arguments).
Moreover, a function documentation facility is available from the Shell.

The ABox visualization facilities have been optimized for large ABoxes, by optimizing the interactive incremental "drill-down" browsing facilities, resulting in a much larger speed regarding graph navigation.

Also, RacerPorter now offers a new tab, the axioms tab, which is used to visualize, manage, and edit the OWL2 axioms created via the NOSA-OWLAPI within RacerPro. It also possible to author knowledge bases in terms of OWL2 axioms with that tab, since new axioms can be created and edited with axiom-specific editors, similar to Protégé 4. However, RacerPorter supplies a much more technical perspective on the axioms of an OWL ontology than Protégé 4 does. Thus, RacerPorter is kind of the "Emacs" of the ontology editors: Very flexible, interactive and powerful, but sometimes a little bit harder to learn. However, we think that the effort will soon pay back.