Création de relations dans le graphe

Les graphes riches sont composés de relations N-Aire. Ces relations n-aires disposent d'informations de typage et de quantifications optionnelles permettant de manipuler des structures sémantiques.

2.5.1. Manipulation de tuples non typés

Un tuples est une une liste de valeurs. On la représente généralement mathématiquement sous la forme (x1,...,xN). N est ici l'arité du tuple.

Pour définir un tuple individuel, on utilise un constructeur de tuple auquel on va passer un tableau de sommets. Par exemple :

t:=TTupleNodeValue.Create(LGraph,'',[ TStringValue.Create_(LGraph,'','a'), TFloatValue.Create_(LGraph,'','1.2'));

créé ici une paire d'un string et d'un nombre réel qui correspond à la paire (2-tuple) : ('a',1.2)

Le tuple peut aussi disposer d'un nom formel comme les sommets atomiques. On peut écrire

t:=TTupleNodeValue.Create(LGraph,'MonTupe',[...

qui permet ensuite de retrouver le tuple comme un IEnvironnementValue dans le graphe. Pour pouvoir le manipuler comme une relation, il faut alors le projeter en IRelationNodeValue

IRelationNodeValue(LGraph['MonTuple'])

On peut obtenir l'arité du tuple via :

t.Arity

et pour accéder au ième élément du tuple on va écrire

ev:=t.Items[i]

qui est un IEnvironnementValue, donc un type de sommet. Ce type de sommet pourra ensuite être manipulé sous sa forme générique ou en le projetant sur un type de valeur IIntegerValue.

2.5.2. Manipulation de relations et de tuples typés

Une relation peut être vue comme un ensemble de tuples qui ont alors pour type la relation.

Pour créer une relation, nous pouvons appeler un constructeur de relation qui dans sa forme la plus simple est similaire au constructeur de tuple. Par exemple pour définir une relation binaire, on peut écrire :

TRelationNodeValue.Create(LGraph,'MaRelation',[nil,nil]);

ou en indiquant directement la cardinalité comme paramètre :

TRelationNodeValue.Create(LGraph,'MaRelation',2);

On peut alors ajouter un tuple à cette relation en le typant. On écrit alors :

TTupleNodeValue.Create(LGraph,'', TStringValue.Create_(LGraph,'','a'), TFloatValue.Create_(LGraph,'','1.2'),['MaRelation']);

Les constructeurs de relations permettent cependant aussi d'ajouter des informations : • Une information de type de relation (optionnel)

• Une information de quantificateur (optionnelle) : permet de réduire l'arité de la relation en liant certains de ses sommets (voir plus loin pour la manipulation des quantificateurs).

150/ 154 • Une information de mappage d'indexes (optionnelle) : permet des permutations ou des projections d'indexes au sein des

tuples (voir plus loin pour la manipulation des mappages d'indexes). • Une information de supertype ou de sous-type (optionnelle)

• Une information de méta-données non sémantiques : ces informations permettent en particulier de donner un nom de rôle aux différents indexes de relation. (voir plus loin pour la manipulation des méta-données de relations)

2.5.3. Manipulation de relations quantifiées

La notion de quantificateur est celle qu'on a en logique traditionnelle. Les relations quantifiées permettent :

• d'introduire des définitions quantifiées de relations déduites d'une relation existante, d'informations de domaines et de contraintes sur ces domaines

• d'ajouter des contraintes/propriétés sur les items reliés par la relation. On ne parlera alors pas de définition quantifiée de relation mais plutôt de contrainte de relation.

Pour construire une relation quantifiée, il faut lui passer en paramètre supplémentaire une liste de quantificateurs représentés par une valeur de type Iquantifiers et un constructeur TQuantifiers. Cette liste est composée de quantificateurs élémentaires (de type TQuantifierData) associés à chaque item de la relation, mais avec des informations supplémentaires d'ordre du quantificateur lui-même car l’ordre des quantificateurs ne respecte pas forcément celui des variables.

On a plusieurs catégories de quantificateurs élémentaires :

Nom Symbol Constructeur Exemples

Quantificateur universel FOL forall(order) forall(0)

Quantificateur universel DL every(order) every(0)

Quantificateur de définition definition(order) ou any(order) definition(0) any(0)

Quantificateur existentiel ou exists(order) ou exists(order,quantity)

exists(order,minQuantity,maxQuantity)

exists(0) equivalent à exists(0,1)

exists(0,3,5)

On peut utiliser Star pour représenter l'infini, ie l'absence de contrainte haute sur la définition.

Star(*)

Quantificateur d'instance instance(order) instance(0)

On note que contrairement à d'autres types de logique, on dispose ici de trois types de quantificateurs universels. La différence entre eux est la suivante :

• Quantificateur universel FOL : signifie que l'on doit prendre toutes les valeurs de E et qu'elles vérifient R. C'est le quantificateur universel de la logique du premier ordre.

• Quantificateur universel DL: signifie que l'on doit prendre toutes les valeurs possibles de x vérifiant R et qu'elles sont alors dans E. C'est le quantificateur universel utilisé dans les logiques de descriptions.

• Quantificateur de définition : signifie que x est un paramètre libre qui permet de définir la relation R et que le domaine des valeurs possible pour x est l'ensemble E

On les assemble dans des expressions de quantificateurs grâce au constructeur de q-tuple (tuple de quantificateurs élémentaires) :

va se coder en terme de liste de quantificateurs sous la forme

Q:=TQuantifiers.Create(LGraph,[exists(0),every(1)]) ;

que l'on peut ensuite l'associer dans une contrainte de relation :

Note : ci-dessus on a mis un domaine et un co-domaine qui correspondent à l'ensemble de toutes les valeurs possibles et notés TOP (#thing est son nom équivalent) et qui n'apparaissent pas dans l'expression mathématique

et

va se coder

TQuantifiers.Create(LGraph,[exists(1),every(0)]) ;

On peut aussi indiquer que deux variables doivent être identiques dans l'expression va une contrainte de quantificateur :

va se coder en terme de liste de quantificateur sous la forme

q:=TQuantifiers.Create(LGraph,[exists(0),exists(0)]) ;

que l'on peut ensuite injecter dans la contraine de relation :

TRelationNodeValue.Create(LGraph,'',[LGraph.Top,LGraph.Top],nil,q,[LGrap['R']) ;

avoir le même ordre de quanticateur va générer une erreur si : • deux quantificateurs individuels différents ont le même ordre • les domaines associés à ces quantificateurs individuels sont différents ainsi

TQuantifiers.Create(LGraph,[exists(0),forall(0)]) ;

génère une erreur du fait de l'existence de deux quantificateurs différents. Sinon dans l'expression suivante :

q:=TQuantifiers.Create(LGraph,[exists(0),exists(0)]) ;

TRelationNodeValue.Create(LGraph,'',['E','F'],nil,q,[LGrap['R']) ;

c'est la relation qui va générer une erreur si les concepts E et F sont différents.

2.5.4. Manipulation des informations polyadiques

Introduction aux relations polyadiques :

Les graphes riches introduisent des informations de relations particulieres, que nous désignerons sous le nom d'informations polyadiques.

En présence d'informations polyadiques on considère en fait que la relation s'applique sur des tuples via une structure interne de cette dernière. Nous clarifions cette notion par un exemple :

Par exemple soit la relation polyadique suivante : R(X,Y,Z) ![[1,0],[2,4],[1]]

Cette notation signifie que :

1. X, Y et Z sont des ensembles de tuples

2. le premier élément de la relation R est une paire (un 2-tuple) extrait de X et qu'on l'on permute les éléments 0 et 1, que le deuxième élément est un 2-tuples extrait de Y dont on prend l'élement d'index 2 et 4, et finalement que le dernier est un singleton extrait de Z dont on prend l'élément d'index 1.

3. chacun de ces éléments doit être en correspondance avec la structure interne de la relation polyadique qui est en fait une série de tuples. Donc avec l'instanciation 'interne' de la relation sous forme de tuples (a,b,c,d,e...) on a x=(b,a), y=(c,e), z=(b) qui sont des éléments valides possibles respectivement de X,Y et Z.

Manipulation des relations polyadiques par du code :

On dispose d'un constructeur pour les informations polyaddiques : TPolyadicMapValue :

TPolyadicMapValue.Create(LGraph,'',Map)

ou Perm est un tableau d'entier, par exemple [0,2,1] ainsi que Switch par exemple [[1,0],nil ,nil]

152/ 154 Pour déclarer une relation polyadique, il suffit de passer un PolyadicMapValue non null à une relation et de lui définir un type associé. TRelationNodeValue.Create(LGraph, 'maRelationPolyadique', [nil,nil,nil], TPolyadicMapValue.Create(LGraph,'',[[1,0],nil,nil]), nil, [LGraph['R']])

note nil correspond à un tableau [0,1,2,3,...] Quantification des relations polyadiques

On peut ajouter aussi des quantificateurs sur les relations polyadiques. Dans ce contexte, il faut interpréter la variable quantifiée comme un tuple, i.e. comme un objet ayant une liste de propriétés.

TRelationNodeValue.Create(LGraph, 'maRelationPolyadiqueQuantifiee', [01,02,03], TPolyadicMapValue.Create(LGraph,'',[0,2,1],[[1,0],nil,nil]), TQuantifiers.Create(LGraph,[forall(0),exists(1),exists(2)]), [LGraph['R']])

qui correspond dans une notation d'ordre 1 étendu par les informations de mappage à :

Note, pour changer l'ordre des quantificateurs on change leur index sans changer leur position dans le tableau. On a alors :

TRelationNodeValue.Create(LGraph, 'maRelationPolyadiqueQuantifiee', [01,02,03], TPolyadicMapValue.Create(LGraph,'',[0,2,1],[[1,0],nil,nil]), TQuantifiers.Create(LGraph,[forall(1),exists(0),exists(2)]), [LGraph['R']])

qui correspond dans une notation d'ordre 1 étendu par les informations de mappage à :