RacerPro

What is RacerPro? An overview

RACER stands for Renamed ABox and Concept Expression Reasoner.
RacerPro is the commercial name of the software.

The origins of RacerPro are within the area of description logics. Since description logics provide the foundation of international approaches to standardize ontology languages in the context of the so-called semantic web, RacerPro can also be used as a system for managing semantic web ontologies based on OWL (e.g., it can be used as a reasoning engine for ontology editors such as Protégé). However, RacerPro can also be seen as a semantic web information repository with optimized retrieval engine because it can handle large sets of data descriptions (e.g., defined using RDF). Last but not least, the system can also be used for modal logics such as Km.

RacerPro as a Semantic Web Reasoning System and Information Repository

The semantic web is aimed at providing "machine-understandable" web resources or by augmenting existing resources with "machine-understandable" meta data. An important aspect of future systems exploiting these resources is the ability to process OWL (Web Ontology Language) documents (OWL KBs), which is the official semantic web ontology language. Ontologies may be taken off the shelf or may be extended for domain-specific purposes (domain-specific ontologies extend core ontologies). For doing this, a reasoning system is required as part of the ontology editing system. RacerPro can process OWL Lite as well as OWL DL documents (knowledge bases). Some restrictions apply, however. OWL DL documents are processed with approximations for nominals in class expressions and user-defined XML datatypes are not yet supported.

A first implementation of the semantic web rule language (SWRL) is provided with RacerPro1.9 (see below for a description of the semantics of rules in this initial version).

The following services are provided for OWL ontologies and RDF data descriptions:

  • Check the consistency of an OWL ontology and a set of data descriptions.
  • Find implicit subclass relationships induced by the declaration in the ontology.
  • Find synonyms for resources (either classes or instance names).
  • Since extensional information from OWL documents (OWL instances and their interrelationships) needs to be queried for client applications, an OWL-QL query processing system is available as an open-source project for RacerPro.
  • HTTP client for retrieving imported resources from the web. Multiple resources can be imported into one ontology.
  • Incremental query answering for information retrieval tasks (retrieve the next n results of a query). In addition, RacerPro supports the adaptive use of computational resource: Answers which require few computational resources are delivered first, and user applications can decide whether computing all answers is worth the effort.

Future extensions for OWL (e.g., OWL-E) are already supported by RacerPro if the system is seen as a description logic system. RacerPro already supports qualified cardinality restrictions as an extension to OWL DL.

RacerPro as a Description Logic System

RacerPro is a knowledge representation system that implements a highly optimized tableau calculus for a very expressive description logic. It offers reasoning services for multiple T-boxes and for multiple A-boxes as well. The system implements the description logic ALCQHIR+ also known as SHIQ. This is the basic logic ALC augmented with qualifying number restrictions, role hierarchies, inverse roles, and transitive roles.

In addition to these basic features, RacerPro also provides facilities for algebraic reasoning including concrete domains for dealing with:

  • min/max restrictions over the integers,
  • linear polynomial (in-)equations over the reals or cardinals with order relations,
  • equalities and inequalities of strings.

For these domains, no feature chains can be supported due to decidability issues. RacerPro supports the specification of general terminological axioms. A T-box may contain general concept inclusions (GCIs), which state the subsumption relation between two concept terms. Multiple definitions or even cyclic definitions of concepts can be handled by RacerPro.

RacerPro implements the HTTP-based quasi-standard DIG for interconnecting DL systems with interfaces and applications using an XML-based protocol [4]. RacerPro also implements most of the functions specified in the older Knowledge Representation System Specification (KRSS).

Given a T-box, various kinds of queries can be answered. Based on the logical semantics of the representation language, different kinds of queries are defined as inference problems (hence, answering a query is called providing inference service). As a summary, we list only the most important ones here:

  • Concept consistency w.r.t. a T-box: Is the set of objects described by a concept empty?
  • Concept subsumption w.r.t. a T-box: Is there a subset relationship between the set of objects described by two concepts?
  • Find all inconsistent concept names mentioned in a T-box. Inconsistent concept names result from T-box axioms, and it is very likely that they are the result of modeling errors.
  • Determine the parents and children of a concept w.r.t. a T-box: The parents of a concept are the most specific concept names mentioned in a T-box which subsume the concept. The children of a concept are the most general concept names mentioned in a T-box that the concept subsumes. Considering all concept names in a T-box the parent (or children) relation defines a graph structure which is often referred to as taxonomy. Note that some authors use the name taxonomy as a synonym for ontology.

Note that whenever a concept is needed as an argument for a query, not only predefined names are possible, instead concept expressions allow for adaptive formulation of queries that have not been anticipated at system construction time.

If also an A-box is given, among others, the following types of queries are possible:

  • Check the consistency of an A-box w.r.t. a T-box: Are the restrictions given in an A-box w.r.t. a T-box too strong, i.e., do they contradict each other? Other queries are only possible w.r.t. consistent A-boxes.
  • Instance testing w.r.t. an A-box and a T-box: Is the object for which an individual stands a member of the set of objects described by a specified concept? The individual is then called an instance of the concept.
  • Instance retrieval w.r.t. an A-box and a T-box: Find all individuals from an A-box such that the objects they stand for can be proven to be a member of a set of objects described by a certain query concept.
  • Retrieval of tuples of individuals (instances) that satisfy certain conditions w.r.t. an A-box and a T-box.
  • Computation of the direct types of an individual w.r.t. an A-box and a T-box: Find the most specific concept names from a T-box of which a given individual is an instance.
  • Computation of the fillers of a role with reference to an individual w.r.t. an A-box and a T-box.
  • Check if certain concrete domain constraints are entailed by an A-box and a T-box.

RacerPro provides another semantically well-defined query language (nRQL, new Racer Query Language), which also supports negation as failure, numeric constraints w.r.t. attribute values of different individuals, substring properties between string attributes, etc. In order to support special OWL features such as annotation and datatype properties, special OWL querying facilities have been incorporated into nRQL. The query language OWL-QL [4] is the W3C recommendation for querying OWL documents. nRQL has been used as a basic engine for implementing a very large subset of the OWL-QL query language (see above).

RacerPro as a Combination of Description Logic and Specific Relational Algebras

For some representation purposes, e.g., reasoning about spatial relations such as contains, touching, etc., relational algebras and constraint propagation have proven to be useful in practice. RacerPro combines description logics reasoning with, for instance, reasoning about spatial (or temporal) relations within the A-box query language nRQL. Bindings for query variables that are determined by A-box reasoning can be further tested with respect to an associated constraint network of spatial (or temporal) relationships.

Although RacerPro is one of the first systems supporting this kind of reasoning in combination with description logics (or OWL), we expect that international standardization efforts will also cover these important representation constructs in the near future. Note also that the semantically well-founded treatment can hardly be efficiently achieved using rule systems.

Application Areas and Usage Scenarios

Description logic systems are no databases. Although one can use RacerPro for storing data using A-boxes, probably, databases provide better support with respect to persistency and transactions. However, databases can hardly be used if indefinite information is to be handled in an application (e.g., ӊohn was seen playing with a ball, but I cannot remember, it was soccer or basket ball, so he must be a soccer player or a basket-ball playerԩ. Being able to deal with indefinite information of this kind is important when information about data comes in from various sources, and in situations where sources are, for instance, used to exclude certain cases that are possible given the information at hand. Description logics are also important if data descriptions are to be queries with respect to varying T-boxes (or ontologies). Note that this is a common scenario in modern information technology infrastructure. Due to the rapid pace in technology evolution, also the vocabulary used to access data descriptions changes quite frequently. New concepts are introduced, and can be set into relation to older terminology using description logics (or semantic web ontologies).

There are numerous papers describing how description logic in general (and RacerPro in particular) can be used to solve application problems (see the International Workshops on Description Logics and the workshops on Applications of Description Logics ADL-01, ADL- 02, or ADL-03). Without completeness one can summarize that applications come from the following areas:

  • Semantic Web, Semantic Grid (ontology representation and logic-based information retrieval)
  • Electronic Business (e.g, reason about services descriptions)
  • Medicine/Bioinformatics (e.g., represent and manage biomedical ontologies)
  • Natural Language Processing and Knowledge-Based Vision (e.g., exploit and combine
  • multiple clues coming from low-level vision processes in a semantically meaningful way).
  • Process Engineering (e.g., represent service descriptions)
  • Knowledge Engineering (e.g., represent ontologies)
  • Software Engineering (e.g., represent the semantics of UML class diagrams)

The features of RacerPro Version 1.9

Among others the RacerPro system offers the following new features:

    • Expressive query language nRQL allows for powerful queries that are efficiently processed (many users of older description logic systems have missed server-based conjunctive queries in previous versions of Racer).
    • RacerPro 1.9 provides for means of resource bounded computation, i.e., maximum query answering times can be specified.
    • RacerPro 1.9 allows for resource-aware computation, i.e., query answering can be done in such a way that applications are instructed that retrieving additional tuples results in much more resources to be allocated. In other words: RacerPro takes care that "easy" answers are computed first and with minimum resources, however, RacerPro is a complete reasoner that informs the user application about a possible increase in computational resources (time and space).
    • Extended support for OWL DL: RacerPro 1.9 supports OWL DL almost completely. In particular, compared to the previous version of Racer, datatype properties and annotation properties are now handled appropriately, and RacerPro's expressive query language nRQL handle both types of roles efficiently. There are still two limitations, however. First, individuals in class expressions (so-called nominals) are only approximated (for details and consequences see Chapter 5.1 of the User Guide). Note that individuals may adequately be processed in RacerPro using so-called ABoxes. Currently, RacerPro cannot process user-defined datatype types given as external XML Schema specifications (although all required datatypes of OWL DL are properly supported).
    • RacerPro 1.9 does not employ the unique name assumption (see below) as required by OWL DL. UNA can be enabled globally, however, if efficiency is of utmost importance. The nRQL system also support a rule engine which provides for efficient and application-controlled ABox augmentation based on rules.
    • A model-checking facility is integrated with nRQL as well. In this context, for instance, reasoning with qualitative spatial relations (e.g., RCC8) can be exploited as part of the query language. New graphical interface are available for RacerPro 1.9.
    • Last but not least: RacerPro 1.9 provides many performance improvements and now offer support for some features not available in 1.7 (e.g., equivalence of roles, synonyms for individuals, datatype property roles, annotation property roles, etc.).

    Structure of available Services

    • Supported description logic: ALCQHIR+ also known as SHIQ
    • OWL-DL without so called “nominals”
    • upcoming feature: complete OWL-DL implementation
    • access to OWL ressources via integrated http client functionality
    • queries in OWL-QL are translated to nRQL
    • Semantic Web Rule Language is supported
    • DIG protocol via http/XML
    • native access from Java and Lisp (via IP sockets)
    • file I/O
    • Direct processing of Semantic Web Rule Language (SWRL) queries will be supported in a future release (2006). Today SWRL is indirecly supported with the help of third party tools.

    Deployment options

    • Back-end network server application
    • File processor launched from command line interface
    • User interaction via certain tools
    • Part of user application when loaded as object code
Copyright © 2014 Franz Inc., All Rights Reserved | Privacy Statement
Delicious Google Buzz Twitter Google+