We work with semantically defined knowledge representation languages (like description logics, conceptual graphs and object-based languages). Their semantics is usually defined within model theory initially developed for logics. The languages dedicated to the semantic web (rdf and owl) follow that approach. rdf is a knowledge representation language dedicated to the description of resources; owl is designed for expressing ontologies: it describes concepts and relations that can be used within rdf.

We consider a language $L$ as a set of syntactically defined expressions (often inductively defined by applying constructors over other expressions). A representation ($o\subseteq L$) is a set of such expressions. It is also called an ontology. An interpretation function ($I$) is inductively defined over the structure of the language to a structure called interpretation domain ($D$). This expresses the construction of the “meaning” of an expression in function of its components. A formula is satisfied by an interpretation if it fulfills a condition (in general being interpreted over a particular subset of the domain). A model of a set of expressions is an interpretation satisfying all these expressions. An expression ($\delta$) is then a consequence of a set of expressions ($o$) if it is satisfied by all of their models (noted $o\vDash \delta$).

A computer must determine if a particular expression (taken as a query, for instance) is the consequence of a set of axioms (a knowledge base). For that purpose, it uses programs, called provers, that can be based on the processing of a set of inference rules, on the construction of models or on procedural programming. These programs are able to deduce theorems (noted $o⊢\delta$). They are said to be sound if they only find theorems which are indeed consequences and to be complete if they find all the consequences as theorems. However, depending on the language and its semantics, the decidability, i.e., the ability to create sound and complete provers, is not warranted. Even for decidable languages, the algorithmic complexity of provers may prohibit their exploitation.

To solve this problem a trade-off between the expressivity of the language and the complexity of its provers has to be found. These considerations have led to the definition of languages with limited complexity – like conceptual graphs and object-based representations – or of modular families of languages with associated modular prover algorithms – like description logics.

Exmo mainly considers languages with well-defined semantics (such as rdf and owl that we contributed to define), and defines the semantics of some languages such as the sparql query language and alignment languages, in order to establish the properties of computer manipulations of the representations.

When different representations are used, it is necessary to identify their correspondences. This task is called ontology matching and its result is an alignment . It can be described as follows: given two ontologies, each describing a set of discrete entities (which can be classes, properties, rules, predicates, etc.), find the relationships, if any, holding between these entities.

An alignment between two ontologies $o$ and $o^{\text{'}}$ is a set of correspondences $\langle e,e^{\text{'}},r\rangle$ such that:

In addition, a correspondence may support various types of metadata, in particular measures of the confidence in a correspondence.

Given the semantics of the two ontologies provided by their consequence relation, we define an interpretation of two aligned ontologies as a pair of interpretations $\langle m,m^{\text{'}}\rangle$, one for each ontology. Such a pair of interpretations is a model of the aligned ontologies $o$ and $o^{\text{'}}$ if and only if each respective interpretation is a model of the ontology and they satisfy all correspondences of the alignment.

This definition is extended to networks of ontologies: a collection of ontologies and associated alignments. A model of such an ontology network is a tuple of local models such that each alignment is valid for the models involved in the tuple. In such a system, alignments play the role of model filters which select the local models that are compatible with all alignments. So, given an ontology network, it is possible to interpret it.

However, given a set of ontologies, it is necessary to find the alignments between them and the semantics does not tell which ones they are. Ontology matching aims at finding these alignments. A variety of methods is used for this task. They perform pairwise comparisons of entities from each of the ontologies and select the most similar pairs. Most matching algorithms provide correspondences between named entities, more rarely between compound terms. The relationships are generally equivalence between these entities. Some systems are able to provide subsumption relations as well as other relations in the support language (like incompatibility or instantiation). Confidence measures are usually given a value between 0 and 1 and are used for expressing preferences between two correspondences.

Links are important for the publication of rdf data on the web. We call data interlinking the process of generating links identifying the same resource described in two data sets. Data interlinking parallels ontology matching: from two datasets ($d$ and $d^{\text{'}}$) it generates a set of links (also called a link set, $L$).

We have extended the notion of database keys in a way which is more adapted to the context of description logics and the openness of the semantic web. We have introduced the notion of a link key , which is a combination of such keys with alignments. More precisely, a link key is a structure $\langle K^{eq},K^{in},C\rangle$ such that:

Such a link key holds if and only if for any pair of resources belonging to the classes in correspondence such that the values of their property in $K^{eq}$ are pairwise equal and the values of those in $K^{in}$ pairwise intersect, the resources are the same.

As can be seen, link key validity is only relying on pairs of objects in two different data sets. We further qualify link keys as weak, plain and strong depending on them satisfying further constraints: a weak link key is only valid on pairs of individuals of different data sets, a plain link key has to apply in addition to pairs of individuals of the same data set as soon as one of them is identified with another individual of the other data set, a strong link key is a link key which is also a key for each data set, it can be though of as a link key which is made of two keys.

Link keys can then be used for finding equal individuals across two data sets and generating the corresponding owl:sameAs links.