ALCOMO is a shortcut for Applying Locical Constraints on Matching Ontologies. ALCOMO is a project that has been developed by Christian Meilicke (that's me) in the context of his Phd. It is a debugging system that allows to transform incoherent alignments in coherent alignments by removing some correspondences from the alignment. The removed part of the alignment is called a diagnosis. It is complete in the sense that it detects any kind of incoherence in SHIN(D) ontologies. At the same time a computed diagnosis is always minimal in the sense that the tool never removes too much, i.e., the removed subset of the alignment is always a minimal hitting set over all conflicts.
Well, the whole story can be found in my thesis, which will be available here (sooner or later).
If you download and unzip the file alcomo.zip, you have a complete eclipse project with all required libraries and a working classpath. Moreover, there are also several files (ontologies and alignments) contained that allow you to directly run one of the two examples in package de.unima.alcomox.examples.
If you want to use alcomo as a jar-file in the classpath via command line, you first have to build the jar. In this case also download the file alcomo.zip, go to the root of the unzipped folder and type ant (you need to have ant installed). It will generate a jar file in the dist/ folder. Then can work with this jar file and the other libraries (in dist/lib/) in the way you like. For example, download the file ExampleXYZ.java and place it also in the dist/ folder. Then you can compile the file with the following command. First change to the dist/ folder as working directory.
javac -cp alcomo.jar ExampleXYZ.java
Run the main method of this class by copying the following line in your command line interpreter (remove line breaks first and for linux replace ; by :).
java -cp .;/lib/aterm-java-1.6.jar;lib/pellet-cli.jar;lib/pellet-core.jar; lib/pellet-datatypes.jar;lib/pellet-dig.jar;lib/pellet-el.jar;lib/pellet-explanation.jar; lib/pellet-jena.jar;lib/pellet-modularity.jar;lib/pellet-owlapiv3.jar;lib/pellet-pellint.jar; lib/pellet-query.jar;lib/pellet-rules.jar;lib/servlet.jar;lib/log4j1216/log4j-1.2.16.jar; lib/owlapi-bin.jar;lib/jgrapht-jdk1.5.jar;alcomo.jar ExampleXYZ
Currently there is a small useage example available and a partial javadoc documentation. However, this should be sufficient to understand how to use the main functionality. A few words on the terminology; typically you will first start to define a diagnostic problem (called 'ExtractionProblem' in the code). This requires you to load two ontologies, and an alignment between them (called 'Mapping'). Then you have to attach the ontologies and the alignment to the extraction problem.
// load the two ontologies that have been matched
LocalOntology sourceOnt = new LocalOntology("examples/cmt.owl");
LocalOntology targetOnt = new LocalOntology("examples/ekaw.owl");
// load the alignment that has been generated by a matcher
Mapping mapping = new Mapping("examples/cmt-ekaw/AgrMaker.rdf");
Mapping reference = new Mapping("examples/ref-cmt-ekaw.rdf");
ExtractionProblem ep = new ExtractionProblem(
... some arguments ... (details in the examples)
);
ep.bindSourceOntology(sourceOnt);
ep.bindTargetOntology(targetOnt);
ep.bindMapping(mapping);
It is now quite easy to run the algorithms. Moreover, you can retrieve the result again as an alignment and you can compare it easily against the reference alignment (if available). The discarded alignment is the diagnosis, the extracted alignment is the remaining part of the alignment if we remove the diagnosis.
System.out.println(ep.getDiscardedMapping());
System.out.println("Debugged alignment:");
System.out.println(ep.getExtractedMapping());
// compute precision and recall
Characteristic before = new Characteristic(mapping, reference);
Characteristic after = new Characteristic(ep.getExtractedMapping(), reference);
System.out.println();
System.out.println("Before debugging:\n" + before);
System.out.println("After debugging: \n" + after);
Note that the classes used in this example are also documented in the javadoc documentation.
ALCOMO uses Pellet v2.2.2 as underlying reasoner (black-box debugging approach) and the OWL API v3.1.0. The ALCOMO system supports as input format (a) the well known ontology formats that are supported by the OWL API and (b) the format of the Alignment API for loading and storing alignments, which has been used for OAEI over several years.
The system is freely available under MIT License.
There has never been an official version released prior to this version, so lets call the currently available version 1.0.0.
This is my University Mannheim Webpage, feel free to contact me if you have any questions or comments.
The figures to the left are Freges illustration of contraposition and contradiction (taken from the Begriffsschrift) and some wallpaper design.