Alignment API: Implementation

This page describes the different classes available in the Alignment API implementation. For instructions how to use them, the reader is refered to the tutorial pages.

Basic alignment structures

A (default) implementation of this API can be found in the fr.inrialpes.exmo.align.impl package. It implements the API by providing the simple basic classes: BasicAlignment, BasicCell, BasicRelation and BasicEvaluator. These classes provide all the necessary implementation for the API but the algorithm specific methods (Alignment.align() and Evaluator.eval()). It also provides an RDF/XML parser that can parse the format into an Alignment object.

It is thus advised to extend these basic implementations instead of reimplementing everything (of course, there may be good reasons for doing otherwise).

Along with these basic classes the default implementation provides a library of other classes, mentioned below.

URI-based implementation

The URI-based implementation is a first concrete implementation of the Alignment API in which entities in correspondences are URI. It defines classes URIAlignment and URICell.

Object implementation

The Object implementation is an implementation of the Alignment API in which entities are OWL entities (classes, object properties, data properties, instances). It defines classes ObjectAlignment and ObjectCell. It is built on top of the abstract ontology layer Ontowrap which is extensible. This layer allows to use different ontology APIs within the Alignment API. This implementation is useful for implementing matching algorithms which needs to have access to the actual ontologies.

It is possible to transform instances of these classes through two primitives:

in ObjectAlignment transforms an ObjectAlignment into and URIAlignment;
static ObjectAlignment.toObjectAlignment(Alignment)
which transforms an URIAlignment into an ObjectAlignment provided that it is possible to load the two ontologies
static EDOALAlignment.toEDOALAlignment(Alignment)
which transforms an URIAlignment or ObjectAlignment into an EDOALAlignment provided that it is possible to load the two ontologies and dereference their URIs.

Useful abstract classes such as DistanceAlignment are built on top of this implementation as well as the old OWLAPIAlignment which has been maintained for compatibility purposes.

EDOAL alignments

The EDOAL language is implemented as an extension of the Alignment API. It defines classes EDOALAlignment and EDOALCell.


In general, alignment structures can be manipuled algebraically. This is described in more details in the dedicated page. We only discuss trimming here.

If neither ontology needs to be completely covered by the alignment, a threshold-based filtering would allows for retaining only the highest confidence entity pairs. Triming, for most of its actions, requires that the set M supporting confidence measures be a totally ordered set. Without the injectivity constraint, the pairs scoring above the threshold represent a sensible alignment.

The easier way to proceed consists of selecting correspondences over a particular threshold. However, we implemented several methods. They are identified in the cut method by a following string switches:

retains all the correspondences above or equal to threshold n;
retains all the correspondences which are above or equal to the best value minus n;
retains all the correspondences which are above or equal to n% of the best value;
retains the n% best values (beware, ex-aequos are drawn at random).

The method is invoked by:

Alignment al; al.cut( "prop", .7 );
or, through the command line interface by:
$ java -jar lib/procalign.jar fr.inrialpes.exmo.align.util.ParserPrinter -T prop -t .7 ./edna.rdf


This API implementation does provide support for manipulating alignments. It offers a number of services for manipulating the API. The following primitives are available:

an alignment from a file in RDF/XML (AlignmentParser.parse());

The method is invoked by:

AlignmentParser aparser = new AlignmentParser(0); Alignment al = aparser.parse( new File( "./refalign.rdf" ).toURI() );


The obtained alignment can, of course, be generated in the RDF serialisation form of the Alignment format. However, there are other formats available.

The method is invoked by:

PrintWriter writer = new PrintWriter ( new BufferedWriter( new OutputStreamWriter( System.out, "UTF-8" )), true); AlignmentVisitor renderer = new RDFRendererVisitor(writer); al.render(renderer); writer.flush(); writer.close();
$ java -jar lib/procalign.jar fr.inrialpes.exmo.align.util.ParserPrinter -r fr.inrialpes.exmo.align.impl.OWLAxiomsRendererVisitor ./edna.rdf

The API provides the notion of a visitor of the alignment cells. These visitors are used in the implementation for rendering the alignments. So far, the implementation is provided with seven such visitors (in parenthesis is the minimal class from which renderer works):

displays the alignment in the RDF format as well as EDOAL. An XSLT stylesheet is available for displaying the alignments in HTML from the RDF/XML format.
OWLAxiomsRendererVisitor (ObjectAlignment)
generates an ontology merging both aligned ontologies and comprising OWL axioms for expressing the subsumption, equivalence and exclusivity relations.
generates an XSLT stylesheet for transforming data expressed in the first ontology in data expressed in the second ontology;
COWLMappingRendererVisitor (ObjectAlignment)
generates a C-OWL mapping, i.e., a set of relations expressed between elements (in fact classes) of two ontologies.
SWRLRendererVisitor (ObjectAlignment)
generates a set of SWRL rules for inferring from data expressed in the first ontology the corresponding data with regard of the second ontology.
SEKTMappingRendererVisitor (ObjectAlignment)
generates a mapping document as was defined in the SEKT document.
generates a SKOS mapping document.

Some of these methods, like XSLT or SWRL, take the first ontology in the alignment as the source ontology and the second one as the target ontology.

Generating axioms

OWL itself provides tools for expressing axioms corresponding to some relations that we are able to generate such as subsumption (subClassOf) or equivalence (equivalentClass). From an alignment, the OWLAxiomsRendererVisitor visitor generates an ontology that merges the previous ontologies and adds the bridging axioms corresponding to the cells of the alignment.

This returns:


  <owl:Ontology rdf:about="">
    <rdfs:comment>Aligned ontollogies</rdfs:comment>
    <owl:imports rdf:resource=""/>
    <owl:imports rdf:resource=""/>

  <owl:Class rdf:about="">
    <owl:equivalentClass rdf:resource=""/>

  <owl:Class rdf:about="">
    <owl:equivalentClass rdf:resource=""/>


Generating XSLT translations

Alignements may be used for translation as well as for merging. Such a transformation can be made on a very syntactic level. The most neutral solution seems to generate translators in XSLT. However, because it lacks deductive capabilities, this solution is only suited for transforming data (i.e., individual descriptions) appearing in a regular form.

The XSLTRendererVisitor generates transformations that recursively replace the names of classes and properties in individuals. The renderer produces stylesheets like:

<xsl:stylesheet xmlns:xsl="" version="1.0" xmlns:owl="" xmlns:rdf="" xmlns:rdfs="" xmlns:xsd=""> <xsl:template match=""> <xsl:element name=""> <xsl:apply-templates select="*|@*|text()"/> </xsl:element> </xsl:template> <xsl:template match=""> <xsl:element name=""> <xsl:apply-templates select="*|@*|text()"/> </xsl:element> </xsl:template> <!-- Copying the root --> <xsl:template match="/"> <xsl:apply-templates/> </xsl:template> <!-- Copying all elements and attributes --> <xsl:template match="*|@*|text()"> <xsl:copy> <xsl:apply-templates select="*|@*|text()"/> </xsl:copy> </xsl:template> </xsl:stylesheet>

Generating SWRL Rules

Finally, this transformation can be implemented as a set of rules which will ``interpret'' the correspondence. This is more adapted than XSLT stylesheets because, we can assume that a rule engine will work semantically (i.e., it achieves some degree of completeness with regard to the semantics) rather than purely syntactically.

The SWRLRendererVisitor transforms the matching into a set of SWRL rules. The result on the same example will be the following:

<?xml version="1.0" encoding="UTF-8"?> <swrlx:Ontology swrlx:name="generatedAl" xmlns:swrlx="" xmlns:owlx="" xmlns:ruleml=""> <owlx:Imports rdf:resource=""/> <ruleml:imp> <ruleml:_body> <swrlx:classAtom> <owlx:Class owlx:name=""/> <ruleml:var>x</ruleml:var> </swrlx:classAtom> </ruleml:_body> <ruleml:_head> <swrlx:classAtom> <owlx:Class owlx:name=""/> <ruleml:var>x</ruleml:var> </swrlx:classAtom> </ruleml:_head> </ruleml:imp> ... </swrlx:Ontology>

Of course, level 2 alignments would require specific renderers targeted at their particular languages.

Generating C-OWL mappings

The COWLMappingRendererVisitor transforms the alignment into a set of C-OWL mappings. The result on the same example will be the following:

<rdf:RDF xmlns:owl="" xmlns:rdf="" xmlns:rdfs="" xmlns:cowl="" xml:base="" xmlns:xsd=""> <cowl:Mapping rdf:ID=""> <cowl:sourceOntology> <owl:Ontology rdf:about=""/> </cowl:sourceOntology> <cowl:targetOntology> <owl:Ontology rdf:about=""/> </cowl:targetOntology> <cowl:bridgeRule> <cowl:Equivalent> <cowl:source> <owl:Class rdf:about=""/> </cowl:source> <cowl:target> <owl:Class rdf:about=""/> </cowl:target> </cowl:Equivalent> </cowl:bridgeRule> ... </cowl:Mapping> </rdf:RDF>

Generating SEKT-ML mappings

The SEKTMappingRendererVisitor transforms the alignment into a SEKT mapping document. The result on the same example is the following:

MappingDocument(""> source(<"">) target(<"">) classMapping( <"#s44261"> bidirectional <""> <""> ) classMapping( <"#s4201"> bidirectional <""> <""> ) )

Of course, level 2 alignments would require specific renderers targeted at their particular languages.

Generating SKOS

The SKOSRendererVisitor transforms the alignment into a SKOS mappings. The result on the same example is the following:

<rdf:RDF xmlns:rdf="" xmlns:rdfs="" xmlns:skos=""> <skos:Concept rdf:about=""> <skos:related rdf:resource=""/> </skos:Concept> <skos:Concept rdf:about=""> <skos:related rdf:resource=""/> </skos:Concept> </rdf:RDF>

Sample matchers

DistanceAlignment class template

The API features a DistanceAlignment abstract class that can be specialised for creating a similarity or distance based matching method. This class offers a variety of methods for extracting alignments from distance matrix.


Collection of predefined algorithms

The implementation of the Alignment API offers a small library of basic matchers. These are simply here as examples of matchers. Several of these algorithms have been run to provide the alignments between the two considered ontologies:

Simply compares the equality of local class and property names (once downcased) and align those objects with the same name;
Uses an editing (or Levenstein) distance between (downcased) entity names. It thus has to build a distance matrix and to choose the alignment from the distance;
Computes a substring distance on the (downcased) entity name;
Computes a substring distance on the (downcased) entity names and uses and aggregates this distance with the symmetric difference of properties in classes. This class is not available anymore within the API.

These simple algorithms should increase the accuracy of the matching results.

All these simple demonstration algorithms of the Alignment API, sould be rewritten with regard to the more generic DistanceAlignment and StringDistAlignment abstract classes.


Evaluators are described in a separate page.