Linked data can be used to connect information stemming from usually disparate sources. The Semantic Web combines various kinds of logical reasoning for the inference of additional knowledge from existing data and for consistency checking of data sets. Although mathematics is crucial for most areas where Semantic Web technologies can be applied, support for them is lacking from related standards and tools. This paper presents an approach for integrating OpenMath with RDF data for the representation of mathematical relationships and the integration of mathematical computations into reasoning systems.
A comparable solution could also be realized with SPIN (SPARQL Inferencing Notation)2 that allows to use SPARQL3 queries for reasoning and constraint checking over RDF data. The upcoming SPARQL 1.14 also supports aggregates, which can be used for, e.g. computing the sum or average of a set of elements. However, SPARQL only support simple mathematical operations and therefore an extension with custom functions would be necessary. Furthermore, expressing rules using SPIN may get complicated for domain experts since mathematical terms have to be nested into SPARQL queries.
Another approach is followed by OntoCAPE [
A general review on representation of mathematical knowledge on the web, which covers a
wide range of possible representation formats and systems, is given by Lange [
Our approach realizes a tight integration between OpenMath and RDF5 for consuming linked data from computer algebra systems. Complemented by an RDF representation for mathematical expressions it not only allows to publish formulas as linked data but also to extend reasoning systems with inferencing capabilities based on mathematical computations.
In Section 2 an OpenMath content dictionary for retrieval and representation of RDF data and corresponding human-friendly notation are introduced. Section 3 describes an OWL ontology for OpenMath objects that enables serialization as RDF. Based on the presented formalisms a method and architecture for math-enhanced inference is introduced in Section 4.
If not stated otherwise then all examples concerning OpenMath objects are given in the
Popcorn6 [
Existing methods for representing and solving equation systems with RDF and OWL [
The following four symbols are provided for retrieving data from an RDF store: resourceset A unary construction function that takes one string argument that is a Manchester Syntax description10. These expressions are a subset of the Manchester Syntax for the definition of OWL classes and restrictions. The result of applying the resourceset function is a set of resource objects.
Example: rdf.resourceset("foaf:Person and foaf:age some xsd:int[>18]") resource An unary construction function with one string argument representing an IRI reference as defined by SPARQL11. Possible values are prefixed names in the form "prefix:resourceName" or absolute IRIs in the form "<IRI>".
Example: rdf.resource("<http://example.org/p#Alice>") valueset A function to retrieve a set of property values for a specific RDF resource. It takes two arguments where the first argument denotes an RDF property as IRI reference and the second argument an OM object that corresponds to an RDF resource. The result of this function is a set of RDF resources or literal values.
$alice := rdf.resource("<http://example.org/p#Alice>"); rdf.valueset("foaf:knows", $alice) value Works like the valueset function but expects and returns exactly one value. The application of this function results in an error if none or more than one value exists.
rdf.value("foaf:age", rdf.resource("<http://example.org/p#Alice>")) Although it would be possible to directly embed SPARQL queries into OpenMath objects, we haven chosen Manchester Syntax descriptions for querying RDF resources. The main advantage of this approach is type-safety. While SPARQL SELECT queries may result in tuples of different cardinality and type (either resource or literal), the result of a Manchester Syntax description is always a set of resources.
Since Manchester Syntax is a concise language for OWL ontologies, it essentially is based
on description logic (DL). This is beneficial for fast query evaluation, which can also be directly
executed by a DL reasoner, but does not allow the use of variables and hence has limited
expressiveness in comparison to SPARQL. Please note that Manchester Syntax descriptions
can also be directly translated to SPARQL queries [
We also propose to reuse the vocabulary of the set1 content dictionary to handle instances of rdf.resourceset and rdf.valueset. This allows for applying existing set1 functions like union, intersect, in or size for basic set operations.
10http://www.w3.org/TR/owl2-manchester-syntax/#Descriptions 11http://www.w3.org/TR/sparql11-query/#rIRIref 2.2
The representation of RDF literals in OpenMath is straightforward. Typed RDF literals are mapped according to their datatype to basic OpenMath objects of type integer, IEEE floating point number, character string or byte array. If the literal’s type is not directly convertible or should be preserved in OpenMath then the literal_type attribute can be used to annotate the corresponding OpenMath object. Plain literals are represented as strings and can be annotated with a language tag by using the attribute literal_lang. 2.3
The functions introduced in Section 2.1 allow the specification of IRI references in a shortened form as so-called prefixed names. For example, the expression
rdf.resource("foaf:Person") uses the prefixed name foaf:Person that expands to a full IRI by concatenating the namespace IRI referred to by the prefix "foaf" with the local part "Person" resulting in the full IRI <http://xmlns.com/foaf/0.1/Person>.
Mappings between prefixes and their corresponding namespaces can be specified by using the prefixes attribute in combination with the prefix symbol: rdf.resourceset("foaf:Person and foaf:age some rdfs:Literal"){ rdf.prefixes -> { rdf.prefix("rdfs", "http://www.w3.org/2000/01/rdf-schema#"), rdf.prefix("foaf", "http://xmlns.com/foaf/0.1/") }
} These prefix declarations are scoped to the annotated OpenMath object including its descendants. Please note that annotations in OpenMath do not automatically propagate to children and therefore an implementor has to take care of the correct propagation of prefix declarations. 2.4
We have extended the Popcorn notation with additional symbols for concise integration of RDF into OpenMath. These RDF expressions have the form:
’@’ ’@’? PROPERTY_REF? (’(’ OM_OBJECT ’)’ | ’[’ CLASS_REF ’]’) Basically, the character @ introduces references to RDF data. A single @ as prefix indicates that the result is also only a single value whereas @@ indicates that the result is a set of zero or more values.
The following examples demonstrate the mapping of symbols from the content dictionary for RDF to compact Popcorn expressions: 2.5
As with every new content dictionary for OpenMath, the related phrase-books for computer algebra systems (CAS) need to be extended with additional translation rules. Since, to the authors’ knowledge, no current CAS supports querying of RDF stores, additional effort for extending existing systems is required.
The implementation of the functions resource, valueset and value is rather simple. The symbol resource just defines a special constant and the latter execute basic retrieval operations against an RDF store.
Implementing the symbol resourceset needs considerably more work since parsing of
Manchester Syntax and transformation to SPARQL (or OWL for DL reasoning) is required.
Possible solutions may use extended SPARQL dialects like Terp [
In order to support the set1 content dictionary, a simple approach would be to first retrieve the data objects and then execute the set operation within the computer algebra system.
However, we suggest a mapping to compound SPARQL expressions that efficiently execute the set1 operations union, intersect, in or size for large-scale RDF data. 3
The content dictionary for RDF as introduced by Section 2 provides sufficient support for integrating linked data with OpenMath. However, a slight weakness of this representation stems from the usage of string constants for IRI references. These make it hard to track referenced classes or properties and to update them if the associated RDF resources are renamed.
A plain RDF encoding of OpenMath objects overcomes these shortcomings and bears additional advantages. Thus, established mechanisms for annotating and linking of RDF data can be used with OpenMath, and furthermore, IRI references and Manchester Syntax descriptions can be directly encoded as RDF (Section 3.2). 3.1
The ontology denoted by Figure 112 is basically a verbatim mapping of the OpenMath standard
to OWL. In contrast to the approach proposed by Robbins [
The only difference in comparison to OpenMath XML is that we have removed the OMR element that encodes explicit references to other OpenMath objects. These references are unnecessary since RDF itself provides the means for cross-referencing between resources. 3.2
We propose to use a special encoding for functions from the content dictionary for RDF (Section 2.1). Normally, these functions take string arguments for IRI references or Manchester Syntax descriptions. But when using the RDF encoding of OpenMath objects these arguments can directly be represented as resource IRIs or owl:Restrictions.
For example, the OpenMath object 12The ontology is available at http://numerateweb.org/vocab/math. Symbol
Compound
Object
rdfs:Literal subclass value must be exactly 1 Literal xsd:string name must be exactly 1 Variable
rdf:XMLLiteral encoding value must be must be exactly 1 exactly 1
Foreign attributeValue attributeKey must be must be exactly 1 exactly 1 AttributionPair
subclass target must be exactly 1 arguments must be list of symbol must be exactly 1 arguments must be list of binder body variables must be must be must be list of exactly 1 exactly 1 Attribution
Error
Application
Binding
rdf.resourceset("foaf:Person and foaf:age some xsd:int[>18]") can be encoded in RDF as [ a om:Application; om:symbol <http://www.openmath.org/cd/rdf#resourceset>; om:arguments ("foaf:Person and foaf:age some xsd:int[>18]") ] . or when using the native RDF encoding for arguments as [ a om:Application; om:symbol <http://www.openmath.org/cd/rdf#resourceset>; om:arguments ([ owl:intersectionOf ( foaf:Person [ a owl:Restriction; owl:onProperty foaf:age; owl:someValuesFrom [ a rdfs:DataType; owl:onDataType xsd:int;
owl:withRestrictions (xsd:minExclusive "18"^^xsd:int) ] ] )]) ] .
The latter form represents the Manchester Syntax expression directly as an owl:Class description. This encoding allows to use OWL reasoners for determining the contents of the rdf.resourceset. 3.3
The ontology as defined in Section 3 enables the representation of OpenMath objects as RDF
for sharing mathematical expressions as linked data and for their interoperability with other
information serialized as RDF (like owl:Restrictions). Together with the content dictionary
for RDF as introduced by Section 3.2, it enables the creation of links between OpenMath objects
and RDF resources and therefore solves the linking issue mentioned by [
Besides this, the ontology does not yet capture the vocabulary for the definition of content
dictionaries with symbols and their properties (roles, CMPs, FMPs, etc.). But nonetheless, we
can use the ontology to define new OpenMath symbols and relate them to existing ones as
discussed by [
a om:Symbol; rdfs:subClassOf <http://www.openmath.org/cd/set1#in> . In this case, the metamodeling capabilities of OWL 213 allow us to treat asymp1.Landauin14 and set1.in as OpenMath symbols and as OWL classes at the same time.
The OpenMath ontology can also be extended by additional subclasses of om:Symbol (e.g. BinderSymbol, AttributionSymbol, ApplicationSymbol) to enable modeling of symbol roles. These roles can then be applied to symbols by using rdf:type: asymp1:Landauin rdf:type om:ApplicationSymbol .
If additionally om:hasCMP and om:hasFMP are introduced as properties of om:Symbol then the definition of OpenMath content dictionaries in a distributed way (as linked data) gets possible: set1:emptyset a om:ConstantSymbol; om:hasCMP "The intersection of A with the emptyset is the emptyset"; om:hasFMP [ a om:Application; om:symbol relation1:eq; om:arguments (
# omitted for simplification ) ] . 4
Based on the content dictionary for RDF and the OpenMath RDF encoding this section describes how mathematical relationships can be expressed and embedded into OWL ontologies. Furthermore an architecture for respective rule processing is proposed. 4.1
For a human-readable definition of mathematical relationships in an ontology we use the
Popcorn syntax and propose the following extension:
13http://www.w3.org/TR/owl2-new-features/#Simple_metamodeling_capabilities
14The symbol was introduced as an example by [
In order to exemplary describe the reasoning process we use the FOAF vocabulary and extend it with the custom properties e:mass and e:height. While the former is a measurement for the weight of a person, the latter is used for representing the height of a human being. Further properties are computed using the following rules: The first rule describes the calculation of the body mass index (e:bmi) for any instance of foaf:Person. Each individual has to define values for the properties e:mass and e:height. This can either be done explicitly or by using property values computed by logical reasoning. If we, for example, consider an instance of foaf:Person that has a value for medical:weight instead of e:mass we could use an ontology alignment to infer the required property value: medical:weight rdfs:subPropertyOf e:mass
The second rule is used for computing the average body mass index (e:aBMI) across a specific set of people. Therefore the sum of respective body-mass-index property values is divided by the cardinality. 4.2
For rule processing we propose the architecture as illustrated in Figure 2. It involves a computer algebra system that has been extended as described in Section 2.5. Thus, this system can handle both, complex mathematics and retrieval of RDF data. In a current implementation of this architecture we make use of Symja15.
The prototype relies on a simple ontology16 that is used to represent mathematical rules. It defines the class mathrl:Constraint for the representation of such relationships. Instances of mathrl:Constraint have the attributes mathrl:onProperty for the target RDF property and mathrl:expression for the related formula represented by our OpenMath ontology (Section 3). Objects of type mathrl:Constraint are assigned to OWL classes by using the property mathrl:constraint. The following listing illustrates the serialization of the first rule given in section 4.1.
15http://code.google.com/p/symja/ 16The ontology is available at http://numerateweb.org/vocab/math/rules. foaf:Person mathrl:constraint [ mathrl:onProperty e:bmi; mathrl:expression [ a om:Application; om:symbol <http://www.openmath.org/cd/arith1#divide>; om:arguments ( [ a om:Application; om:symbol <http://www.openmath.org/cd/rdf#value>; om:arguments (e:mass)] [ a om:Application; om:symbol <http://www.openmath.org/cd/arith1.xhtml#power>; om:arguments ([ a om:Application; om:symbol <http://www.openmath.org/cd/rdf#value>; om:arguments (e:height)] "2"^^xsd:long)] ] .
)]
During the reasoning process, which can be triggered by the user or on data change, our
reasoner iterates over all instances of classes that are related to one or more mathematical rules.
Within an iteration it computes the properties given by the mathrl:onProperty attribute of
the correspondent instances of mathrl:Constraint using the mathematical term that is
referenced by mathrl:expression. Therefore the reasoner uses a phrase-book to transform the
mathematical expression for feeding the computer algebra system. The result of the calculation
is saved explicitly into the triple store. If, during computation, some of the referenced property
values cannot be retrieved then an error is logged. The described process is applicable to
backward and forward chaining. Furthermore, it relies on a closed world assumption like SPARQL
[
The examples show that rules may interfere with each other. If the reasoner encounters a rule that is dependent on an individual with a property whose value is retrieved from another rule, then, if not already existent, these respective values are calculated first. Possible strategies to overcome cycles involve the reasoning until no more changes occur or a certain processing limit, e.g. timeout, is reached or executing every rule for every individual only once. So far we can only handle acyclic dependencies.
We additionally support RDFS and OWL-based reasoning, which relies on an open world assumption. The combination with further description logic and rule languages like SPIN or SWRL is possible, but could be a source for additional dependency issues. 5
We have introduced a method for integrating RDF data retrieval into OpenMath to enable the consumption of linked data by computer algebra systems. In combination with our proposed RDF serialization for OpenMath objects it enables the definition of mathematical relationships within OWL ontologies. The related rules are used by our software architecture to execute mathematically enhanced inference over linked data sets.
Future work may investigate how the integration between OpenMath and RDF can be further improved, particularly concerning the representation of RDF statements within OpenMath and the alignment of OWL’s set logic with OpenMath’s set1 symbols. The development of methods for partial and distributed calculation could solve scalability issues when applying mathematically enhanced inference on huge data sets.
More sophisticated methods to overcome circular dependencies need to be applied, especially when combining our mathematically enhanced inference approach with reasoning based on description logic or further rule languages.
Finally, we think that, besides our use cases for energy performance analysis and process planning, the integration between OpenMath and linked data has a high potential for many applications, e.g. for open government data where methods for statistical calculations should be transparent. Especially the combination with existing technologies for knowledge representation and logical reasoning may provide improved support for today’s engineering tasks (e.g. integration of multiple data sources for the development of sustainable products).
The work presented in this paper is co-funded within the Cluster of Excellence Energy-Efficient Product and Process Innovation in Production Engineering (eniPROD R ) by the European Union (European Regional Development Fund) and the Free State of Saxony.