[Alignment format] [API]

EDOAL: Expressive and Declarative Ontology Alignment Language

The Expressive and Declarative Ontology Alignment Language (EDOAL) allows for representing correspondences between the entities of different ontologies. Unlike other formats, the alignment vocabulary allows to represent complex correspondences allowing to precisely describe the relation between the entities. The alignment vocabulary extends the alignment format.

Purpose

Representing ontology alignments is the general purpose of this vocabulary. Particularly, it extends the ontology alignment format in order to enable the representation of complex correspondences.

This format can be used for cases where expressing equivalence or subsumption between terms is not sufficient, when more precise relations need to be expressed. While term equivalence or subsumption might be enough for exchanging documents, more precise relations are needed to exchange and integrate data.

This vocabulary was originally designed with the goal of representing patterns of correspondence between ontologies. It was since then both simplified and extended to obtain a minimal vocabulary on top of the alignment format, able to express all possible kinds of ontology alignments.

Features

The alignment vocabulary has the following features:

The buttons below can be used to show or hide the available syntaxes.

In case of conflict, the RDF/XML syntax is the authoritative one. This is also the one for which we have developed parsers and renderers. However, we are glad that you report errors in the other syntaxes as well.

Alignment and cells

In the alignment format, an alignment is a set of cells, each cell being a correspondence between two entities. The alignment vocabulary extend this scheme by allowing cells to contain compound entity descriptions. Each entity can be typed according to one of the following category: Class, Instance, Relation, Property. A relation corresponds to an object property in OWL, a property to a datatype property. Each entity can then be restricted, and transformation can be specified on propery values.

While Alignment and Cell are described by the alignment format, we will focus here on the remaining classes.

Namespaces

The namespace for the Alignment format is still http://knowledgeweb.semanticweb.org/heterogeneity/alignment# (usual prefix: align).

EDOAL's own namespace is http://ns.inria.org/edoal/1.0/ (usual prefix: edoal). EDOAL vocabulary is dereferenceable (see below).

Alignment format

An EDOAL alignment is an alignment as specified by the alignment format. It is identified by its level which must be "2EDOAL". This tells tools that the alignment is on level 2, i.e., correspondences are across constructed entities, and that the corresponding entities are specified according to the expressive language. This ensures the compatibility with other extensions of the format. The alignment moreover specifies the two aligned ontologies, and as exemplified in the code below.

RDF/XML Syntax
<?xml version='1.0' encoding='utf-8' standalone='no'?> <rdf:RDF xmlns='http://knowledgeweb.semanticweb.org/heterogeneity/alignment#' xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns:xsd='http://www.w3.org/2001/XMLSchema#' xmlns:align='http://knowledgeweb.semanticweb.org/heterogeneity/alignment#' xmlns:edoal='http://ns.inria.org/edoal/1.0/'> <align:Alignment> <align:xml>yes</align:xml> <align:level>2EDOAL</align:level> <align:type>**</align:type> <align:method>fr.inrialpes.exmo.align.impl.method.StringDistAlignment</align:method> <align:time>7</align:time> <align:onto1> <align:Ontology rdf:about="http://www.example.org/ontology1"> <align:location>file:examples/rdf/onto1.owl</align:location> <align:formalism> <align:Formalism align:name="OWL1.0" align:uri="http://www.w3.org/2002/07/owl#" /> </align:formalism> </align:Ontology> </align:onto1> <align:onto2> <align:Ontology rdf:about="http://www.example.org/ontology2"> <align:location>file:examples/rdf/onto2.owl</location> <align:formalism> <align:Formalism align:name="OWL1.0" align:uri="http://www.w3.org/2002/07/owl#" /> </align:formalism> </align:Ontology> </align:onto2> ...

Details on each property are available on the alignment format page.

An alignment contains a set of correspondences (Cells). Each cell can be linked to an alignment using the map property.

RDF/XML Syntax
... <align:map> <align:Cell> <align:entity1><edoal:Class rdf:about="http://www.example.org/ontology1#entity1" /></align:entity1> <align:entity2><edoal:Class rdf:about="http://www.example.org/ontology2#entity2" /></align:entity2> <align:relation>=</align:relation> <align:measure rdf:datatype="&xsd;float">1.0</align:measure> <edoal:transformation>...</edoal:transformation> </align:Cell> </align:map> ...

As the example shows, the EDOAL vocabulary only appears within the "entity" properties and very specificaly in the edoal:transformation property.

The correspondence between the two entities could have been expressed in the simple Alignment format because these have named entities identified by a URI. However, the correspondence provides more information because it tells that these entities are Classes.

The strength of EDOAL is to express more complex entities which are described below.

Entities

A quick overview of the implemented EDOAL API is provided here (abstract classes are in bold and interfaces in italics):

EDOALAlignment extends BasicAlignment
EDOALCell extends BasicCell
Expression
|- ClassExpression
|  |- ClassId implements Id
|  |- ClassConstruction
|  |- ClassRestriction
|     |- ClassDomainRestriction
|     |- ClassOccurenceRestriction
|     |- ClassTypeRestriction
|     |- ClassValueRestriction
|- PathExpression implements ValueExpression
|  |- PropertyExpression
|  |  |- PropertyId implements Id
|  |  |- PropertyConstruction
|  |  |- PropertyRestriction
|  |     |- PropertyDomainRestriction
|  |     |- PropertyTypeRestriction
|  |     |- PropertyValueRestriction
|  |- RelationExpression
|     |- RelationId implements Id
|     |- RelationConstruction
|     |- RelationRestriction
|        |- RelationCoDomainRestriction
|        |- RelationDomainRestriction
|- InstanceExpression
   |- InstanceId implements Id
Value implements ValueExpression
Apply implements ValueExpression
Transformation
TransfService implements Clonable
Variable
Comparator
Datatype

The Id interface is implemented by expressions identified by an URI: these are the named entities of ontologies that may be used in basic URIAlignments. The ValueExpression is implemented by expressions that identify in context a particular value or instance. This can be an instance or a literal as well as a path expression that leads to that value in the context of an instance.

Hence, the entities that can be found in cells are:

entity ::= instexpr | classexpr | attexpr attexpr ::= propexpr | relexpr
Below are the syntactic declaration of these entities.

Class expressions

Class entities can be constructed using one of the three operators and, or, not.

A class can also be identified by using its URI or defined through a restriction. There are four types of class restrictions: These four types of restrictions restrict the scope of a class expression by applying a restriction to the value, type or cardinality of a particular property or relation. Restrictions are defined by giving an path expression (relation or property), a comparator defining the relation to a value.

classexpr ::= <Class rdf:about=" URI "/> | <Class> classconst </Class> | <AttributeOccurenceRestriction> onatt comp <value><Literal edoal:type="&xsd;integer" edoal:string="INTEGER" /></value> </AttributeOccurenceRestriction> | <AttributeDomainRestriction> onatt classrest </AttributeDomainRestriction> | <AttributeTypeRestriction> onatt typerest </AttributeTypeRestriction> | <AttributeValueRestriction> onatt comp (<value>instexpr</value>|val) </AttributeValueRestriction> classconst ::= <and rdf:parseType="Collection"> classexpr* </and> | <or rdf:parseType="Collection"> classexpr* </or> | <not> classexpr </not>

This grammar relies on base values described in the following table:

onatt ::= <onAttribute> attexpr </onAttribute> typerest ::= <datatype> type </datatype> type ::= <Datatype rdf:about=" URI " /> classrest ::= <class> classexpr </class> comp ::= <comparator rdf:resource=" URI "/>

Comparators have to be defined as specific URI, usually in the edoal namespace. They are currently described by: edoal:equals, edoal:lower-than, edoal:greater-than, the latter morally corresponding to the op:numeric-less-than and op:numeric-greater-than from the XQuery 1.0 and XPath 2.0 Functions and Operators recommendation.

Hence, a class expression may be an identified class:
RDF/XML Syntax
<Class rdf:about="&wine;WineFlavor" />
a disjunction or class expressions:
RDF/XML Syntax
<Class> <or rdf:parseType="Collection"> <Class rdf:about="&vin;Acidite" /> <Class rdf:about="&vin;Astreingence" /> <Class rdf:about="&vin;Amertume" /> </or> </Class>
Thanks to paths and restrictions, it is possible to restrict a correspondence to ``Wines whose producing region is located in Aquitaine'' using the following restriction:
RDF/XML Syntax
<Class> <and rdf:parseType="Collection"> <Class rdf:about="&vin;Wine" /> <AttributeValueRestriction> <onAttribute> <Property> <compose rdf:parseType="Collection"> <Relation rdf:about="&vin;hasTerroir" /> <Property rdf:about="&proton;name" /> </compose> </Property> </onAttribute> <comparator rdf:resource="&edoal;equals" /> <value edoal:type="&xsd;string">Acquitaine</value> </AttributeValueRestriction> </and> </Class>

Note that and and or can take no argument. This may be useful in some circumstances. They are interpreted as follows:

Property expressions

Properties correspond to data properties in OWL. Properties entities can be constructed using one of the operators and, or, not and compose:

A property can also be identified by using its URI or defined through a restriction. There are three classes of property restrictions:

propexpr ::= <Property rdf:about=" URI "/> | <Property> propconst+ </Property> | <PropertyDomainRestriction> <class> classexpr </class> </PropertyDomainRestriction> | <PropertyTypeRestriction> typerest </PropertyTypeRestriction> | <PropertyValueRestriction> comp val </PropertyValueRestriction> propconst ::= <and rdf:parseType="Collection"> propexpr+ </and> | <or rdf:parseType="Collection"> propexpr+ </or> | <not> propexpr </not> | <compose> relexpr* propexpr </compose>
As previously properties can be identified by its URI:
RDF/XML Syntax
<Property rdf:about="&wine;hasVintageYear" />
As previously properties can be assembled by boolean connectors:
RDF/XML Syntax
<Property> <and rdf:parseType="Collection"> <Property rdf:about="&vin;propriétaire" /> <Property rdf:about="&vin;négociant" /> </and> </Property>
but they can be obtained through a path, i.e., a sequence of relations ending by a property:
RDF/XML Syntax
<Property> <compose rdf:parseType="Collection"> <Relation rdf:about="&vin;hasTerroir" /> <Property rdf:about="&proton;name" /> </compose> </Property>
RDF/XML Syntax
<PropertyTypeRestriction> <datatype> <Datatype rdf:about="&xsd;integer" /> </datatype> </PropertyTypeRestriction>

Relation expressions

Relations correspond to object properties in OWL. Relation expressions can be constructed using one of the operators and, or, not and compose as well as "closure" operator inverse, symmetric, transitive and reflexive:

A relation can also be identified by using its URI or defined through a restriction. There are two classes of relation restrictions:

Their syntax is the following:

relexpr ::= <Relation rdf:about=" URI "/> | <Relation> relconst+ </Relation> | <RelationDomainRestriction> <class> classexpr </class> </RelationDomainRestriction> | <RelationCoDomainRestriction> <class> classexpr </class> </RelationCoDomainRestriction> relconst ::= <and rdf:parseType="Collection"> relexpr+ </and> | <or rdf:parseType="Collection"> relexpr+ </or> | <not> relexpr </not> | <compose> relexpr* </compose> | <inverse> relexpr </inverse> | <symmetric> relexpr </symmetric> | <transitive> relexpr </transitive> | <reflexive> relexpr </reflexive>

Domain restriction is exemplified in the following correspondence with relation expression:
RDF/XML Syntax
<align:Cell> <align:entity1> <Relation rdf:about="&wine;locatedIn"> <domainRestriction> <Class rdf:about="&wine;Wine" /> </domainRestriction> </Relation> </align:entity1> <align:entity2> <Relation rdf:about="&vin;hasTerroir" /> </align:entity2> <align:measure rdf:datatype="&xsd;float">1.0</align:measure> <align:relation><</align:relation> </align:Cell>
An example of occurrence restriction would be the wines produced in a region with no adjacent region, such as an island. For instance Moscatel Madeira wine is produced on the island of Madeira.
RDF/XML Syntax
<align:Cell> <align:entity1> <Class> <and rdf:parseType="Collection"> <Class rdf:about="&wine;Wine"> <attributeOccurrenceCondition> <Restriction> <onAttribute> <Relation> <compose rdf:parseType="Collection"> <Relation rdf:about="&vin;hasTerroir" /> <Relation rdf:about="&wine;adjacentRegion" /> </compose> </Relation> </onAttribute> <comparator rdf:resource="&edoal;greater-than" /> <value edoal:type="&xsd;integer">0</value> </Restriction> </attributeOccurrenceCondition> </and> </Class> </align:entity1> <align:entity2> <Class rdf:about="&vin;Madere" /> </align:entity2> <align:measure rdf:datatype="&xsd;float">1.0</align:measure> <align:relation>></align:relation> </align:Cell>
Another example uses a path to state that a locally grown wine is a wine whose owner (propriétaire) is the same person as the first seller (négociant) for this wine.
RDF/XML Syntax
<align:Cell> <align:entity1> <Class rdf:about="&wine;LocallyGrownWine" /> </align:entity1> <align:entity2> <Class> <and rdf:parseType="Collection"> <Class rdf:about="&vin;Vin"> <AttributeValueRestriction> <onAttribute> <Relation rdf:about="&vin;propriétaire" /></first> </onAttribute> <comparator rdf:resource="&edoal;equals" /> <value><Relation rdf:about="&vin;négotiant" /></value> </AttributeValueRestriction> </and> </Class> </align:entity2> <align:measure rdf:datatype="&xsd;float">1.0</align:measure> <align:relation>></align:relation> </align:Cell>

Note that compose may take no argument in case of relations. This may be useful in some circumstances. <compose rdf:parseType="Collection"/> is equivalent to the identity relation, hence when applied to an object has for unique value the object itself (it is the equivalent self or this in some languages).

Values

A value expression may be used in alignments for denoting an individual things (not a class, a property or a relations). These values may be:

They obey the following grammar:

val ::= <value> value </value> value ::= <Literal {edoal:type=" URI "} edoal:string=" STRING " /> | instexpr | attrexpr | <Apply edoal:operator=" URI "> <arguments rdf:parseType="Collection">value*</arguments> </Apply> instexpr ::= <Instance rdf:about=" URI "/>

Literal values:
RDF/XML Syntax
<Literal edoal:type="&xsd;integer" edoal:string="123" />

Instances are always single entities refering to an individual through its URI:

RDF/XML Syntax
<Instance rdf:about="&vin;hasTerroir" />

Application of an operator is not operational but may be expressed in the following way:
RDF/XML Syntax
<Apply edoal:operator="http://example.com/Whatever"> <arguments rdf:parseType="Collection"> <Literal rdf:about="&xsd;integer" edoal:string="123" /> <Property> <compose rdf:parseType="Collection"> <Relation rdf:about="&vin;hasTerroir" /> <Property rdf:about="&proton;localedIn" /> </compose> </Property> <Instance rdf:about="&vin;Bordelais" /> </arguments> </Apply>

URIs to use as the operator attribute of Apply are not specified. It is however advised, when possible, to use operators from the XQuery 1.0 and XPath 2.0 Functions and Operators recommendation. (fn: prefix used for http://www.w3.org/2005/xpath-functions).

Transformations

The development of transformations is still work in progress and you can contribute by providing your requirements. Transformations are expressed in the cell itself. Transformations do not express constraints on the classes or properties, but constraints on instances that should match.

transformation ::= <Transformation edoal:direction=" STRING "> <entity1> entity </entity1> <entity2> entity </entity2> </Transformation>

Transformations can be invoked, for example for dynamic transformations like currency conversions (see examples).

The following correspondence shows an example of the use of data transformation:
RDF/XML Syntax
<transformation> <Transformation edoal:direction="o-"> <entity1> <Property><compose rdf:parseType="Collection"/></Property> </entity1> <entity2> <Apply edoal:operator="concat"> <arguments rdf:parseType="Collection"> <Property rdf:about="vcard:firstname" /> <Literal edoal:type="&xsd;string" edoal:string=" " /> <!-- or even compute middle initial from middlename --> <Property rdf:about="vcard:middleinitial" /> <Literal edoal:string=". " /> <Property rdf:about="vcard:lastname" /> </arguments> </Apply> </entity2> </Transformation> </transformation>

Longer examples

The best examples are the alignment files found in the "examples/omwg" directory of the Alignment API release zip.

The following examples illustrate various kids of usage of the vocabulary.

Class partition

This example shows how to express a correspondence between a class in one ontology corresponding to a set of classes in the other ontology. In order to graps the precise correspondence, the one class is partitioned according to the value of one of its attributes. In this example one ontology has a class LED which has a property color, while the other ontology has three classes RedLED, BlueLED, and GreenLED. The LED class is aligned with the three corresponding classes by specifying a restriction of its scope to the corresponding value of the color attribute.

RDF/XML Syntax
<align:Cell rdf:about="#cell1"> <align:entity1> <Class> <and rdf:parseType="Collection"> <Class rdf:about="&O1;LED" /> <AttributeValueRestriction> <onAttribute> <Relation rdf:about="&O1;hasColor" /> </onAttribute> <comparator rdf:resource="&edoal;equals" /> <value><Instance rdf:about="&O1;Blue" /></value> </AttributeValueRestriction> </and> </Class> </align:entity1> <align:entity2><Class rdf:about="&O2;BlueLED" /></align:entity2> <align:relation>=</align:relation> </align:Cell> <align:Cell rdf:about="#cell2"> <align:entity1> <Class> <and rdf:parseType="Collection"> <Class rdf:about="&O1;LED" /> <AttributeValueRestriction> <onAttribute> <Relation rdf:about="&O1;hasColor" /> </onAttribute> <comparator rdf:resource="&edoal;equals" /> <value><Instance rdf:about="&O1;Red" /></value> </AttributeValueRestriction> </and> </Class> </align:entity1> <align:entity2><Class rdf:about="&O2;RedLED" /></align:entity2> <align:relation>=</align:relation> </align:Cell> <align:Cell rdf:about="#cell3"> <align:entity1> <Class> <and rdf:parseType="Collection"> <Class rdf:about="&O1;LED" /> <AttributeValueRestriction> <onAttribute> <Relation rdf:about="&O1;hasColor" /> </onAttribute> <comparator rdf:resource="&edoal;equals" /> <value><Instance rdf:about="&O1;Green" /></value> </AttributeValueRestriction> </and> </Class> </align:entity1> <align:entity2><Class rdf:about="&O2;GreenLED" /></align:entity2> <align:relation>=</align:relation> </align:Cell>
N3 Syntax
O1:LED a edoal:Class; O1:hasColor a edoal:Relation. O1:Blue a edoal:Instance. O2:BlueLED a edoal:Class. :cell1 a align:Cell; align:entity1 [ edoal:and [ edoal:onAttribute O1:hasColor; edoal:comparator function:equals; edoal:value O1:Blue. ]; edoal:and O1:LED. align:entity2 O2:BlueLED. O1:Red a edoal:Instance. O2:RedLED a edoal:Class. :cell2 a align:Cell; align:entity1 [ edoal:and [ edoal:onAttribute O1:hasColor; edoal:comparator function:equals; edoal:value O1:Red. ]; edoal:and O1:LED. align:entity2 O2:RedLED. O1:Green a edoal:Instance. O2:GreenLED a edoal:Class. :cell3 a align:Cell; align:entity1 [ edoal:and [ edoal:onAttribute O1:hasColor; edoal:comparator function:equals; edoal:value O1:Green. ]; edoal:and O1:LED. align:entity2 O2:GreenLED.
Graph

Property value transformation (XPath function)

This exemple shows how to use a transformation between property values. Two cases can be considered: static transformations such as unit conversion, and transformations which vary over time such as currency conversions. This example illustrates a static conversion from pounds to kilograms using a XPath function.

We give two valid versions of this correspondence depending on if the correspondence applies to the two properties (version 1) or the bearer of the transformed properties (version 2).

RDF/XML Syntax
<align:Cell rdf:about="#cell"> <align:entity1><Property rdf:about="&O1;hasWeight" /></align:entity1> <align:entity2><Property rdf:about="&O2;weight" /></align:entity2> <align:relation>=</align:relation> <transformation> <Transformation edoal:direction="o-"> <entity1> <Property><compose rdf:parseType="Collection"/></Property> </entity1> <entity2> <Apply edoal:operator="&fn;safe-divide"> <arguments rdf:parseType="Collection"> <Property><compose rdf:parseType="Collection"/></Property> <Literal edoal:type="&xsd;float" edoal:string="2.679229" /> </arguments> </Apply> </entity2> </Transformation> </transformation> </align:Cell>

RDF/XML Syntax
<align:Cell rdf:about="#cell"> <align:entity1><Class rdf:about="&O1;Person" /></align:entity1> <align:entity2><Class rdf:about="&O2;Patient" /></align:entity2> <align:relation>=</align:relation> <transformation> <Transformation edoal:direction="o-"> <entity1><Property rdf:about="&O1;hasWeight" /></entity1> <entity2> <Apply edoal:operator="&fn;safe-divide"> <arguments rdf:parseType="Collection"> <Property rdf:about="&O2;weight" /> <Literal edoal:type="&xsd;float" edoal:string="2.679229" /> </arguments> </Apply> </entity2> </Transformation> </transformation> </align:Cell>
N3 Syntax
01:hasWeight a edoal:Property. O2:weight a edoal:Property. :cell a align:Cell; align:entity1 O1:hasWeight; align:entity2 [ a Transformation; fn:safe-divide [ a rdf:Seq; rdf:li O2:weight; rdf:li 2.679229. ]. ].
Graph

Property value transformation (other service)

This example illustrates the conversion between two currencies. A transformation service is specified.

RDF/XML Syntax
<align:Cell> <align:entity1><Property rdf:about="&O1;price" /></align:entity1> <align:entity2><Property rdf:about="&O2;hasPrice" /></align:entity2> <align:relation>=</align:relation> <transformation> <Transformation edoal:direction="o-"> <entity1> <Property><compose rdf:parseType="Collection"/></Property> </entity1> <entity2> <Apply edoal:operator="http://www.google.com/finance/converter"> <arguments rdf:parseType="Collection"> <Property><compose rdf:parseType="Collection"/></Property> <Literal edoal:string="EUR" /> <Literal edoal:string="CNY" /> </arguments> </Apply> </entity2> </Transformation> </transformation> </align:Cell>
N3 Syntax
O1:price a edoal:Property. O2:hasPrice a edoal:Property. :cell a align:Cell; align:entity1 [ edoal:function <http://www.google.com/finance/converter?>; edoal:parameters [ rdf:li O1:price; rdf:li "from=EUR"; rdf:li "to=CNY". ]. ]; align:entity2 O2:hasPrice.
Graph

Class with attribute value restriction

This alignment pattern makes use of three variables. Var3 is a property variable representing a property having in its domain the class identified by the variable Var1. Moreover, the property Var3 has an integer value. This pattern thus captures all correspondences between two classes, the scope of one class being restricted to only those instances having a specific value (not specified by the pattern) for one of its property whith datatype "integer".

RDF/XML Syntax
<align:Cell rdf:about="#Cell1"> <align:entity1> <Class> <and rdf:parseType="Collection"> <Class edoal:var="#var1" /> <AttributeTypeRestriction> <onAttribute> <PropertyDomainRestriction edoal:var="#var3"> <class> <Class edoal:var="#var1" /> </class> </PropertyDomainRestriction> </onAttribute> <datatype><Datatype rdf:about="&xsd;integer" /></datatype> </AttributeTypeRestriction> </and> </Class> </align:entity1> <align:entity2> <Class edoal:var="#var2" /> </align:entity2> <align:relation>=</align:relation> </align:Cell>
N3 Syntax
:var1 a edoal:Variable; a edoal:Class. :var2 a edoal:Variable; a edoal:Class; :var3 a edoal:Variable; a edoal:Property; edoal:and [ edoal:domainRestriction :var1. ]. edoal:and [ edoal:typeRestriction <http://www.w3.org/2001/XMLSchema#integer>. ]. :Cell1 a align:Cell; align:entity1 [ edoal:and :var1; edoal:and [ a edoal:Restriction; edoal:onAttribute :var3. ]. ]. align:entity2 :var2.
Graph

EDOAL Pattern

EDOAL also contains a pattern language with allows for expressing generalised correspondences in which entities can be abstract. This language is not very different from EDOAL (beside its introduction of variables which are already present in the previous example).

It will be released at a later stage. Ask François Scharffe for a more complete description of the EDOAL Pattern language.

Dereferenceable vocabulary (Please: XHTML+RDFa)

Due to popular demand, here is the derefenceable version of the RDF vocabulary used in the format. Official URI is http://ns.inria.org/edoal/1.0/.

Beware, that EDOAL has been designed as a format and an API rather than a generic RDF vocabulary. A natural ontology would be closer to the API but would give a more verbose EDOAL format. The EDOAL format is in RDF and compact. In consequence, not any RDF graph using the EDOAL vocabulary is a well-defined EDOAL alignment. In particular, RDF can express incomplete knowledge while the EDOAL API requires complete knowledge of the alignment.

Class: Value

This is an abstract class, never instantiated in the format.

URI
http://ns.inria.org/edoal/1.0/#Value
subclasses
Literal, Instance, Attribute, Apply,

Class: Literal

URI
http://ns.inria.org/edoal/1.0/#Literal
superclasses
Value
properties
type, string

Property: type

URI
http://ns.inria.org/edoal/1.0/#type
domain
Literal
range
Datatype

Property: string

URI
http://ns.inria.org/edoal/1.0/#string
domain
Literal
range
String

Class: Apply

URI
http://ns.inria.org/edoal/1.0/#Apply
superclasses
Value
properties
operator, arguments

Property: operator

URI
http://ns.inria.org/edoal/1.0/#operator
domain
Apply
range
Operator

Property: arguments

URI
http://ns.inria.org/edoal/1.0/#argument
domain
Apply
range
Sequence(Value)

Class: Datatype

URI
http://ns.inria.org/edoal/1.0/#Datatype

Class: Class

URI
http://ns.inria.org/edoal/1.0/#Class
properties
and, or, not
subclasses
AttributeRestriction

Class: AttributeRestriction

This is an abstract class, never instantiated in the format.

URI
http://ns.inria.org/edoal/1.0/#AttributeRestriction
superclasses
Class
properties
onAttribute

Class: AttributeOccurenceRestriction

URI
http://ns.inria.org/edoal/1.0/#AttributeOccurenceRestriction
superclasses
AttributeRestriction
properties
(onAttribute), comparator, value

Class: AttributeDomainRestriction

URI
http://ns.inria.org/edoal/1.0/#AttributeDomainRestriction
superclasses
AttributeRestriction
properties
(onAttribute), class, all, exists

Class: AttributeTypeRestriction

URI
http://ns.inria.org/edoal/1.0/#AttributeTypeRestriction
superclasses
AttributeRestriction
properties
(onAttribute), datatype,

Class: AttributeValueRestriction

URI
http://ns.inria.org/edoal/1.0/#AttributeValueRestriction
superclasses
AttributeRestriction
properties
(onAttribute), comparator, value

Property: onAttribute

URI
http://ns.inria.org/edoal/1.0/#onAttribute
domain
ClassRestriction
range
Attribute

Property: class

URI
http://ns.inria.org/edoal/1.0/#class
domain
AttributeClassRestriction, PropertyDomainRestriction, RelationDomainRestriction, RelationCoDomainRestriction
range
Class

Property: all

URI
http://ns.inria.org/edoal/1.0/#all
domain
AttributeClassRestriction
range
Class

Property: exists

URI
http://ns.inria.org/edoal/1.0/#exists
domain
AttributeClassRestriction
range
Class

Property: datatype

URI
http://ns.inria.org/edoal/1.0/#datatype
domain
AttributeTypeRestriction, PropertyTypeRestriction
range
Datatype

Property: comparator

URI
http://ns.inria.org/edoal/1.0/#comparator
domain
AttributeValueRestriction, AttributeOccurenceRestriction, PropertyValueRestriction
range
Comparator

Property: value

URI
http://ns.inria.org/edoal/1.0/#value
domain
AttributeValueRestriction, AttributeOccurenceRestriction, PropertyValueRestriction
range
Value

Property: and

URI
http://ns.inria.org/edoal/1.0/#and
domain
Class, Property, Relation
range
Class, Property, Relation

Property: or

URI
http://ns.inria.org/edoal/1.0/#or
domain
Class, Property, Relation
range
Class, Property, Relation

Property: not

URI
http://ns.inria.org/edoal/1.0/#not
domain
Class, Property, Relation
range
Class, Property, Relation

Property: compose

URI
http://ns.inria.org/edoal/1.0/#compose
domain
Attribute
range
Attribute

Property: inverse

URI
http://ns.inria.org/edoal/1.0/#inverse
domain
Relation
range
Relation

Property: reflexive

URI
http://ns.inria.org/edoal/1.0/#reflexive
domain
Relation
range
Relation

Property: transitive

URI
http://ns.inria.org/edoal/1.0/#transitive
domain
Relation
range
Relation

Property: symmetric

URI
http://ns.inria.org/edoal/1.0/#symmetric
domain
Relation
range
Relation

Class: Attribute

This is an abstract class, never instantiated in the format.

URI
http://ns.inria.org/edoal/1.0/#Attribute
superclasses
Value
properties
and, or, not, compose
subclasses
Relation, Property

Class: Property

URI
http://ns.inria.org/edoal/1.0/#Property,
superclasses
Attribute
properties
(and, or, not, compose)
subclasses
PropertyDomainRestriction, PropertyTypeRestriction, PropertyValueRestriction
see also
the property section

Class: PropertyDomainRestriction

URI
http://ns.inria.org/edoal/1.0/#PropertyDomainRestriction
superclasses
Property
properties
class

Class: PropertyTypeRestriction

URI
http://ns.inria.org/edoal/1.0/#PropertyTypeRestriction
superclasses
Property
properties
datatype

Class: PropertyValueRestriction

URI
http://ns.inria.org/edoal/1.0/#PropertyValueRestriction
superclasses
Property
properties
comparator, value

Class: Relation

URI
http://ns.inria.org/edoal/1.0/#RelationExpression
superclasses
Attribute
properties
(and, or, not, compose), inverse, reflexive, symmetric, transitive
subclasses
RelationRestriction
see also
Relation section

Class: RelationRestriction

URI
http://ns.inria.org/edoal/1.0/#RelationRestriction
superclasses
Relation
properties
class
subclasses
RelationCoDomainRestriction, RelationCoDomainRestriction

Class: RelationCoDomainRestriction

URI
http://ns.inria.org/edoal/1.0/#RelationCoDomainRestriction
properties
(class)
superclasses
RelationRestriction

Class: RelationDomainRestriction

URI
http://ns.inria.org/edoal/1.0/#RelationDomainRestriction
properties
(class)
superclasses
RelationRestriction

Class: Instance

URI
http://ns.inria.org/edoal/1.0/#Instance
superclasses
Value
see also
Instance section

Class: Comparator

URI
http://ns.inria.org/edoal/1.0/#Comparator

Class: Operator

URI
http://ns.inria.org/edoal/1.0/#Operator
Transformation TransfService implements Clonable Variable

History

This language has been first designed by François Scharffe as the SEKT Mapping language. It then became the OMWG Ontology Mapping language developed under the Sourceforge mappingapi project (http://sourceforge.net/projects/mediation/). This language was further described by François Scharffe, Jérôme Euzenat and Antoine Zimmermann in Knowledge web deliverable 2.2.10, in particular through the semantics of the language. Its implementation was also reengineered as an extension of the alignment format so that it could be manipulated through the Alignment API tools (starting version 3.1).

It has now been redesigned and reimplemented under the name of EDOAL. It is a plain component of the Alignment API and is maintained together with it.

Thanks

Thanks to Jonathan Snook and Robert Nyman for the syntax toggling scripts borrowed from the OWL Recommendation web page. http://www.robertnyman.com/2005/11/07/the-ultimate-getelementsbyclassname/.


http://alignapi.gforge.inria.fr/edoal.html

$Id: edoal.html 1857 2013-06-27 08:58:50Z euzenat $