Convertisseur OWL vers RDF/RDFS by bt5Rkt

VIEWS: 0 PAGES: 96

									Projet tuteuré
2008-2009

Benjamin Harbelot – Emmanuel Neret – Yoan Chabot
IUT Informatique de Dijon
Tuteur : Christophe Cruz




             [CONVERTISSEUR
             OWL VERS
             RDF/RDFS]
              Application destinée au web sémantique
SOMMAIRE

Table des figures ........................................................................................................................................................................................................... 3

1 Introduction ............................................................................................................................................................................................................... 4

2 Présentation générale ............................................................................................................................................................................................... 4

    2.1 Objectifs du projet ............................................................................................................................................................................................. 4

         2.1.1 Definition du besoin.................................................................................................................................................................................. 4

         2.1.2 Resultats attendus ..................................................................................................................................................................................... 5

    2.2 Présentation du web sémantique .................................................................................................................................................................... 5

         2.2.1 L’évolution d’Internet ............................................................................................................................................................................... 5

         2.2.2 Applications du web sémantique ............................................................................................................................................................ 5

    2.3 Organisation du projet...................................................................................................................................................................................... 6

         2.3.1 Planning ..................................................................................................................................................................................................... 6

         2.3.2 Moyens mis en œuvre ............................................................................................................................................................................... 8

         2.3.3 Management de projet et communications ............................................................................................................................................ 9

3 Analyse et conception............................................................................................................................................................................................... 9

    3.1 Caractéristiques des langages en œuvre ........................................................................................................................................................ 9

         3.1.1 Présentation hierarchique ...................................................................................................................................................................... 10

         3.1.2 étude de RDFS/RDFS ............................................................................................................................................................................. 11

         3.1.3 Etude de OWL ......................................................................................................................................................................................... 16

         3.1.4 Langages de simplification .................................................................................................................................................................... 24

    3.2 Passage entre OWL et RDF/RDFS ................................................................................................................................................................ 26

         3.2.1 Tableau d’équivalence ............................................................................................................................................................................ 26

         3.2.2 Restrictions imposées par RDF/RDFS .................................................................................................................................................. 28

         3.2.3 Principes de traductions ......................................................................................................................................................................... 29

         3.2.4 Proprietés traduites par jena .................................................................................................................................................................. 31

         3.2.4 Propriétés non prises en charge par Jena ............................................................................................................................................. 48

    3.3 Etude de l’existant ........................................................................................................................................................................................... 75

         3.3.1 Présentation et comparatif des API Java Jena et Sésame .................................................................................................................... 76

         3.3.2 Présentation du convertisseur de Michel Klein ................................................................................................................................... 79

         3.3.3 Choix resultant de l’etude de l’existant ................................................................................................................................................ 82

4 Conclusion ............................................................................................................................................................................................................... 82

5 Sources ..................................................................................................................................................................................................................... 83

6 Annexes .................................................................................................................................................................................................................... 84



                                                                                                        Page 2
TABLE DES FIGURES
Figure 1 : L'évolution du web ............................................................................................................................................. 5
Figure 2 Principe d'inférence ............................................................................................................................................. 6
Figure 3 Planning de la phase d'analyse et conception ..................................................................................................... 7
Figure 4 Planning générale ................................................................................................................................................ 7
Figure 5 Diagramme de Pert .............................................................................................................................................. 8
Figure 6 Diagramme hiérarchie de l'équipe ........................................................................................................................ 8
Figure 7 Hiérarchie des langages ...................................................................................................................................... 10
Figure 8 Exemple RDF ..................................................................................................................................................... 13
Figure 9 Diagramme UML RDF 1 ................................................................................................................................... 15
Figure 10 Diagramme UML RDF 2 ................................................................................................................................. 16
Figure 11 Diagramme UML OWL 1................................................................................................................................ 18
Figure 12 Diagramme UML OWL 3................................................................................................................................ 21
Figure 13 Diagramme UML OWL 2................................................................................................................................ 20
Figure 14 Diagramme UML OWL 4................................................................................................................................ 23
Figure 15 Diagramme UML OWL 5................................................................................................................................ 23
Figure 16 Diagramme UML OWL 6................................................................................................................................ 23
Figure 17 Tableau d'équivalence OWL-RDF/RDFS ....................................................................................................... 28
Figure 18 Exemple de graphe............................................................................................................................................ 30
Figure 19 Graphe Annotation Property ........................................................................................................................... 32
Figure 20 Graphe Class .................................................................................................................................................... 33
Figure 21 Graphe Deprecated Class ................................................................................................................................. 34
Figure 22 Graphe Deprecated Property ............................................................................................................................ 36
Figure 23 Graphe DataRange ........................................................................................................................................... 39
Figure 24 Graphe Functional Property ............................................................................................................................ 41
Figure 25 Graphe Inverse Functionnal Property ............................................................................................................. 42
Figure 26 Graphe Object Property ................................................................................................................................... 44
Figure 27 Graphe Ontology .............................................................................................................................................. 44
Figure 28 Graphe Ontology Property............................................................................................................................... 46
Figure 29 Graphe Symmetric Property ............................................................................................................................ 47
Figure 30 Graphe Transitive Property ............................................................................................................................. 48
Figure 31 Graphe All Different et Distinct menbers ........................................................................................................ 51
Figure 32 Graphe Different From ..................................................................................................................................... 52
Figure 33 Graphe Cardinality .......................................................................................................................................... 54
Figure 34 Graphe Disjoint with ....................................................................................................................................... 55
Figure 35 Graphe Equivalent property ............................................................................................................................. 56
Figure 36 Tableau de conversion Jena .............................................................................................................................. 78
Figure 37 Capture d’écran du convertisseur de Michel Klein 1 ....................................................................................... 79
Figure 38 Capture d’écran du convertisseur de Michel Klein 2 ....................................................................................... 80
Figure 39 Tableau de conversion du convertisseur de Michel Klein ................................................................................ 82




                                                                                Page 3
1 INTRODUCTION

Lors de notre DUT informatique, nous sommes amenés à réaliser un projet tuteuré. Celui ci a pour but de
nous mettre face à une situation se voulant la plus proche possible de la réalité du métier d’analyste
programmeur. Notre équipe s’est tournée vers le projet du convertisseur car celui-ci introduit de
nombreuses technologies que nous ne connaissions pas ou peu. Afin de rendre notre projet le plus instructif
possible, il était important pour nous de prendre un sujet paraissant certes déroutant de prime abord mais
pouvant nous apporter une grande quantité de nouveaux savoirs. Ce sujet est en cela très intéressant. En
effet le sujet du web sémantique étant quelque chose de nouveau, cela est donc une chance pour nous
d’acquérir des capacités de ce genre.

Ce dossier a pour vocation de présenter l’analyse que nous avons faite autour du sujet. Pour cela nous
introduirons tout d’abord les aspects généraux de ce projet en abordant l’étude du besoin, la présentation
du contexte ou encore les sujets relatifs au management de projet. La deuxième partie de ce projet présentera
la partie technique de ce dernier avec une introduction aux langages en présence, une étude de l’existence et
les solutions proposées aux problèmes posés.




2 PRESENTATION GENERALE

Avant d’aborder les travaux de conception il est important de définir clairement ce qu’est le projet et dans
quel contexte il se situe. Pour cela nous avons réalisé une étude en trois parties. Tout d’abord nous nous
sommes demandés quels étaient les réels objectifs de ce projet. Puis ensuite nous avons défini le contexte du
web sémantique et enfin nous nous sommes intéressés à la gestion de notre projet en termes de temps et de
ressources.


2.1 OBJECTIFS DU PROJET

Certaines questions sont primordiales dans l’analyse d’un sujet. La définition du besoin et du résultat
attendu correspondant aux questions Pourquoi ? et Comment ? est une phase impérative pour la bonne
réussite d’un projet. Ces deux questions posées au bon moment et voire même plusieurs fois permettent
d’établir des spécifications précises et stables.


2.1.1 DEFINITION DU BESOIN

Le web sémantique étant relativement jeune, ses utilisateurs disposent de peu d’outils pour optimiser et
accélérer son maniement. Notre projet se propose donc de mettre à disposition de la communauté du
sémantique un outil performant, robuste et simple d’utilisation. Pour certaines applications bien
particulières il peut être utile de « traduire » des codes basés sur OWL en code RDF/RDFS. Ainsi des règles
de passage ont été prévues dès la création de ces deux langages. Le besoin exprimé est le suivant : créer une
application utilisant ces règles de passage permettant de faire le pont entre OWL et RDF/RDFS. Réaliser
cette opération de façon dynamique et automatisé est très intéressante en termes de temps et de justesse de
la traduction.

Une des applications de ce projet sera un des projets de Mr Rampaceck intitulé « Utilisation de CADP sur
des graphes sémantiques » Ce projet réalisé par Sébastien Meriot et Martin Richard devrait à terme fournir
un outil utilisant le langage RDF et capable de transformer ce dernier en graphe compatible avec la boite à
outils de vérification formelle qu’est CADP. Notre projet permettra donc d’utiliser OWL comme format
d’entrée de l’outil de façon indirecte.

                                                  Page 4
2.1.2 RESULTATS ATTENDUS

Le résultat attendu est un ensemble de classe programmé en Java et permettant le passage du langage OWL
à RDF/RDFS. Le langage Java a été imposé par le sujet. De nombreux API Java permettent de traiter la
sémantique ce qui nous pousse à croire que ce choix est le bon. Afin de permettre une utilisation simple une
documentation utilisateur sera fournie. Nous verrons plus loin dans ce dossier qu’il existe plusieurs
déclinaisons d’OWL : lite, DL et full. Pour ce projet nous réaliserons un convertisseur prenant en charge la
version lite et la version DL. En effet la version full de OWL ne prenant pas ou peu en charge les inférences,
cela se révèle inintéressant dans le cadre des projets énoncés ci-dessus.

Maintenant que les objectifs du projet sont définis nous allons étudier le contexte du projet : le web
sémantique.


2.2 PRESENTATION DU WEB SEMANTIQUE

Nous verrons dans cette partie les évolutions d’internet jusqu’au web sémantique, nous présenterons ensuite
le concept en présence pour enfin terminer sur des applications concrètes de cette nouvelle technologie.


2.2.1 L’EVOLUTION D’INTERNET

                                                      Depuis sa création, Internet a connu de nombreuses
                                                      évolutions. Dans son état initial le web 1.0 était
                                                      exclusivement constitué de pages statiques qui étaient
                                                      rarement mise à jour par manque de maniabilité et
                                                      d’accessibilité. Petit à petit internet est devenu un
                                                      réseau plus interactif. Les données se générant
                                                      dynamiquement à partir de bases de données, une
                                                      grande facilité à communiquer, le développement des
                                                      réseaux sociaux, autant de possibilités réunies sous la
                                                      bannière du web 2.0. Seulement le fond reste le
                                                      même : les données présentées sous forme de pages
                                                      par internet n’ont de sens que pour les yeux d’un
                                                      humain. Le code HTML (HyperText              Markup
                                                      Language) des pages internet est pris en charge par
                                                     le navigateur qui a pour rôle de traduire et d’afficher
                                                     les données à l’écran. Le web sémantique permettrait
                                                     de donner un sens aux données via des grâce à un
                                                     système de métadonnées (donnée définissant une
                                                     autre donnée) afin que celle-ci puissent être traité
Figure 1 : L'évolution du web
                                                  automatiquement. Le web sémantique est fondé sur les
                                                  principes du web actuel et s’appuie sur ce dernier : c’est
donc une évolution et pas un remplacement. Le rôle du web reste entier : consulter des données rapidement.




2.2.2 APPLICATIONS DU WEB SEMANTIQUE

Le concept de la sémantique étant relativement jeune sur internet, il est encore difficile de dire qu’elles
seront les réels apports de ce dernier. Toutefois on peut déjà saisir les contours de plusieurs applications
engendrées par cette évolution



                                                  Page 5
       Le raisonnement par inférence : C’est une opération qui consiste à tirer une conclusion à partir de
        données connues. Cela permet donc de déduire de nouvelles informations à partir de l’existant.
        C’est un processus de création qui permet l’expansion des connaissances. Tirer des conclusions, faire
        des déductions sont des choses qui étaient jusque là réserver aux êtres doté d’un esprit permettant la
        logique. Grâce à la sémantique cela pourrait s’étendre aux ordinateurs. Lorsque l’on connait la
        différence de vitesse de calcul entre un cerveau humain et un ordinateur on imagine rapidement les
        possibilités ouvertes par un tel phénomène.


                                                                                Les voitures sont rouges

             Les voitures sont des
                  véhicules




          Les véhicules sont
             tous rouges                 Figure 2 Principe d'inférence




       Optimisation de la coopération entre les machines : Grâce à la sémantique ce ne sont plus
        seulement les hommes qui comprennent le sens des informations. Désormais, La machine le
        comprend et peut donc travailler dessus. A ce jour internet permet l’accès à un énorme volume de
        données, la sémantique apporte aux machines le moyen de les traiter.

Les possibilités et les libertés engendrées par le web sémantique ont permis à de nombreux langages
sémantiques de naitre. Constatant la similitude de ces derniers le W3C (World Wide Web Consortium) a mis
en place un groupe de travail : WebOnt. Il en résultera deux recommandations provenant du W3C (Le W3C
n’émet pas de normes mais des recommandations) : Les langages RDF et OWL.

Le contexte étant bien défini, nous allons maintenant nous intéressé à l’optimisation de notre organisation
pour répondre aux besoins du projet avec efficience.


2.3 ORGANISATION DU PROJET

Il est indispensable, et c’est encore plus vrai à notre époque, d’établir un plan de route, de planifier notre
projet. Cela passe par une réflexion approfondi et des réajustements quotidiens mais c’est là la meilleure
solution pour subvenir aux besoins de notre client dans les délais et conformément à ses spécifications. Cette
étude se décomposera en trois parties. Tout d’abord nous présenterons le planning estimatif puis ensuite
nous aborderons le thème des ressources utilisés pour finir par divers aspects de l’organisation de notre
groupe de travail


2.3.1 PLANNING

Pour mener à bien ce projet, nous nous sommes vues imposés plusieurs dates butoirs. Nous ne sommes pas
sans savoir que la réussite de tout projet, et plus particulièrement dans le domaine de l’informatique, passe
par un planning bien estimé et harmonieux. Nous avons donc dès le début du projet établi un premier
planning estimatif sur le court terme du projet. Malgré des ré-estimations fréquentes, celui-ci nous as fourni
un bon support de travail en ce qui concerne la répartition des tâches.




                                                   Page 6
        Le projet est découpé en plusieurs grandes phases :

                L’analyse et la conception se terminant le 24 Octobre par le rendu d’un document de présentation du
                 sujet et d’un document concernant la conception
                La production et la qualification se terminant le jeudi 15 janvier 2009 par le rendu de dossiers
                 techniques et d’une présentation du produit
                Le déploiement et la finalisation. La dernière étape du projet sera une présentation orale devant un
                 jury le 16 janvier 2009

        Dès le début du projet nous avons réfléchi à un découpage en différentes taches afin de faciliter le travail en
        équipe et la vision de l’avancement de ce dernier. Ainsi nous avons pu en tirer les parties apparaissant sur le
        planning ci-dessous. Le temps utilisé à réfléchir à un découpage intelligent a été largement compensé par le
        gain de temps engendré par une telle manœuvre. Nous avons pu ainsi mener plusieurs tâches en parallèle et
        la rédaction de dossier de synthèse nous a tout de même permis de comprendre ce que faisais chacun des
        membres de notre équipe même si nous n’avions pas été directement impliqué.




 Figure 3 Planning de la phase d'analyse et conception

        Ci-dessus se trouve le planning de la phase d’analyse et de conception. Malgré de nombreuses retouches
        apportées tout au long de l’analyse nous avons pu constater que notre premier jet avait été plutôt bien
        calculé.




Figure 4 Planning générale




                                                           Page 7
      Ci-dessus se trouve le planning global. Les tâches de la partie développement n’ont pas été clairement
      définies mais on peut tout de même constaté sur ce diagramme de Gantt que l’analyse et la conception
      occupe un quart du temps alloué au projet.




                                                                 Ce diagramme de Pert nous permet de mieux voir
                                                                 les antécédents des taches. On constate qu’il y a en
                                                                 somme que très peu de dépendances ce qui a
                                                                 permis un découpage du travail peu complexe au
                                                                 final.

                                                                 Maintenant que le facteur temps est en partie
                                                                 maitrisé grâce à cette batterie de planning estimatif
                                                                 nous allons pouvoir nous intéressé aux facteurs
                                                                 ressources.




Figure 5 Diagramme de Pert




      2.3.2 MOYENS MIS EN ŒUVRE

      Tout d’abord sur le plan humain, notre équipe se compose de la manière suivante :




                                                                     La polyvalence apporté par le DUT
                                                                     Informatique a été avantageuse mais présente
                                                                     tout de même des inconvénients. Lorsque
                                                                     chacun a des affinités et des compétences
                                                                     spécifiques, cela entraine un découpage des
                                                                     taches naturel et efficace. Ce qui n’a pas été le
                                                                     cas pour notre équipe.




  Figure 6 Diagramme hiérarchie de l'équipe



      Sur le plan matériel, nos choix ce sont naturellement tourné vers des solutions
      totalement gratuites. Le langage de programmation retenu pour développer le
      projet étant le Java, cela nous as donné accès à des environnements de
      développement intégré tel que Eclipse ou encore NetBeans qui sont totalement
      gratuit. Lors de notre formation nous avons été familiarisés avec Eclipse. Ces 2




                                                        Page 8
logicielles ne présentant pas de différences significatives nous nous sommes tournés vers Eclipse profitant
ainsi de notre expérience sur cette EDI.

Nous avons aussi utilisé des outils plus spécifiques à la sémantique telle que
le logiciel Protégé. Ce logiciel permet la création et la manipulation
d’ontologie. Ce logiciel nous a permis de mieux comprendre le
fonctionnement du concept d’ontologie. Protégé est également une librairie
Java qui peut créer des applications à bases de connaissances en utilisant un
moteur d’inférence pour raisonner et déduire de nouvelles données par
application de règles d’inférence sur les instances d’une ontologie. Nous avons aussi étudié les capacités de
conversion de plusieurs API Java tel que Jena ou Kaon2. Une étude comparative de ces API est l’objet d’une
des parties de ce dossier (Voir étude de l’existant)


2.3.3 MANAGEMENT DE PROJET ET COMMUNICATIONS

Afin de rendre compte de notre travail, une réunion d’une demi-heure a eu lieu chaque semaine dans le
bureau de Mr Cruz. C’était pour nous l’occasion de définir le travail effectué et ce qu’il restait à faire. La
deuxième partie de nos réunions abordait les aspects techniques du projet et les solutions possibles à nos
problèmes. Apres chaque réunion le chef de projet était amené à ajuster le planning en fonction des
nouvelles consignes, des aléas, et du travail rendu. Un email de compte rendu de la réunion était ensuite
envoyé à chacun des membres ainsi qu’à Mr Cruz (Voir Annexes). Afin de permettre à chacun de suivre
l’avancement du travail des autres mais aussi de préparer la rédaction de ce dossier, Mr Cruz nous a invités
à rendre des comptes rendu du travail effectué chaque semaine. « L’obligation » de rendre un travail
hebdomadaire était quelque chose de contraignant mais qui au final c’est révélé salvateur pour l’avancée de
notre projet. De plus cela est plus logique de rédiger jour après jour notre travail plutôt que de faire cela en
toute fin d’analyse.

Maintenant que la partie relative au management de projet est terminée nous abordons l’étude technique
avec la quasi certitude d’utiliser notre temps avec justesse. Cette partie a aussi introduit le problème du
choix des technologies que nous retrouverons plus tard dans ce dossier lorsque nous devrons comparer les
différentes solutions déjà existantes.


3 ANALYSE ET CONCEPTION

Cette partie du dossier se propose de préparer le terrain de la phase de développement. Nous résumerons
tout d’abord les caractéristiques des langages OWL et RDF/RDFS, nous nous intéresserons ensuite au cœur
du problème : le passage de OWL à RDF/RDFS. Puis nous terminerons par une étude de l’existant afin de
déterminer si des solutions pourraient nous servir de base pour ce projet


3.1 CARACTERISTIQUES DES LANGAGES EN ŒUVRE

Pour réaliser un convertisseur, il est primordial de connaitre parfaitement la syntaxe et le comportement de
chacun des langages en entrée et en sortie. C’est ce que se propose de faire l’étude suivante. Nous avons vu
précédemment que les utilisateurs de la sémantique disposent de plusieurs langages pour travailler dont
deux recommandations du W3C : OWL et RDF/RDFS. Il est intéressant de voir d’où proviennent ses
langages et surtout de voir quels types de relations ils ont entre eux. Nous étudierons ensuite plus
précisément les propriétés des langages. Enfin nous terminerons cette partie par la présentation de deux
langages permettant de simplifier la syntaxe RDF :N3 et Turtle




                                                   Page 9
    3.1.1 PRESENTATION HIERARCHIQUE



                                                                                       = Parent syntaxique de
                                                                                       = Donne du sens à

                                                                         On constate sur ce schéma que les 2 langages
                                                                         qui nous intéressent sont des descendants
                                                                         syntaxiques de XML. En effet OWL et
                                                                         RDF/RDFS sont des langages ayant de fortes
                                                                         similitudes structurelles avec le XML. Afin de
                                                                         se familiariser aux langages qui seront utilisés
                                                                         lors du projet, il nous a semblé indispensable
                                                                         de réaliser un court résumé sur les propriétés
                                                                         du métalangage XML.


Figure 7 Hiérarchie des langages




                                                  PRESENTATION DU XML

                   XML est un langage de balisage, standardisé par le W3C, qui définit un ensemble de règles
                   syntaxiques pour la présentation structurée de l'information. Ce langage n’est donc d’aucune
                   utilité s’il est utilisé seul. Le langage XML fut créé pour répondre aux besoins de
                   communications entre les programmes et de partages d’informations en général. La grande
    force du langage XML est que tout le monde peut créer son langage à partir des règles de syntaxes dictées
    par la norme. XML est un métalangage, c'est-à-dire qu’il permet d’en créer d’autres.

    Pour réponde à la norme XML et donc à une partie de la norme RDF et OWL il faut respecter les quelques
    points suivants :

             Une balise commence par < et se termine par >. On doit toujours trouver une balise ouvrante
              associé une balise fermante. La balise fermante commence par </ :

                        Ex : <balise> </balise>

             Les balises ne doivent pas se chevaucher :

                        Ex : <baliseA><baliseB> …….</baliseA></baliseB>

             Une balise peut contenir du texte, des balises, les deux ou rien :

                        Ex : <baliseParent><baliseEnfant> Texte </baliseEnfant> Texte </baliseParent>

             Lorsqu'il n'y a rien entre deux balises, on peut écrire le raccourci suivant :

                        Ex : <balise></balise> peut s’écrire <balise/>

             Les éléments peuvent porter des attributs:

                        Ex : <balise attributA= « Test » attributB= « Test2 »></balise>




                                                           Page 10
       Un élément doit contenir toutes les balises. Il est appelé « élément racine » :

                Ex : <elementRacine>

                        <Personne>

                                 <nom/>

                                 <prenom/>

                        </Personne>

                </elementRacine>

La DTD (Document Type Definition) permet de définir la « grammaire du document XML» , on parlera de :

       Document valide pour un document XML comportant une DTD
       Document bien formé pour un document XML ne comportant pas de DTD mais répondant aux
        règles de base du XML

Une DTD peut être définie de 2 façons :

       En interne, c'est-à-dire en précisant la grammaire à l’intérieur du document
       En externe, en appelant un fichier contenant la grammaire à partir d'un fichier local ou bien par son
        URL

Après cette présentation de XML et la schématisation des relations entre les différents langages nous
pouvons maintenant aborder une étude détaillée pour chacun des langages utilisés dans le convertisseur.


3.1.2 ETUDE DE RDFS/RDFS

Dans cette partie du dossier nous allons essayer de faire le tour de l’ensemble des langages RDF/RDFS.
Nous présenterons pour cela les concepts inhérents à ces deux langages puis nous présenterons les
mécanismes de ces technologies en illustrant nos propos par des diagrammes UML.

RDF est un modèle conceptuel très élémentaire composé d’un sujet, prédicat et objet.
RDF est un langage formel par conséquent, il ne fait pas intervenir tout ce qui est
implicite selon le contexte. En résumé, RDF est un modèle de métadonnées (donnée
servant à définir une autre donnée) puissant largement accepté et utilisé mais trop
limité pour formuler des contraintes sémantiques plus riches et raisonner (d’où
l’intervention de RDFS et de OWL par la suite). RDF est le langage de base du web
sémantique, il a été conçu pour assurer une interopérabilité entre les applications qui
échangent de l’information non formalisée et non structurée sur le web. Il existe
différentes syntaxes sur lesquelles peut s’appuyer RDF : RDF-XML, OWL, ou encore N3 (notation 3), etc…Le
préfixe associé au vocabulaire RDF est rdf.

Exemple du fonctionnement de RDF :

Une personne peut regarder le ciel et dire « il pleut ». Ce qui sous-entend qu’il pleut des gouttes d’eau dans
le lieu où se situe la personne. Il faut donc l’exprimer de manière explicite en RDF : « Des gouttes d'eau
[sujet] pleuvent [prédicat] en ce lieu [objet] »

       Le sujet représente la ressource à décrire : par exemple une goutte d’eau
       Le prédicat représente un type de propriété applicable à cette ressource: par exemple le fait de
        pleuvoir


                                                    Page 11
       L'objet représente une donnée ou une autre ressource, c'est la valeur de la propriété: par exemple le
        lieu où il pleut

En somme RDF décrit des choses sous la forme d’une phrase avec sujet (ressource), verbe (propriété),
complément (valeur). RDF décrit toujours sous cette forme stricte de triplet. Une ressource peut être une
page web, un lien, un utilisateur… Cela introduit le concept d’identification des ressources.

                                              IDENTIFICATION

Une adresse URL est une chaîne de caractères qui identifie une ressource Web. Ces adresses constituent donc
des formes identificateurs au sein du Web. On peut alors s’en servir pour référencer de manière unique des
ressources. Cependant les adresses URL sont des types particuliers d’une forme plus générale
d’identificateur : les URI. Ces adresses partagent comme propriété de pouvoir être créées indépendamment
par des personnes ou des organisations différentes qui peuvent les utiliser pour identifier des choses.
Cependant, les adresses URI ne se limitent pas à l'identification de choses. En fait, on peut créer une adresse
URI pour tout ce qui a besoin d'être cité dans une déclaration, comme par exemple un document
électronique, une image, un service (ex : bulletin météo), des être humains, des entreprises, des bouquins
dans une bibliothèque et enfin des concepts abstraits sans réalité physique. RDF peut permettre
d’individualiser les informations en utilisant des URIref comme prédicat, sujet et objet. Les URIref
permettent d’enlever les ambiguïtés des informations référencées, de rendre l’identification du sujet plus
précise. Les URIref ont un identificateur de fragment optionnel qui est définit par l’utilisateur. Exemple :
http://www.example.org/index.html#section2

En bleu, nous avons l’adresse URI et en rouge l’identificateur de fragment optionnel séparé par un « # ». Par
exemple, si nous avons une ressource appelée « John Smith », une URIref permet de différencier ce « John
Smith » des milliers d’autres qui doivent exister ou encore d’une variable d’un programme quelconque. Mais
aussi de le faire évoluer d’une simple chaîne caractère vers une entité unique porteuse d’informations
inférentes. Ceci permet à une machine de comprendre lorsque des termes employés par plusieurs personnes
différentes sont identiques.

Nous avons désormais posé les bases du langage RDF. Nous allons maintenant tacher de donné un aspect
plus sémantique à tout cela en ajoutant le langage RDFS.

                                                 RDF SCHEMA

RDF Schéma (ou RDFS) permet d’étendre le vocabulaire RDF avec des Classes et des types de propriétés
spécifiques à une application ou un domaine. Le préfixe associé au vocabulaire RDF Schéma est rdfs. RDFS
fonctionne avec un nœud pour le sujet, un nœud pour l’objet et une flèche pour le prédicat (avec la flèche
orientée du nœud sujet au nœud objet). RDF Schéma permet de définir du vocabulaire et de l’utiliser pour
décrire des choses. Cependant, ce n’est pas un vocabulaire de classes et de propriétés propres à une
application. Il fournit en fait les facilités nécessaires pour décrire ces classes et propriétés et indiquer quelles
classes et propriétés s'utilisent ensemble (par exemple, pour dire que la propriété ex: métier servira à décrire
une personne ex: Personne). En somme, RDF Schéma ressemble au système d’un type de langage de
programmation tel que java. Par exemple, RDF Schéma permet de définir des ressources comme étant des
instances d'une ou de plusieurs classes. De plus, il permet d'organiser les classes de manière hiérarchique.
Par exemple, on pourrait définir une classe « Chien » comme sous-classe d’une classe « Animal », ainsi un
chien est implicitement un animal.




                                                     Page 12
        Exemple :




                          Figure 8 Exemple RDF




Ce graphe définit que la classe « MiniVan » est une sous-classe de « Van » mais aussi de
« PassengerVehicle ». Et les classes « Truck », « Van » et « PassengerVehicle » sont des sous-classes de
« MotorVehicle ». En conséquence, des instances de la classe « MiniVan » seront aussi des instances de la
classe « MotorVehicle » (et bien sûr de « Van » et « PassengerVehicle »)

En notation par triplet, ce schéma peut aussi s’écrire ainsi :

       On définit les classes :

        ex:MotorVehicle       rdf:type       rdfs:Class.

        ex:PassengerVehicle rdf:type             rdfs:Class.

        ex:Van           rdf:type        rdfs:Class.

        ex:Truck          rdf:type       rdfs:Class.

        ex:MiniVan          rdf:type       rdfs:Class.

       On lie les classes avec leurs sous-classes :

        ex:PassengerVehicle rdfs:subClassOf ex:MotorVehicle.

        ex:Van           rdfs:subClassOf ex:MotorVehicle.

        ex:Truck          rdfs:subClassOf ex:MotorVehicle.

        ex:MiniVan          rdfs:subClassOf ex:Van.

        ex:MiniVan          rdfs:subClassOf ex:PassengerVehicle.

Ceci s’écrit se traduit comme suit en RDF/XML :

<?xml version="1.0"?>

<!DOCTYPE rdf:RDF [<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#">]>




                                                       Page 13
<rdf:RDF

        xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"

        xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"

        xml:base="http://example.org/schemas/vehicles">

                <rdfs:Class rdf:ID="MotorVehicle"/>

                <rdfs:Class rdf:ID="PassengerVehicle">

                         <rdfs:subClassOf rdf:resource="#MotorVehicle"/>

                </rdfs:Class>

                <rdfs:Class rdf:ID="Truck">

                         <rdfs:subClassOf rdf:resource="#MotorVehicle"/>

                        </rdfs:Class>

                <rdfs:Class rdf:ID="Van">

                        <rdfs:subClassOf rdf:resource="#MotorVehicle"/>

                </rdfs:Class>

                <rdfs:Class rdf:ID="MiniVan">

                         <rdfs:subClassOf rdf:resource="#Van"/>

                         <rdfs:subClassOf rdf:resource="#PassengerVehicle"/>

                </rdfs:Class>

</rdf:RDF>

L’attribut rdf :ID sert à nommer les ressources (classes) et a pour effet d’affecter une référence URI relative
au schéma. Par exemple, pour rdf:ID="MotorVehicle", et en supposant que le schéma lui-même soit la
ressource : http://example.org/schemas/vehicles,           la référence URI complète de cette classe
serait http://example.org/schemas/vehicles#MotorVehicle.

Nous allons maintenant voir les différentes propriétés de RDFS. Outre les classes en RDF Schéma qui
décrivent des choses spécifiques, on trouve aussi des propriétés qui viennent caractériser ces classes. En
RDF Schéma, les propriétés sont décrites en utilisant la classe RDF rdf:Property, et les propriétés
RDF Schéma rdfs:domain, rdfs:range et rdfs:subPropertyOf qui sont les plus importantes.

La propriété rdfs:range sert à faire en sorte que les valeurs d'une propriété soit des instances d'une classe
désignée. Par exemple, si example.org voulait indiquer que la propriété ex:author avaient des valeurs qui
sont des instances de la classe ex:Person, cela s’écrirait en notation triplet :

ex:Person rdf:type    rdfs:Class

ex:author rdf:type    rdf:Property

ex:author rdfs:range ex:Person



                                                   Page 14
On commence par définir que l’on va utiliser une classe Person et une propriété author, puis on utilise range
pour définir author comme instance de person.

La propriété rdfs:domain sert à faire en sorte qu'une propriété s'applique à une classe désignée. Par exemple,
si example.org veut indiquer que la propriété ex:author s'applique aux instances de la classe ex:Book, il faut
écrire :

ex:Book   rdf:type    rdfs:Class.

ex:author rdf:type     rdf:Property.

ex:author rdfs:domain ex:Book.

Ces déclarations indiquent que ex:Book est une classe, que ex:author est une propriété, et que les
déclarations RDF utilisant la propriété ex:author ont des instances de ex:Book pour sujets. Il faut bien garder
à l’esprit que RDF Schema s’utilise en fait comme un complément d’information sur les ressources décrites
par RDF. Afin de mieux comprendre les concepts relatifs à RDF et RDFS, nous nous proposons de modéliser
cette réalité grâce aux diagrammes UML suivants.




    Figure 9 Diagramme UML RDF 1




Ce diagramme illustre qu’une classe peut hériter d’une ou de plusieurs autre classes grâce à la propriété
SubClassOf . Une propriété peut être composé d’un domain et d’un range (D’un sujet et d’un objet.
L’héritage peut aussi s’appliquer sur les propriétés grâce à la propriété SubPropertyOf. Enfin une ressource
peut avoir à un instant précis un type Classe.




                                                   Page 15
          Figure 10 Diagramme UML RDF 2




Le diagramme ci-dessus illustre d’autres propriétés de RDF/RDFS. Il faut retenir de ce diagramme que la
classe Statement fixe l’organisation de chaque triplet RDF en définissant le sujet, le prédicat et l’objet. Le
conteneur list est un ensemble ordonné de plusieurs ressources. Une ressource peut avoir un label et un
commentaire de type litteral.

L’étude de RDF/RDFS étant terminé, nous allons maintenant traiter le langage OWL.


3.1.3 ETUDE DE OWL

Avant de commencer la définition du langage OWL destiné au Web sémantique, il est important de précisé
quelques termes pour mieux comprendre la suite du dossier.

       OWL :Web Ontology Language est un dialecte XML basé sur une syntaxe RDF. Il fournit les moyens
        pour définir des ontologies web structurées.
       Ontologie(s) : Une ontologie est un ensemble structuré des termes et concepts représentant le sens
        d'un champ d'informations, que ce soient par les métadonnées d'un espace de noms, ou les éléments
        d'un domaine de connaissances.

         Exemple d’ontologie : une carte électronique est un ensemble de composants. Un composant peut être
soit un condensateur, soit une résistance, soit une puce. Une puce peut être soit une unité de mémoire, soit une
unité de calcul. Une carte électronique qui contient une unité de calcul contient aussi au moins une unité de
mémoire.

       Métadonnée(s) : Une métadonnée est une donnée servant à définir ou décrire une autre donnée quel
        que soit son support.
       Espace de nom :Un espace de nom est un ensemble de ce qui est désignable dans un contexte donné
        par une méthode d'accès donnée faisant usage de noms symboliques, plus clairement en prenant un


                                                   Page 16
        exemple : dans un annuaire téléphonique, l'espace de noms associé est celui des abonnés au
        téléphone du département concerné.
       Assertion : Une assertion de fait consiste à faire une instanciation et la description par énonciation
        des propriétés s’appliquant sur les instances.

Le langage OWL est basé sur la recherche effectuée dans le domaine de la logique de description. OWL
permet de décrire des ontologies, c'est-à-dire qu'il permet de définir des terminologies pour décrire des
domaines concrets. Une terminologie se constitue de concepts et de propriétés. Un domaine se compose
d'instance et de concepts. Comme on a vu avec l’exemple de la carte à puce le but est de prendre un objet et
d’en faire la description de manière à lui donné un sens. En pratique, le langage OWL est conçu comme une
extension de RDF et de RDFS ; OWL est destiné à la description de classes (par des constructeurs) et des
types de propriétés. De ce fait, il est plus expressif que RDF, auxquels certains reprochent une insuffisance
d'expressivité due à la seule définition des relations entre objets par des assertions. Aux concepts de classe,
de ressource, de littéral et de propriétés des sous-classes, de sous-propriétés, de champs de valeurs et de
domaines d'application déjà présents dans RDFS, OWL ajoute les concepts de classes équivalentes, de
propriété équivalente, d'égalité de deux ressources, de leurs différences, du contraire, de symétrie et de
cardinalité...

Il existe trois niveaux d’OWL :

       OWL Lite: pour une hiérarchie de classe et des contraintes simples (ex: cardinalité restreinte à 0 ou 1)
       OWL DL: pour une expressivité maximum, sans perdre la vérification automatique de complétude
        et de décidabilité pour les systèmes de raisonnement. OWL DL inclue toutes les constructions OWL
        avec pour restriction la séparation des types (une classe ne peut pas être aussi un individu et une
        propriété, une propriété ne peut être aussi un individu ou une classe). OWL DL est ainsi nommé
        parce qu’il correspond à une logique de description (Description Logic).
       OWL Full: pour un maximum d’expressivité et la liberté syntaxique de RDF, mais sans garantie pour
        l’automatisation. Par exemple une classe OWL peut être traitée à la fois comme une collection
        d’individu et un individu unique.

Nous allons maintenant nous intéressé à la syntaxe abstraite du langage qu’est OWL. Cette syntaxe ne permet pas la
construction de structures syntaxiques auto-référentes. Elle est également prévue pour les situations où les
classes, les propriétés et les individus forment des ensembles disjoints. Grossièrement, ce sont les limitations
nécessaires pour rendre le raisonnement décidable dans OWL. Une ontologie OWL dans la syntaxe abstraite
contient une séquence d'annotations, d'axiomes et de faits. Les ontologies OWL peuvent avoir un nom. Les
annotations des ontologies OWL peuvent servir à enregistrer l'origine et d'autres renseignements associés à
une ontologie, y compris les références d'importations d'autres ontologies. Le contenu principal d'une
ontologie OWL tient dans ses axiomes et ses faits, lesquels fournissent des informations concernant les
classes, les propriétés et les individus dans l'ontologie. Précision de quels vocabulaires ces termes
proviennent. C'est la raison pour laquelle, comme tout autre document XML, une ontologie commence par
une déclaration d'espace de nom contenue dans une balise rdf:RDF.

Exemple d’espace de nom pour une ontologie Humanité :

<rdf:RDF

xmlns   = "http://domain.tld/path/humanite#" // espace de nommage de l’ontologie
utilisable sans le préfixe humanité.

xmlns:humanite= "http://domain.tld/path/humanite#"// espace de nommage de l’ontologie
utilisable avec le préfixe humanité.

xmlns:base    = "http://domain.tld/path/humanite#"//URL de base de l’ontologie courante.


                                                    Page 17
xmlns:vivant = "http://otherdomain.tld/otherpath/vivant#"//Utilisation d’une autre
ontologie vivant.

xmlns:owl      = "http://www.w3.org/2002/07/owl#"//Introduction du vocabulaire owl

xmlns:rdf     = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"//Introduction du vocabulaire
owl

xmlns:rdfs    = "http://www.w3.org/2000/01/rdf-schema#"//Introduction du vocabulaire owl

xmlns:xsd     = "http://www.w3.org/2001/XMLSchema#">//Introduction du vocabulaire owl

L’en tête d’une ontologie se définit selon le même principe que celui d’un document XHTML : par une balise
d’en tête qui sera : owl:Ontology .




        Figure 11 Diagramme UML OWL 1



Le schéma ci-dessus montre les propriétés relatives au concept d’ontologie. Ce sont pour la plupart des
propriétés réflexives car elles symbolisent des relations entre ontologies (Version précédente, Notion de
compatibilité , import ). On constate que les ontologies OWL hérite de RDF Description.

                                               LES CLASSES

Une classe définit un groupe d'individus qui sont réunis parce qu'ils ont des caractéristiques similaires.
L’ensemble des individus d'une classe est désigné par le terme « extension de classe », chacun de ces
individus étant alors une « instance » de la classe. Les trois versions d'OWL comportent les mêmes
mécanismes de classe, à ceci près qu’OWL FULL est la seule version à permettre qu'une classe soit
l'instance d'une autre classe (d’une méta classe). A l'inverse, OWL Lite et OWL DL n'autorisent pas qu'une
instance de classe soit elle-même une classe. Ainsi les classes reprennent les concepts étudiés dans les
langages orientés objet. Pour déclarer une classe on utilise un principe de description. Ainsi, il existe de
nombreuses manières de déclarer une classe.

        Tout d’abord, on peut déclarer une classe grâce à son indicateur ainsi la description repose
         uniquement dans le nommage de la classe.




                                                  Page 18
    Exemple : <owl:Class rdf:ID="Humain" />// ici on nomme une classe Humain a l’aide
    de rdf:ID, c’est aussi la seul méthode pour nommé une classe lors de la
    déclaration

   Il est aussi possible d’énumérer les individus qui constituent la classe pour décrire cette dernière.

    Exemple :

    <owl:Class>//Comme dit précédemment on Remarque que la classe ne possède pas
    de nom.

          <owl:oneOf rdf:parseType="Collection">//A l’aide de la propriété
    owl :oneOf, il est possible d’énumérer les instances qui compose cette
    classe.

                    <owl:Thing rdf:about="#Damien" />

                    <owl:Thing rdf:about="#Olivier" />

                    <owl:Thing rdf:about="#Philippe" />

                    <owl:Thing rdf:about="#Xavier" />

                    <owl:Thing rdf:about="#Yves" />

            </owl:oneOf>

    </owl:Class>

    A noter : on voit ici l’apparition de owl :Thing c’est une classe spécial de même que la classe
    owl:noThing, toute les classes héritent de owl :Thing ainsi toutes les instances des ontologies
    existante font partie de l’ensemble Thing.A l’inverse la classe noThing elle est hérité de toutes les
    classes.

   Il existe aussi la description par restriction : Dans ce cas, la classe se compose de toutes les instances
    de owl :Thing qui sont en accord avec des propriétés. Les propriétés peuvent être de deux types : De
    valeurs ou de cardinalités.

    Une contrainte de valeur s'exerce sur la valeur d'une certaine propriété de l'individu (par exemple,
    pour un individu de la classe Humain, sexe =Homme), tandis qu'une contrainte de cardinalité
    porte sur le nombre de valeurs que peut prendre une propriété (par exemple, pour un individu de
    la classe Humain, aPourFrere est une propriété qui peut ne pas avoir de valeur, ou avoir plusieurs
    valeurs, suivant le nombre de frères de l'individu.

   Enfin, les descriptions par intersection, union ou complémentaire permettent de décrire une classe
    par, comme leur nom l'indique, l'intersection, l'union ou le complémentaire d'autres classes déjà
    définies, ou dont la définition se fait au sein même de la définition de la classe courante.

    L’intersection est utilisé pour créé une équivalence a partir de deux classe existante, a l’aide de
    owl:intersectionOf

    Exemple :

    owl:Class Woman                                               owl:intersectionOf
    owl:Class Human                                               owl:Class Female




                                                Page 19
  Ici la classe Woman est définie comme l’intersection de Human et de Female. Autrement écrit :
  Human  Female  Woman . L’union est utilisée pour faire d’un ensemble d’individu une classe, à
  l’aide de owl:unionOf.

  Exemple :

  owl:Class Humanoid

          owl:unionOf

                  ex:Chimpanzee

                  ex:Gorilla

                  ex:Man

  La classe Humanoid est ici définie comme l’union de Chimpanzé, Gorilla, et Man.

  Le complément est lui utilisé pour tout ce qui n’appartient pas à un ensemble, à l’aide de
  complementOf .

  Exemple :

  owl:Class Invertebrate

          owl:complementOf

                  Vertebrate

  Ici tout ce qui n’appartient pas à l’ensemble des Invertebrate sont les Vertebrate.

  Le diagramme UML suivant résume les différentes possibilités offertes pour créer une classe.




Figure 12 Diagramme UML OWL 2
                                             Page 20
Tout d’abord toutes les classes héritent de RDFS Class. Chaque classe peut être équivalente ou disjointe à
une ou plusieurs autres. Les différents types de déclarations sont modélisés par des classes héritant de OWL
Class. Les classes énumérées sont composés de plusieurs objets grâce à la propriété OneOf. Les descriptions
par complémentarité sont en relation avec une seule classe dont elle est le complément. Les descriptions par
intersections ou par union ont quant à elle besoin de deux ou plusieurs classes pour pouvoir fonctionner.




Figure 13 Diagramme UML OWL 3

Sur le diagramme UML ci-dessus on constate que les déclarations par restriction permettent l’accès à un
panel varié de restrictions. Ces restrictions utilisent des ressources, des classes ou des types littéral pour fixer
les restrictions.

                                       LES INSTANCES DE CLASSE :

La définition d'un individu consiste à énoncer un « fait ». On peut distinguer deux types de faits : les faits
concernant l'appartenance à une classe. La plupart des faits concerne généralement la déclaration de
l'appartenance à une classe d'un individu et les valeurs de propriété de cet individu. Une difficulté qui
peut éventuellement apparaître dans le nommage des individus concerne la non-unicité éventuelle
des noms attribués aux individus. Par exemple, un même individu pourrait être désigné de plusieurs façons
différentes. C'est la raison pour laquelle OWL propose un mécanisme permettant de lever cette
ambiguïté, à l'aide des propriétés owl:sameAs, owl:diffrentFrom et owl:allDifferent.

Exemple :

        <rdf:Description rdf:about="#Louis_XIV">

                 <owl:sameAs rdf:resource="#Le_Roi_Soleil" />

        </rdf:Description>

Ici on voit donc que Louis XIV et Le Roi Soleil désignent la même personne.


                                                     Page 21
                                             LES PROPRIETES

Owl fait la distinction entre deux types de propriétés : Tout d’abord les propriétés d’objet permettant de
relier des instances à d’autres instances, puis les propriétés de type de donnée qui permettent de relier des
instances à des valeurs de données. Respectivement, ce sont des instances des classes owl :ObjectProperty, et
owl :DataProperty elle-même sous classes de la classe RDF rdf :Property . Il est possible de spécifier les
propriétés, on peut restreindre la relation qu’elle symbolise, c'est-à-dire que l’on peut préciser me domaine et
l’image de la propriété.

Exemple :

        <owl:ObjectProperty rdf:ID="habite">

                <rdfs:domain rdf:resource="#Humain" />// le domaine

                <rdfs:range rdf:resource="#Pays" />// l’image

        </owl:ObjectProperty>

Ici, la propriété habite a pour domaine la classe humain, c’est a dire que se sont les humain qui agisse sur la
propriété habite, et pour image Pays. Pour une propriété de type de donnée l’image sera un type de donnée
(Integer, Double,ect). On peut définir une hiérarchie entre les propriétés, mécanisme sensiblement semblable
a celui de l’héritage sur les classes, à laide de rdfs :subPropertyOf (sous propriété de ).

Exemple :

        <owl:ObjectProperty rdf:ID="aPourFrere">

                <rdfs:subPropertyOf rdf:resource="#estDeLaFamilleDe" />

                <rdfs:range rdf:resource="#Humain" /> ...

        </owl:ObjectProperty>

Ici, la propriété « aPourFrere ” est une sous propriété de “ estDeLaFamille ”, car si l’instance répond au
critère de la propriété aPourFrere elle répond forcement à ceux de estDeLaFamille . On est ici en présence
d’un raisonnement par inférences. Une propriété comporte de nombreuse caractéristique telle que la
transitivité (owl:TransitiveProperty),       la symétrie (owl :SymmetricProperty), la fonctionnalité
(owl:FunctionalProperty), l’inverse (owl:inverseOf). L’ajout d’une caractéristique à une propriété se fait à
l’aide de la balise owl type.

Exemple de propriété symétrique :

        <owl:ObjectProperty rdf:ID="aPourFrere">

                 <rdf:type rdf:resource="&owl;SymmetricProperty" />

                <rdfs:domain rdf:resource="#Humain" />

                <rdfs:range rdf:resource="#Humain" />

        </owl:ObjectProperty>

Ici, la propriété est symétrique de manière a ce qu’un humain soit le frère d’un autre humain dans les deux
sens. Prenons un humain A et humain B, A a pour frère B et B a pour frère A.




                                                   Page 22
       Figure 14 Diagramme UML OWL 4



Le diagramme ci-dessus illustre les notions de Datatype et Object Property. Les différents « états » de ces
propriétés sont modélisés par des attributs à l’intérieur des classes. Une propriété peut aussi être l’équivalent
d’une autre et ce quelque soit son type (Objet ou données) et elle peut être aussi l’inverse d’une propriété
dans le cas des objets.




    Figure 15 Diagramme UML OWL 5




Le diagramme ci-dessus présente les relations qui existent
entre les individus et les Objet et dataProperty. On voit donc
qu’un individu peut avoir un certains nombre de
DatatypeProperty (Qui sont elles mêmes constitué de type
literal) et d’ObjectProperty. Enfin les notions DifferentFrom et



                                                    Page 23        Figure 16 Diagramme UML OWL 6
SameAs sont modélisés par des relations réflexives sur les individus. A gauche, le diagramme modélisant la
propriété DataRange. Chaque DataRange est associé à un ou plusieurs literal

La présentation du langage OWL étant terminé nous allons maintenant présenté les langages de
simplification N3 et Turtle.


3.1.4 LANGAGES DE SIMPLIFICATION

Afin de simplifier la lecture des traductions de la partie 3.2 il serait intéressant d’utiliser un des langages de
simplification de RDF/RDFS proposé par le W3C. Deux technologies peuvent répondre à notre besoin :
Turtle et N 3. La partie qui suit a pour but de définir chacun des langages et de choisir le meilleur des deux.

                                                   TURTLE

       Les URI sont écrit entre < >
       Les URI peuvent être abrégé en utilisant le @prefix.
                 Exemple : «@prefix MonPref :< http://example.org/ nes# >.//MonPref représente L’URI
        @prefix : < http://other.example.org/ nes#> . //tout ce que contient L’URI peut être utilisé avec
        un préfix
                 :bar.//revient a écrire http://example.org/nes#bar.
       Il y a toujours un point à la fin de chaque ligne.
       Les littéraux sont divisé en deux catégorie simple littéral et long littéral l’écriture change suivant le
        cas présent.

                “a string “

                “””a long string “””

       Les littéraux peuvent être donné soit à un suffixe soit à un datatype URI mais pas aux deux. Pour un
        suffixe il suffit de mettre @monSufix et pour le datatype il suffit de mettre ^^<URI>

                Exemple : « chat »

                « chat »@en

                « foo »^^<http://example.org/my/datatype>

       Les bases des URI peuvent être utilisé avec la directive @base pour servir d’abréviation mais c’est
        aussi pour simplifier une URI dans les donnés ou le préfixe est là pour décrire la donnée. Quand
        cette directive apparait, elle définie l’URI de base pour toutes les relatives.

        Exemple : @base<http://example.org/ns/>.

       On utilise a pour définir le type, ainsi a est équivalent a l’URI <http://www.w3.org/1999/02/22-
        rdf-syntax-ns#type>

                Exemple :

                         @prefix doc :< http://example.org/#ns> .

                         <http://example.org/path > a doc:Document .

       Abréviation des groupe de triplets
       Le symbole , peut être utilisé pour répété le sujet et le prédicat d’un triplet et ne modifier que
        l’objet .

                                                    Page 24
Exemple :

             :a :b :c,

                   :d.//le dernier triplet est :a :b :d

            Le symbole ; peut être utilisé pour répéter le sujet et varier uniquement le prédicat et l’objet

Exemple

:a :b :c ;

     :d :e.//le dernier triplet devient :a :d :e

            Une collection en turtle s’exprime de la manière suivante :

 ( object1 object2 ) is short for:
[ rdf:first object1; rdf:rest [ rdf:first object2; rdf:rest rdf:nil ] ]

( ) is short for the resource:
rdf:nil

Ainsi on place les objets de la collection entre parenthèse, qui elles désignent la ressource rdf:nil.

                                                          NOTATION 3

Il est possible d’abréger les URI de la même façon qu’avec Turtle, notamment avec @base qui permet de
choisir une URI de base pour simplifier celle qui seront relative a celle-ci, puis avec @prefix qui permet lui
de définir un namespace avec un préfixe.

S’ajoute a la notation turtle la possibilité de réduire encore plus le namespace au prefixe a l’aide de
@keyword .

             Exemple

             @prefix : <#> .

             :foo=<#foo> et en utilisant @keyword on peut encore le réduire a foo.

Pour les chaines de caractère, toute les chaine sont traité ainsi en N3 : « « « valeur » » ».

Certains namespace sont définit avec des particule de même que dans turtle N3 utilise la particule a pour
rdf :type mais elle utilise aussi d’autre outils :

A            <http://www.w3.org/1999/02/22-rdf-syntax-ns#type>

=            <http://www.w3.org/2002/07/owl#sameAs>

= >          <http://www.w3.org/2000/10/swap/log#implies>

<=           <http://www.w3.org/2000/10/swap/log#implies>

N3 utilise aussi des quantification : @forAll et @forSome qui permettent d’exprimer des restrictions sur des
valeurs.




                                                            Page 25
Enfin comme vu dans Turtle, N3 définie ses liste de la manière suivante : [rdf:first <a>; rdf:rest rdf:nil]. Qui
est beaucoup plus simplifier en Turtle.

                                    COMPARATIF DE TURTLE ET N3

La notation 3 semble plus complète que la notation Turtle, en cela elle contient plus de spécifications.

Malgré cela le but restant de simplifier la notation RDF au maximum de manière a favoriser la lecture. La
syntaxe sera entièrement suffisante pour notre projet.

Voici présenté les fonctionnalités présentes dans N3 mais pas dans turtle:

       :a.:b.:c equivalent a :a^:b^:c
       @keywords
       =>//implique
       = //equivalence
       @forAll
       @forSome
       <=// implique


Après cette étude on constate que ces deux langages se révèlent efficace et intéressant pour réaliser des
simplifications. N3 étant un peu plus complexe et en vue de la faible importance du travail de simplifications
à réaliser pour notre projet nous utiliserons le langage Turtle.

Nous avons terminé l’étude des langages. Cela nous aura permis de comprendre les mécanismes composant
ces derniers et nous pouvons maintenant débuter le travail de traduction.


3.2 PASSAGE ENTRE OWL ET RDF/RDFS

Lors de cette partie nous allons essayer d’apporter une traduction à chaque propriété OWL. Afin de donner
une base à notre travail nous avons soumis un fichier OWL contenant toutes les propriétés OWL existantes à
un petit programme Java utilisant l’API Jena. Vous trouverez un exemplaire de ce fichier en annexe avec
quelques propriétés en moins afin de garantir la cohérence de l’ontologie ainsi que le fichier de sortie après
la traduction réalisé par Jena. L’étude suivante est décomposée en quatre parties. Tout d’abord nous
présenterons un tableau récapitulatif des traductions de Jena puis nous expliciterons les restrictions imposés
par le langage RDF/RDFS ainsi que les principes de traductions. Ensuite nous étudierons les traductions
qu’a pu réaliser Jena puis ensuite nous essayerons de proposer des solutions pour les propriétés n’ayant pas
pu être traduite. Pour chaque propriété vous trouverez sa version OWL et RDF/RDFS , sa notation N3
(Permet une lecture plus aisé des triplets RDF) et un graphe représentatif de la réalité exprimé par la
propriété.


3.2.1 TABLEAU D’EQUIVALENCE

Le tableau d’équivalence qui suit fait apparaître toutes les propriétés OWL. Toutes ces propriétés ont été
soumise à une interprétation en RDF grâce à l’API Jena qui est l’un des rares outils capable à l’heure actuelle
d’effectuer cette opération.

Tableau d’équivalence entre owl et rdf :

-Toutes les propriétés d’OWL Lite sont en vert.




                                                   Page 26
-Toutes les propriétés d’OWL DL sont en bleu et s’ajoutent ou sont une extension (bleu-vert) de OWL Lite
(vert) à l’exception des propriétés en rouge qui sont interdite par OWL DL.

-Toutes les propriétés sont incluses dans OWL Full.


        Terme de vocabulaire                                  Pris en charge par Jena



                                      Propriétés relatives aux classes

        owl:equivalentClass                                              non

          owl:disjointWith                                               non

              owl:Class                                                  oui

             owl:oneOf                                                   non

         owl:complementOf                                                non

         owl:intersectionOf                                              non

            owl:unionOf                                                  non

            owl:Nothing                                                  oui

              owl:Thing                                                  oui

                                    Propriétés relatives au versionning

   owl:backwardCompatibleWith                                            non

       owl:incompatibleWith                                              non

          owl:priorVersion                                               non

             owl:imports                                                 non

        owl:DeprecatedClass                                              oui

      owl:DeprecatedProperty                                             oui

            owl:Ontology                                                 oui

       owl:OntologyProperty                                              oui

           owl:versionInfo                                               non

                                    Propriétés relatives aux restrictions

           owl:onProperty                                                non


                                                 Page 27
         Terme de vocabulaire                                    Pris en charge par Jena


             owl:hasValue                                                    non

         owl:allValuesFrom                                                   non

        owl:someValuesFrom                                                   non

            owl:cardinality                                                  non

         owl:minCardinality                                                  non

         owl:maxCardinality                                                  non

            owl:Restriction                                                  non

                        Propriétés relatives aux Object property et Datatype Property

       owl:FunctionalProperty                                                oui

   owl:InverseFunctionalProperty                                             oui

       owl:TransitiveProperty                                                oui

       owl:SymmetricProperty                                                 oui

       owl:equivalentProperty                                                non

       owl:AnnotationProperty                                                oui

            owl:DataRange                                                    oui

        owl:DatatypeProperty                                                 oui

         owl:ObjectProperty                                                  oui

            owl:inverseOf                                                    non

                                        Propriétés relatives aux instances

          owl:differentFrom                                                  non

             owl:sameAs                                                      non

        owl:distinctMembers                                                  non


Figure 17 Tableau d'équivalence OWL-RDF/RDFS


3.2.2 RESTRICTIONS IMPOSEES PAR RDF/RDFS



                                                   Page 28
       RDFS ne permet pas d’exprimer que deux classes sont disjointes. Par exemple, les classes des
        hommes et des femmes sont disjointes.
       RDFS ne permet pas de créer des classes par combinaison ensembliste d’autres classes (intersection,
        union, complément). Par exemple, on veut construire la classe Personne comme l’union disjointe des
        classes des hommes et des femmes.
       RDFS ne permet pas de définir de restriction sur le nombre d’occurrences de valeurs que peut
        prendre une propriété. Par exemple, on ne peut pas dire qu’une personne a exactement deux
        parents.
       RDFS ne permet pas de définir certaines caractéristiques des propriétés : transitivité (par exemple :
        estPlusGrand-Que), unicité (par exemple : estLePèreDe), propriété inverse (par exemple : mange est
        la propriété inverse de estMangéPar).


3.2.3 PRINCIPES DE TRADUCTIONS

La base de l’interprétation en RDF d’une classe, propriété, objet, individus, etc… est une description définie
entre deux balises :

<rdf :Description LaDonnée>

        …………………

        ………………….

        …………………

</rdf :Description>

On fera une description pour chaque ressource utilisée. Pour chaque propriété décrite, on utilisera ou
conservera un rdf :domain comme sujet, un rdf :range comme objet et un ou plusieurs rdf : type comme
prédicat. Toutes les ressources utilisées sont définies grâce à des URIrefs.

Exemple :

<owl:ObjectProperty rdf:ID="habiteA">

    <rdfs:domain rdf:resource="#Humain"/>

    <rdfs:range rdf:resource="#Ville"/>

  </owl:ObjectProperty>

Se traduit en RDF par :

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#habiteA">
(définition de la propriété à décrire avec rdf :about)

  <rdfs:range rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Ville"/> (objet)

  <rdfs:domain rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Humain"/>
(sujet)

  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty"/> (prédicat spécifiant le
type de propriété)

 </rdf:Description>



                                                  Page 29
Il se peut que l’on veuille utiliser un type de donnée ( date, String, integer,...) comme rdf :range plutôt
qu’une classe. Prenons un exemple pour une date de naissance. Une date de naissance s’applique à un
humain mais la valeur de la propriété DateDeNaissance est une date (la propriété sera de type
DatatypeProperty). Voici le modèle en
OWL :

<owl:DatatypeProperty
rdf:ID="dateDeNaissance">

     <rdfs:domain
rdf:resource="#Humain"/>

     <rdfs:range
rdf:resource="&xsd;date"/>

  </owl:DatatypeProperty>

Et la version interprétée en RDF :

<rdf:Description
rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#
dateDeNaissance">

  <rdfs:range
rdf:resource="http://www.w3.org/2001/
XMLSchema#date"/> (On se rend compte que
                                                      Figure 18 Exemple de graphe
#date n’est pas une classe de l’ontologie mais un
type prédéfini dans les Schémas XML)

  <rdfs:domain rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Humain"/>

  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DatatypeProperty"/>

 </rdf:Description>

Se traduit en TURTLE

@prefix myonto=<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

@prefix owl=<"http://www.w3.org/2002/07/owl# "/>.

@prefix xsd=<"http://www.w3.org/2001/XMLSchema# >.

Myonto :Humain a owl :Class.

Myonto :dateDeNaissance a owl :DatatypeProperty.

Rdfs:range:xsd:date.

Rdfs:domaine:Myonto:Humain.

Ci-dessus se trouve le graphe correspondant à cette traduction.

L’exemple ci-après montre comment s’utilisera dateDeNaissance pour définir une date de naissance au 18
août 2008. Bien sûr, on l’utilisera dans une autre description, celle d’un humain nommé Paul par exemple.
Pour lui attribuer une date de naissance, on notera :

                                                    Page 30
<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Paul">

        <dateDeNaissance rdf:datatype=

                "http://www.w3.org/2001/XMLSchema#date">2008-08-18

        </dateDeNaissance>

 </rdf:Description>

Il existe une super classe qui contient n’importe quelle classe en OWL : la classe thing. Si l’on veut définir
une classe humain comme sous classe de thing en OWL, voici comment cela fonctionne :

<owl:Class rdf:ID="Humain">

    <rdfs:subClassOf rdf:resource="&owl;Thing"/>

 </owl:Class>

La classe thing n’existe pas en RDF, cependant on peut tout de même supposer l’existence d’une classe qui
englobe toutes les classes :

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Humain">

  <rdfs:subClassOf rdf:nodeID="A0"/>

  <rdfs:subClassOf rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>

  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>

</rdf:Description

Lors de ces traductions nous utiliserons parfois des nœuds anonymes : une ressource anonyme ou nœud
anonyme (en anglais blank node ou bnode) est dans le langage RDF, une ressource, ou nœud d'un graphe
RDF, qui n'est pas identifiée par une URI. Une ressource anonyme peut être sujet ou objet d'un triplet RDF.

Afin de simplifier les graphes nous allons utiliser les préfixes suivants :

rdfxmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"

xsdxmlns:xsd="http://www.w3.org/2001/XMLSchema#"

rdfsxmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"

owl xmlns:owl="http://www.w3.org/2002/07/owl#"

MyOnto xmlns : MyOnto= "http://www.owl-ontologies.com/Ontology1223114912.owl#"

Maintenant que les principes de traductions sont définis nous allons nous intéressé aux propriétés que l’API
Jena a pu traduire.


3.2.4 PROPRIETES TRADUITES PAR JENA

Nous allons présenter dans cette partie toutes les propriétés ayant eu une traduction satisfaisante après le
travail de Jena.

                                         ANNOTATION PROPERTY


                                                    Page 31
Cette propriété est utilisée pour faire part de commentaire relatif à une ontologie

OWL :

<owl:AnnotationProperty rdf:about="creator"/>

RDF :

Traduction realisée par Klein : <rdf:Property rdf:about="creator"/>

ou

Traduction realisée par Jena : <rdf:Description rdf:about=" http://www.owl
ontologies.com/Ontology1223114912.owl#creator">

  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#AnnotationProperty"/>

</rdf:Description>

NOTATION TURTLE :

@prefix myonto=<"http://www.owl-ontologies.com/#">.

@prefix owl=<"http://www.w3.org/2002/07/owl# "/>.

Myonto:creator a owl:AnnotationProperty .

GRAPHE :


                                            Rdf :type
                                                                           owl :AnnotationProperty
MyOnto :creator




Figure 19 Graphe Annotation Property


                                                    CLASS

Cette propriété est utilisée pour déclarer une classe

OWL :

<owl:Class rdf:ID="Pays"/>

RDF :

Traduction realisée par Klein : <rdfs:Class rdf:ID="Pays"/>

Ou :

Traduction realisée par Jena :

<rdf:Description rdf:about="http://www.owl ontologies.com/Ontology1223114912.owl#Pays">



                                                    Page 32
         <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>

 </rdf:Description>

NOTATION TURTLE:

@prefix myonto=<"http://www.owl-ontologies.com/Ontology1223114912.owl#">.

@prefix owl=<"http://www.w3.org/2002/07/owl# "/>.

myonto:Pays a owl:Class.

GRAPHE :


                                                Rdf :type
                                                                                       Rdfs :Class
        MyOnto :Pays



Figure 20 Graphe Class


                                         DATATYPE PROPERTY

Cette propriété est utilisé pour relier des instances de classes à des types de données. La traduction de cette
dernière se trouve dans l’exemple de la partie : Principes de traductions

                                          DEPRECATED CLASS



Cette propriété sert à indiquer que la classe sera amenée à changer de manière incompatible dans la version
de l’ontologie à venir

OWL :

<owl:DeprecatedClass rdf:ID="Car">

 <rdfs:comment>Automobile is now preferred</rdfs:comment>

 <owl:equivalentClass rdf:resource="#Automobile"/>

</owl:DeprecatedClass>

RDF :

 <rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Car">

         <rdfs:comment> Automobile is now preferred </rdfs:comment>

         <rdf:Description rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#Automobile">

                  <rdf :type rdf : resource= "http://www.w3.org/2000/01/rdf-schema#Class"/>




                                                   Page 33
                  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#equivalentClass"/>

          </rdf:Description>

         <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DeprecatedClass"/>

 </rdf:Description>

NOTATION TURTLE :

@prefixmyonto="http://www.owl-ontologies.com/Ontology1223114912.owl#">.

@prefix owl=<"http://www.w3.org/2002/07/owl# "/>.

MyOnto:Automobile a owl:Class.

MyOnto:Automobile a owl:equivalentClass.

MyOnto:Car “”"is now prefered"””.

MyOnto:Car a owl: DeprecatedClass

GRAPHE :


                                                       Rdfs :comment
                                                                                      Automobile is now preferred
            MyOnto :Car



                                              Rdf :type
                                                                       Owl :Deprecated Class
                                    Rdf :Description




                             MyOnto :Automobile




             Rdf :type                                       Rdf :type




      Owl :equivalentClass
                                                                         Owl :Class




Figure 21 Graphe Deprecated Class


                                            DEPRECATED PROPERTY




                                                         Page 34
Cette propriété sert à indiquer que la propriété sera amenée à changer de manière incompatible dans la
version de l’ontologie à venir

OWL :

<owl:DeprecatedProperty rdf:ID="aPourConducteur">

               <rdfs:comment></rdfs:comment>

               <owl :inverseof rdf :ressource= « conduit » />

</owl:DeprecatedProperty>

RDF :

<rdf:Description rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#aPourConducteur">

        <rdfs:comment>inverse property drives is now preferred</rdfs:comment>

           <rdf:Description rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#Conduit">

               <rdf :type rdf : resource= " http://www.w3.org/2002/07/owl#ObjectProperty "/>

               <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#inverseOf"/>

           </rdf:Description>

<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DeprecatedProperty"/>

</rdf:Description>

NOTATION TURTLE :

@prefix myonto=<"http://www.owl-ontologies.com/Ontology1223114912.owl# ">.

@prefix owl=<"http://www.w3.org/2002/07/owl# "/>.

Myonto:conducteur a owl:DeprectatedProperty.

Myonto:conduit a owl:ObjectProperty.

Myonto:conduit a owl:inverseOf.




                                                 Page 35
  GRAPHE :


                                            Rdfs :comment
                                                                   Inverse property drives is now preferred
  MyOnto :aPourConducteur

                                                   Rdfs :type



Rdf :Description                                                       Owl :DeprecatedProperty




         MyOnto :Conduit



                               Rdfs :type
    Rdfs :type
                                                        Owl :Object Property



    Owl :Object Property



  Figure 22 Graphe Deprecated Property




                                                   DATARANGE

  Cette propriété est utilisée pour définir une structure contenant une gamme de valeurs de données

  OWL :

  <owl:DatatypeProperty rdf:ID="marqueDuTennis">

   <rdfs:range>

    <owl:DataRange>

       <rdf:List>

         <rdf:first rdf:datatype="&xsd;integer">0</rdf:first>

         <rdf:rest>

          <rdf:List>

           <rdf:first rdf:datatype="&xsd;integer">15</rdf:first>

           <rdf:rest>

            <rdf:List>


                                                      Page 36
           <rdf:first rdf:datatype="&xsd;integer">30</rdf:first>

           <rdf:rest>

            <rdf:List>

             <rdf:first rdf:datatype="&xsd;integer">40</rdf:first>

             <rdf:rest rdf:resource="&rdf;nil" />

            </rdf:List>

           </rdf:rest>

          </rdf:List>

         </rdf:rest>

        </rdf:List>

     </rdf:rest>

    </rdf:List>

  </owl:DataRange>

 </rdfs:range>

</owl:DatatypeProperty>

RDF :

<rdf:Description rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#marqueDuTennis">

         <rdfs:range rdf:nodeID="A33"/>

         <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DatatypeProperty"/>

</rdf:Description>

<rdf:Description rdf:nodeID="A36">

         <rdf:rest rdf:nodeID="A37"/>

         <rdf:first rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">0</rdf:first>

         <rdf:type rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#List"/>

 </rdf:Description>

<rdf:Description rdf:nodeID="A37">

                  <rdf:rest rdf:nodeID="A0"/>

                  <rdf:first rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">15</rdf:first>

                  <rdf:type rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#List"/>



                                                    Page 37
</rdf:Description>

 <rdf:Description rdf:nodeID="A0">

        <rdf:rest rdf:nodeID="A1"/>

        <rdf:first rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">30</rdf:first>

        <rdf:type rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#List"/>

</rdf:Description>

<rdf:Description rdf:nodeID="A1">

<rdf:rest rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"/>

        <rdf:first rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">40</rdf:first>

        <rdf:type rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#List"/>

 </rdf:Description>

<rdf:Description rdf:nodeID="A33">

  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DataRange"/>

 </rdf:Description>

NOTATION TURTLE :

@prefix myonto=<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

@prefix owl=<"http://www.w3.org/2002/07/owl# "/>.

@prefix Rdf=<"http://www.w3.org/1999/02/22-rdf-syntax-ns# "/>.

Myonto:marqueDuTennis a owl:DatatypeProperty.

Rdf:list(0 15 30 40) a owl:DataRange.




                                              Page 38
                           Owl :datatypeProperty




GRAPHE :

                                       Rdfs :range
                                                                        MyOnto :marqueDuTennis

     Rdf :nodeID= « A33 »




                   Owl :DataRange




     Rdf :nodeID= « A36 »                                                     Xsd :Integer>0<
                                            Rdf :List


                     Rdf :Rest



        Rdf :nodeID= « A37 »                                                  Xsd :Integer>15<
                                            Rdf :List


                     Rdf :Rest




     Rdf :nodeID= « A0 »                                                      Xsd :Integer>30<
                                             Rdf :List


                   Rdf :Rest



                                             Rdf :List
        Rdf :nodeID= « A1 »
                                                                              Xsd :Integer>40<

                     Rdf :Rest
                                           Figure 23 Graphe DataRange

               Rdf :nil




                                 FUNCTIONNAL PROPERTY

Cette propriété est utilisé pour définir une propriété qui ne peut avoir qu'une seule valeur y pour chaque
instance x

OWL :


                                                   Page 39
<owl:ObjectProperty rdf:ID="Mari">

               <rdf:type   rdf:resource="&owl;FunctionalProperty" />

               <rdfs:domain rdf:resource="#Femme" />

               <rdfs:range rdf:resource="#Homme" />

</owl:ObjectProperty>

RDF :

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Mari">

        <rdfs:range rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Homme"/>

        <rdfs:domain rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Femme"/>

        <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#FunctionalProperty"/>

        <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty"/>

 </rdf:Description>

NOTATION TURTLE :

@prefix myonto=<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

@prefix owl=<"http://www.w3.org/2002/07/owl# "/>.

Myonto:Homme a owl:Class.

Myonto:Femme a owl:Class.

Myonto:mari a owl:FunctionnalProperty.

Myonto:mari a owl:ObjectProperty.

Rdfs:range:Myonto:Homme.

Rdfs:domain:Myonto:Femme.




                                               Page 40
GRAPHE :


  MyOnto :Mari                                 Rdfs :range
                                                                                MyOnto :Homme




                                         Rdfs :domain


  Rdf :type                                                                    MyOnto :Femme

                                 Rdf :type




                                                             Owl :FunctionnalProperty

Figure 24 Graphe Functional Property
  Owl :ObjectProperty




                                       INVERSE FUNCTIONNAL PROPERTY

Cette propriété indique que pour chaque objet de la propriété déclaré « Inverse Functionnal » on peut
associer un seul sujet Cette propriété se rapproche du concept de clé primaire utilisé dans les bases de
données

OWL :

<owl:InverseFunctionalProperty rdf:ID="aPourParent">

                  <rdfs:domain rdf:resource="#Femme"/>

                  <rdfs:range rdf:resource="#Humain"/>

</owl:InverseFunctionalProperty>

RDF :

rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#aPourParent">

  <rdfs:range rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Humain"/>

  <rdfs:domain rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Femme"/>

  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#InverseFunctionalProperty"/>

 </rdf:Description>



                                                    Page 41
  NOTATION TURTLE :

  @prefix Myonto=<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

  @prefix owl=<"http://www.w3.org/2002/07/owl# "/>.

  Myonto:Humain a owl:Class.

  Myonto:Femme a owl:Class.

  Myonto:aPourParent a InverseFunctionnalProperty.

  Rdfs:range:Myonto:Humain.

  Rdfs:domain:Myonto:Femme.




  GRAPHE :


                                                  Rdfs :range
                                                                                       MyOnto :Humain
    MyOnto :aPourParent




                                             Rdfs :domain
Rdf :type
                                                                                       MyOnto :Femme
                                Rdf :type




    Owl :ObjectProperty
                                                    Owl :InverseFunctionnalProperty




  Figure 25 Graphe Inverse Functionnal Property


                                                   OBJECT PROPERTY

  Cette propriété permet de relier des instances de classes à d’autres instances (Des objets)

  OWL :


                                                          Page 42
<owl:ObjectProperty rdf:ID="aPourPere">

    <rdfs:domain rdf:resource="#Humain"/>

    <rdfs:range rdf:resource="#Homme"/>

  </owl:ObjectProperty>




RDF :

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#aPourPere">

<rdfs:range rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Homme"/>

<rdfs:domain rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Humain"/>

<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty"/>

</rdf:Description>

NOTATION TURTLE :

@prefix myonto=<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

@prefix owl=<"http://www.w3.org/2002/07/owl# "/>.

Myonto:Homme a owl:Class.

Myonto:Humain a owl:Class.

Myonto:aPourPere a owl:ObjectProperty.

Rdfs:range:Myonto:Homme.

Rdfs:domain:Myonto:Humain.

GRAPHE :


                                     Rdfs :range
 MyOnto :aPourPere                                                        MyOnto :Homme




                                     Rdfs :domain
Rdf :type




                                                         MyOnto :Homme

 Owl :ObjectProperty




                                              Page 43
    Figure 26 Graphe Object Property




                                                     ONTOLOGY

    Cette propriété permet de définir l’en-tête de l’ontologie

    OWL :

    <owl:Ontology rdf:about="MyOnto">

    <rdfs:comment>c’est mon ontologie à laquelle il est possible d’appliquer des propriétés comme
    owl:incompatibleWith, owl:backwardCompatibleWith, owl:priorVersion ou encore
    owl:versionInfo</rdfs:comment>

    </owl:Ontology>

    RDF :

    <rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#MyOnto">

    <rdfs:comment> c’est mon ontologie à laquelle il est possible d’appliquer des propriétés comme
    owl:incompatibleWith, owl:backwardCompatibleWith, owl:priorVersion ou encore owl:versionInfo
    </rdfs:comment>

      <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Ontology"/>

     </rdf:Description>

    NOTATION TURTLE :

    @prefix myonto=<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

    @prefix owl=<"http://www.w3.org/2002/07/owl# "/>.

    Myonto a owl :Ontology.

    Rdfs :comment « c’est mon ontologie à laquelle il est possible d’appliquer des propriétés comme
    owl:incompatibleWith, owl:backwardCompatibleWith, owl:priorVersion ou encore owl:versionInfo » .

    GRAPHE :




                                                 Rdf :type
                                                                            Owl :Ontology
                 MyOnto




                            rdfs:comment


                                                Figure 27 Graphe Ontology
c’est mon ontologie à laquelle il est possible d’appliquer des
propriétés comme owl:incompatibleWith,                  Page 44
owl:backwardCompatibleWith, owl:priorVersion ou encore
owl:versionInfo
                                         ONTOLOGY PROPERTY

Cette propriété de versionning est utilisée entre autres pour réaliser des importations.

OWL :

<owl:OntologyProperty rdf:ID="MyOnto">

 <rdfs:label>Mon ontologie</rdfs:label>

</owl:OntologyProperty >

RDF :

<rdf:Property rdf:ID="MyOnto">

 <rdfs:label> Mon ontologie </rdfs:label>

 <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#OntologyProperty"/>

 <rdfs:domain rdf:resource="http://www.w3.org/2002/07/owl#Ontology"/>

 <rdfs:range rdf:resource="http://www.w3.org/2002/07/owl#Ontology"/>

</rdf:Property>

NOTATION N3 :

@prefix myonto=<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

@prefix owl=<"http://www.w3.org/2002/07/owl# "/>.

Myonto:monOntologie a owl:OntologieProperty.

Rdfs:range:owl:Ontology

Rdfs:domain:owl:Ontology

Rdfs:label “Mon ontology”




                                                   Page 45
                                                                    Rdf :type
                                                                                      Owl :OntologyProperty
                                      MyOnto

GRAPHE :



        Rdf :label                                                         Figure 28 Graphe Ontology Property



                                                                     Rdfs :domain
                              Rdfs :range

Mon ontologie
                                                                                      Owl :Ontology
                                    Owl :Ontology




                                          SYMMETRIC PROPERTY

Une propriété symétrique est telle que si le couple (x,y) est une instance de la propriété P, alors le couple
(y,x) est aussi une instance de P

OWL :

<owl:SymmetricProperty rdf:ID="Test3">

                <rdfs:domain rdf:resource="#Humain"/>

                <rdfs:range rdf:resource="#Humain"/>

</owl:SymmetricProperty>

RDF :

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Test3">

  <rdfs:range rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Humain"/>

  <rdfs:domain rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Humain"/>

  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#SymmetricProperty"/>

 </rdf:Description>

NOTATION TURTLE :

@prefix myonto=<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

@prefix owl=<"http://www.w3.org/2002/07/owl# "/>.



                                                    Page 46
Myonto:Humain a owl:Class.

Myonto:Test3 a owl:SymmetricProperty.

Rdfs:range:Myonto:Humain

Rdfs:domain:Myonto:Humain.

GRAPHE :

                                              Rdfs :range

 MyOnto :Test3
                                                                                  MyOnto :Humain


                                        Rdfs :domain


        Rdf :type


                                                                   Figure 29 Graphe Symmetric Property


                          Owl :SymmetricProperty




                                          TRANSITIVE PROPERTY

Lorsque l'on définit une propriété P comme étant transitive, cela signifie que si le couple (x,y) est une
instance de P et le couple (y,z) aussi, alors on peut inférer que le couple (x,z) est également une instance de P

OWL :

<owl:TransitiveProperty rdf:ID="Test2">

                    <rdfs:domain rdf:resource="#Pays"/>

                    <rdfs:range rdf:resource="#Pays"/>

</owl:TransitiveProperty>

RDF :

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Test2">

  <rdfs:range rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Pays"/>

  <rdfs:domain rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Pays"/>

  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#TransitiveProperty"/>

 </rdf:Description>

NOTATION TURTLE :



                                                   Page 47
@prefix myonto=<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

@prefix owl=<"http://www.w3.org/2002/07/owl# "/>.

Myonto:Pays a owl:Class.

Myonto:Test2 a owl:TransitiveProperty.

Rdfs:range:Myonto:Pays.

Rdfs:domain:Myonto:Pays.

GRAPHE :

                                           Rdfs :range


   MyOnto :Test2
                                                                                          MyOnto :Pays
                                         Rdfs :domain




   Rdf :type
                                                   Figure 30 Graphe Transitive Property




        Owl :TransitiveProperty




Les propriétés convertit par Jena sont maintenant présentés. Nous allons maintenant nous intéressé aux
propositions de traductions pour celles qui n’ont pas pu être traité par Jena.


3.2.4 PROPRIETES NON PRISES EN CHARGE PAR JENA

Nous allons dans cette partie essayé de proposer des traductions aux propriétés n’ayant pas reçu de
traductions de la part de Jena. Nous n’avons pas encore trouvé de solutions à chacune des propriétés car cela
s’est révélé être un travail de longue haleine. Nous continuerons donc ce travail avant de passer en phase de
développement.

                              ALL DIFFERENT : ET DISTINCTMEMBERS

Ces deux propriétés s’utilisant combiné permettent de définir une liste d’instances toutes différentes les unes
des autres

OWL :

<owl:AllDifferent>

 <owl:distinctMembers rdf:parseType="Collection">




                                                   Page 48
  <Opera rdf:about="#Don_Giovanni"/>

  <Opera rdf:about="#Nozze_di_Figaro"/>

  <Opera rdf:about="#Cosi_fan_tutte"/>

 </owl:distinctMembers>

</owl:AllDifferent>

RDF :

<rdf:Description>

   <MyOnto:opera rdf:parseType="Collection">

        <rdf:Description rdf:about=" http://www.owl-
ontologies.com/Ontology1223114912.owl#Don_Giovanni ">

         <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#distinctMembers"/>

         </rdf:Description>

      <rdf:Description rdf:about=" http://www.owl-
ontologies.com/Ontology1223114912.owl#Nozze_di_Figaro ">

         <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#distinctMembers"/>

        </rdf:Description>

      <rdf:Description rdf:about=" http://www.owl-
ontologies.com/Ontology1223114912.owl#Cosi_fan_tutte ">

         <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#distinctMembers"/>

        </rdf:Description>

   </ MyOnto:opera >

<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#AllDifferent"/>

</rdf:Description>

NOTATION N3 :

@prefix myonto="http://www.owl-ontologies.com/Ontology1223114912.owl# ">.

@prefix owl=<” http://www.w3.org/2002/07/owl#”>.

         Myonto:Cosi_fan_tutte a owl:DistinctMembers.

         Myonto:Nozze_di_figaro a owl:DistinctMembers.


                                                Page 49
            Myonto:Don_Giovanni a owl:DistinctMembers.

            MyOnto:Opera a owl:AllDifferent.




    GRAPHE :


                                               Rdf :type
                                                                Owl :AllDifferent
       MyOnto : Opera




               Rdf :description



                     Rdf :first
                                  MyOnto : Don_Giovanni                       Owl :distinctMenbers

                                                            Rdf :type


Rdf :rest


                    Rdf :first
                                  MyOnto :Nozze_di_Figaro                    Owl :distinctMenbers

                                                             Rdf :type

Rdf :rest

                  Rdf :first
                                  MyOnto :Cosi_fan_tutte                     Owl :distinctMenbers
                                                 Page 50
                                                                            Rdf :type


Rdf :rest



            Rdf :nil




      Figure 31 Graphe All Different et Distinct menbers




                                                           DIFFERENT FROM

      Cette propriété permet de relier deux instances et de spécifier quelles sont différentes l’une de l’autre

      OWL :

      <Opera rdf:ID="Don_Giovanni"/>

      <Opera rdf:ID="Nozze_di_Figaro">

       <owl:differentFrom rdf:resource="#Don_Giovanni"/>

      </Opera>

      <Opera rdf:ID="Cosi_fan_tutte">

       <owl:differentFrom rdf:resource="#Don_Giovanni"/>

       <owl:differentFrom rdf:resource="#Nozze_di_Figaro"/>

      </Opera>

      RDF :

              <rdf:Description rdf:about=" http://www.owl-ontologies.com/Ontology1223114912.owl
      # Cosi_fan_tutte "

                 <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DifferentFrom"/>

             <rdf:Description rdf:about=" http://www.owl-ontologies.com/Ontology1223114912.owl
      # Nozze_di_Figaro "

                 <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DifferentFrom"/>

            <rdf:Description rdf:about=" http://www.owl-ontologies.com/Ontology1223114912.owl
      # Don_Giovanni "

                 </rdf:Description>

      </rdf:Description>


                                                               Page 51
</rdf:Description>

NOTATION N3 :

@prefix myonto="http://www.owl-ontologies.com/Ontology1223114912.owl# ">.

@prefix owl=<” http://www.w3.org/2002/07/owl#”>.

        Myonto:Cosi_fan_tutte a owl:DifferentFrom

        Myonto:Nozze_di_figaro a owl:DifferentFrom.

        Myonto:Don_Giovanni a owl:DifferentFrom.

        .




GRAPHE :




                                       MyOnto :Cosi_fan_tutte                Rdf :type



                                                                                         Owl :DifferentFrom
                  Rdf :Description

                                               Rdf :type
                                                                                           Rdf :type


            MyOnto : NozeediFigarro                                        MyOnto : Don Giovanni

                                           Rdf :Description




                                        Figure 32 Graphe Different From


                                              CARDINALITY

Cette propriété permet de relier une classe déclaré par restriction à une valeur appartenant à l’espace de
valeurs du type nonNegativeInteger du schéma XML. Une restriction avec une contrainte de cardinalité
décrit la classe de touts les individus ayant exactement N valeurs distinctes où N est la valeur de contrainte
de cardinalité

OWL :

<owl:Restriction>

<owl:onProperty rdf:resource=" http://www.owl-ontologies.com/Ontology1223114912.owl#hasParent " />

                                                   Page 52
 <owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">2</owl:cardinality>

</owl:Restriction>

RDF :

<rdf:Description rdf:nodeID=”A1”>

        <rdf:Description rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#hasParent">

        <rdf : type rdf : resource= " http://www.w3.org/2002/07/owl#OnProperty "/>

        </rdf:description>



    <rdf:Description rdf:datatype=" http://www.w3.org/2001/XMLSchema# nonNegativeInteger " >2</>

        <rdf : type rdf : resource= " http://www.w3.org/2002/07/owl#Cardinality "/>

     </rdf:Description>

<rdf:type rdf:resource =" http://www.w3.org/2002/07/owl#Restriction"/>

</rdf:Description>

NOTATION TURTLE :

@prefix myonto="http://www.owl-ontologies.com/Ontology1223114912.owl# ">.

@prefix owl=<” http://www.w3.org/2002/07/owl#”>.

        Myonto:humain a owl:Class.

        Myonto:hasParents a owl:DatatypeProperty.

        Rdfs:range:2.

        Rdfs:domain: Myonto:humain.




                                                                               Owl :Restriction


                                                           Rdf :type

GRAPHE :



                                            A1


                Rdf :description                                       Rdf :description



   Xsd :nonNegativeInteger                       Page 53                   MyOnto :hasParent
                                       Rdf :type

                                                                                              Rdf :type

                                                Owl :Cardinality
               2

                                                                                          Owl :OnProperty
                                       Figure 33 Graphe Cardinality


                                                DISJOINT WITH

Cette propriété est utilisée lors des déclarations de classes. Elle spécifie que les deux classes concernées n’ont
aucun individu en commun

OWL :

<owl:Class rdf:about="#Man">

 <owl:disjointWith rdf:resource="#Woman"/>

</owl:Class>

RDF :

<rdfs:Class rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl# Man ">

        <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#disjoinWith"/>

        <rdf:Description rdf:resource=" http://www.owl-
ontologies.com/Ontology1223114912.owl#Woman"/>

 </rdfs:Class>

NOTATION TURTLE :

@prefix myonto =<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

@prefix owl =<”http://www.w3.org/2002/07/owl#”>.

Myonto:Man a owl:Class.

Myonto:Man dijoinWith

Myonto:Woman a owl:Class.
                                                                MyOnto :Woman

GRAPHE :
                        Rdf:Description


                                            Rdf :Type
                                                                               Owl :disjoinWith
     MyOnto :Man
                                                      Page 54
                                   Figure 34 Graphe Disjoint with




                                      EQUIVALENT PROPERTY

Cette propriété sert à spécifier que deux propriétés ont la même extension de propriété. L'équivalence de
propriété n'est pas la même chose que l'égalité de propriété. Les propriétés équivalentes ont les mêmes
valeurs (c'est-à-dire, la même extension de propriété), mais elles peuvent avoir des significations
intensionnelles différentes (c'est-à-dire représenter des concepts différents)

OWL :

<owl:ObjectProperty rdf:ID="EstMort">

               <owl:equivalentProperty rdf:resource="#estAmiDe"/>

</owl:ObjectProperty>

RDF :

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl# EstMort ">

        <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#equivalentProperty"/>

        <rdf:description rdf:resource="#estAmiDe"/>

        <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty"/>

 </rdf:Description>

NOTATION TURTLE :

@prefix myonto =<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

@prefix owl =<”http://www.w3.org/2002/07/owl#”>.

Myonto:EstMort a owl:equivalentProperty.

Myonto:EstMort a owl:ObjectPoperty.

GRAPHE :



                                      rdf :Description
   MyOnto : EstMort
                                                                                MyOnto : EstAmiDe


                                         Rdf :type
            Rdf :type



                                                                    Owl :EquivalentProperty
                                                  Page 55
  Owl :ObjectProperty




                                     Figure 35 Graphe Equivalent property




                                   MECANISME D’INSTANCIATION

Cette traduction n’est pas une propriété définit dans le langage OWL. Mais il est important de voir comment
traduire le mécanisme d’instanciation pour réaliser notre convertisseur car cela fait partie intégrante du
langage

OWL :

<Femme rdf:ID="Marie">

    <nomDeJeuneFille rdf:datatype="&xsd;string">Martin</nomDeJeuneFille>

    <dateDeNaissance rdf:datatype="&xsd;date">2008-10-15</dateDeNaissance>

    <prenom rdf:datatype="&xsd;string">Marie</prenom>

        <habiteA rdf:resource="#Paris"/>

  </Femme>




RDF :

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#prenom">

  <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>

  <rdfs:domain rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Humain"/>

  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DatatypeProperty"/>

 </rdf:Description>

 <rdf:Description rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#dateDeNaissance">

  <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#date"/>

  <rdfs:domain rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Humain"/>

  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DatatypeProperty"/>

 </rdf:Description>

 <rdf:Description rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#nomDeJeuneFille">



                                                   Page 56
  <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>

  <rdfs:domain rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Femme"/>

  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DatatypeProperty"/>

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#habiteA">

  <rdfs:range rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Ville"/>

  <rdfs:domain rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Humain"/>

  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty"/>

 </rdf:Description>

 </rdf:Description>

 <rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Marie">

  <habiteA rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Paris"/>

  <prenom rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Marie</prenom>

  <dateDeNaissance rdf:datatype="http://www.w3.org/2001/XMLSchema#date">2008-10-
15</dateDeNaissance>

  <nomDeJeuneFille
rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Martin</nomDeJeuneFille>

  <rdf:type rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Femme"/>

</rdf:Description>

Graphe :




                                                                  MyOnto : Femme
                                    Rdf :type



           MyOnto : Marie
                                                MyOnto :nomDeJeuneFille


                                                                                   Xsd :string




 MyOnto :habiteA                             MyOnto :dateDeNaissance


                                                                                      Martin
                            MyOnto :prenom




 MyOnto : Paris
                                                Page 57
                                                                                       Xsd :date


                                     Xsd :string




                                                                                       2008-10-15
                                       Marie




                                          COMPLEMENT OF

Une déclaration owl:complementOf décrit la classe contenant exactement les individus n'appartenant pas à
la description de classe faisant l'objet de la déclaration

OWL :
<owl:Class>
  <owl:complementOf>
    <owl:Class rdf:about="#Viande"/>
  </owl:complementOf>
</owl:Class>


RDF :

<rdf:description rdf:NodeID=”A1”

      <rdfs:description rdf:about=http://www.owl-
ontologies.com/Ontology1223114912.owl#Viande/>
     <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#complementOf"/>
</rdf:description>




                                                   Page 58
NOTATION TURTLE :



@prefix myonto =<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

@prefix owl =<”http://www.w3.org/2002/07/owl#”>.

Myonto:A1 a owl:complementOf.

Myonto:Viande a owl:Class




GRAPHE :




                                 Rdf :type
           A1                                             Owl :complementOf



                            Rdf :description



                                       MyOnto :Viande




                                               HASVALUE



OWL :

<owl:Restriction>
  <owl:onProperty rdf:resource="#aPourParent" />
  <owl:hasValue rdf:resource="#Clinton" />
</owl:Restriction>



                                                Page 59
RDF :


<rdf:Description rdf:nodeID=”A1”>

        <rdf:Description rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#hasParent">

        <rdf : type rdf : resource= " http://www.w3.org/2002/07/owl#OnProperty "/>

        </rdf:description>

    <rdf:Description rdf:about=" http://www.owl-ontologies.com/Ontology1223114912.owl#Clinton" >

        <rdf : type rdf : resource= " http://www.w3.org/2002/07/owl#hasValue "/>

     </rdf:Description>

<rdf:type rdf:resource =" http://www.w3.org/2002/07/owl#Restriction"/>

</rdf:Description>




NOTATION TURTLE :

@prefix myonto =<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

@prefix owl =<”http://www.w3.org/2002/07/owl#”>.

A1 a owl:restriction.

Myonto:hasParents a owl:OnProperty

Myonto:Clinton a owl:hasValue.




                                              Page 60
                                         Rdf :type

            A1                                                  Owl :Restriction




                                            Rdf :Description




                                                                MyOnto : HasParent
                                     Rdf :Description

                                                                                     Rdf :type


                                                                                             Owl :OnProperty



                                              MyOnto :Clinton
                             Rdf :type

 Owl :hasValue




                                         MAXCARDINALITY



OWL :
<owl:Restriction>
  <owl:onProperty rdf:resource=" http://www.owl-
ontologies.com/Ontology1223114912.owl#hasParent " />
  <owl:maxCardinality
rdf:datatype="&xsd;nonNegativeInteger">2</owl:maxCardinality>
</owl:Restriction>

RDF :

<rdf:Description rdf:nodeID=”A1”>

        <rdf:Description rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#hasParent">

        <rdf : type rdf : resource= " http://www.w3.org/2002/07/owl#OnProperty "/>

        </rdf:description>




                                                Page 61
        <rdf:Description rdf:datatype=" http://www.w3.org/2001/XMLSchema# nonNegativeInteger "
>2</>

        <rdf : type rdf : resource= " http://www.w3.org/2002/07/owl#MaxCardinality "/>

     </rdf:Description>

<rdf:type rdf:resource =" http://www.w3.org/2002/07/owl#Restriction"/>

</rdf:Description>




NOTATION TURTLE :

@prefix myonto =<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

@prefix owl =<”http://www.w3.org/2002/07/owl#”>.

@prefix Xml==<" http://www.w3.org/2001/XMLSchema# ">

A1 a owl:restriction

Myonto:hasParents a owl:OnProperty.

Xml: nonNegativeInteger<2> a owl:MaxCardinality




                                           Rdf :type
              A1                                                      Owl :Restriction




                 Rdf :description       Rdf:description




  Xsd : nonNegativeInteger
                                                          MyOnto : hasParent


                                    Rdf :type
                                                                                         Rdf :type



                                      Owl :MaxCardinality
                                                Page 62
              2                                                                      Owl :OnProperty




                                        MINCARDINALITY



OWL :
<owl:Restriction>
  <owl:onProperty rdf:resource=" http://www.owl-
ontologies.com/Ontology1223114912.owl#hasParent " />
  <owl:minCardinality
rdf:datatype="&xsd;nonNegativeInteger">2</owl:minCardinality>
</owl:Restriction>




RDF :


<rdf:Description rdf:nodeID=”A1”>

        <rdf:Description rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#hasParent">

        <rdf : type rdf : resource= " http://www.w3.org/2002/07/owl#OnProperty "/>

        </rdf:description>

        <rdf:Description rdf:datatype=" http://www.w3.org/2001/XMLSchema# nonNegativeInteger "
>2</>

        <rdf : type rdf : resource= " http://www.w3.org/2002/07/owl#MinCardinality "/>

     </rdf:Description>

<rdf:type rdf:resource =" http://www.w3.org/2002/07/owl#Restriction"/>

</rdf:Description>

NOTATION TURTLE :

@prefix myonto =<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

@prefix owl =<”http://www.w3.org/2002/07/owl#”>.

@prefix Xml==<" http://www.w3.org/2001/XMLSchema# ">

A1 a owl:restriction

Myonto:hasParents a owl:OnProperty.



                                              Page 63
Xml: nonNegativeInteger<2> a owl:MinCardinality




                                           Rdf :type
             A1                                                       Owl :Restriction




                 Rdf :description       Rdf:description




  Xsd : nonNegativeInteger
                                                          MyOnto : hasParent


                                    Rdf :type
                                                                                         Rdf :type



                                     Owl :MinCardinality

             2                                                                            Owl :OnProperty




                                      INTERSECTIONOF ET ONEOF


OWL :

<owl:Class>
  <owl:intersectionOf rdf:parseType="Collection">
    <owl:Class>
      <owl:oneOf rdf:parseType="Collection">
        <owl:Thing rdf:about="#Tosca" />
        <owl:Thing rdf:about="#Salome" />
      </owl:oneOf>
    </owl:Class>
    <owl:Class>
      <owl:oneOf rdf:parseType="Collection">
        <owl:Thing rdf:about="#Turandot" />
        <owl:Thing rdf:about="#Tosca" />
      </owl:oneOf>
    </owl:Class>
  </owl:intersectionOf>
</owl:Class>


                                                Page 64
RDF :

<rdfs:Class>
    <rdf:Description rdf:parseType="Collection">
        <rdfs:Class>
            <o:opera rdf:parseType="Collection">
              <rdf:Description rdf:about="http://example.org/opera/#Tosca ">
                 <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
             </rdf:Description>

               <rdf:Description rdf:about="http://example.org/opera/#Salome">
                   <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
               </rdf:Description>

             <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#oneOf"/>
             </o:opera >
         </rdfs:Class>
         <rdfs:Class>
             <o:opera rdf:parseType="Collection">
             <rdf:Description rdf:about="http://example.org/opera/#Turando">
                 <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
             </rdf:Description>

               <rdf:Description rdf:about="http://example.org/opera/#Tosca">
                   <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
               </rdf:Description>

             <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#oneOf"/>
             </o:opera >
         </rdfs:Class>

    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#intersectionOf"/>
   </rdf:Description>
</rdfs:Class>




Notation turtle
@prefix myonto =<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

@prefix owl =<”http://www.w3.org/2002/07/owl#”>.

@prefix Opera=<" ="http://example.org/opera#">

Myonto:Opera a owl:one of.

Myonto:Opera a owl:IntersectionOf.

Opera:Tosca a owl:Thing.

Opera:Salome a owl:Thing.

Opera:Turando a owl:Thing.




                                             Page 65
             Owl :oneOf                                                                                       Owl :oneOf




                                                        Owl :intersectionOf
                                                                                       Rdf :type
                                           Rdf :type

                     MyOnto : Opera
                                                                                           MyOnto : Opera
                                                                                           MyOnto : Opera




                   Rdf :first                   Rdf :type
                                                                                      Rdf :type                   Rdf :first
                                MyOnto :Tosca          Owl :Thing
                                                                         Owl :Thing
                                                                                                  MyOnto :Tosca


 Rdf :rest
                                                                                                                        Rdf :rest
                   Rdf :first              Rdf :type
                            MyOnto :Salome                                            Rdf :type               Rdf :first
                                                   Owl :Thing         Owl :Thing              MyOnto :Turando



Rdf :rest
                                                                                                                       Rdf :rest



        Rdf :nil                                                                                                        Rdf :nil




                                                               Page 66
                                    UNIONOF


OWL :

<owl:Class>
  <owl:unionOf rdf:parseType="Collection">
    <owl:Class>
      <owl:oneOf rdf:parseType="Collection">
        <owl:Thing rdf:about="#Tosca" />
        <owl:Thing rdf:about="#Salome" />
      </owl:oneOf>
    </owl:Class>
    <owl:Class>
      <owl:oneOf rdf:parseType="Collection">
        <owl:Thing rdf:about="#Turandot" />
        <owl:Thing rdf:about="#Tosca" />
      </owl:oneOf>
    </owl:Class>
  </owl:unionOf>
</owl:Class>

RDF :

<rdfs:Class>
    <rdf:Description rdf:parseType="Collection">
        <rdfs:Class>
            <o:opera rdf:parseType="Collection">
              <rdf:Description rdf:about="http://example.org/opera/#Tosca ">
                 <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
             </rdf:Description>

            <rdf:Description rdf:about="http://example.org/opera/#Salome">
                <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
            </rdf:Description>

            <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#oneOf"/>
            </o:opera >
        </rdfs:Class>
        <rdfs:Class>
            <o:opera rdf:parseType="Collection">
            <rdf:Description rdf:about="http://example.org/opera/#Turando">
                <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
            </rdf:Description>

            <rdf:Description rdf:about="http://example.org/opera/#Tosca">
                <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
            </rdf:Description>

            <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#oneOf"/>
            </o:opera >
        </rdfs:Class>

    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#unionOf"/>
   </rdf:Description>


                                     Page 67
            </rdfs:Class>

            Notation Turtle

            @prefix myonto =<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

            @prefix owl =<”http://www.w3.org/2002/07/owl#”>.

            @prefix Opera=<" ="http://example.org/opera#">

            Myonto:Opera a owl:one of.

            Myonto:Opera a owl:UnionOf.

            Opera:Tosca a owl:Thing.

            Opera:Salome a owl:Thing.

            Opera:Turando a owl:Thing.




            Owl :oneOf                                                                                     Owl :oneOf




                                                        Owl :unionOf
                                                                                      Rdf :type
                                           Rdf :type

                     MyOnto : Opera
                                                                                          MyOnto : Opera
                                                                                          MyOnto : Opera




                   Rdf :first                   Rdf :type                        Rdf :type
                                                                                                              Rdf :first
                                MyOnto :Tosca          Owl :Thing
                                                                        Owl :Thing           MyOnto :Tosca


Rdf :rest
                                                                                                                    Rdf :rest
                   Rdf :first              Rdf :type
                            MyOnto :Salome                                           Rdf :type               Rdf :first
                                                   Owl :Thing          Owl :Thing            MyOnto :Turando
                                                              Page 68
Rdf :rest
                                                                                                      Rdf :rest



        Rdf :nil                                                                                       Rdf :nil




                                          SOMEVALUESFROM ET ONPROPERTY

            OWL :

            <owl:Restriction>
              <owl:onProperty rdf:resource="#aPourParent" />
              <owl:someValuesFrom rdf:resource="#Médecin" />
            </owl:Restriction>

            RDF :


            <rdf:Description rdf:nodeID=”A1”>

                    <rdf:Description rdf:about="http://www.owl-
            ontologies.com/Ontology1223114912.owl#hasParent">

                     <rdf : type rdf : resource= " http://www.w3.org/2002/07/owl#OnProperty "/>

                     </rdf:description>

                    <rdf:Description rdf:about=" http://www.owl-
            ontologies.com/Ontology1223114912.owl#Medecin">

                     <rdf : type rdf : resource= " http://www.w3.org/2002/07/owl#someValuesFrom "/>

                   </rdf:Description>

            <rdf:type rdf:resource =" http://www.w3.org/2002/07/owl#Restriction"/>

            </rdf:Description>




                                                           Page 69
  Notation Turtle

  @prefix myonto =<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

  @prefix owl =<”http://www.w3.org/2002/07/owl#”>.

  A1 a Owl:Restriction.

  MyOnto:hasParents a owl:OnProperty.

  MyOnto:Medecin a owl somValuesFrom.




                                    Rdf : description        MyOnto : Medecin



                A1


                                                                         Rdf :type




Rdf : type
                                                                someValuesFrom




      Owl :Restriction




                                                 SAMEAS



  OWL :

  <rdf:Description rdf:about="#William_Jefferson_Clinton">
    <owl:sameAs rdf:resource="#BillClinton"/>
  </rdf:Description>

  RDF :


  <rdf:description rdf:about="http://www.owl-
  ontologies.com/Ontology1223114912.owl#William_Jefferson_Clinton">

             <rdf:type rdf:resource=" http://www.w3.org/2002/07/owl#sameAs "/>

          <rdf:Description rdf:resource=" http://www.owl-
  ontologies.com/Ontology1223114912.owl#BillClinton "/>



                                                 Page 70
       </rdfs:Class>

      Notation Turtle

      @prefix myonto =<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

      @prefix owl =<”http://www.w3.org/2002/07/owl#”>.

      MyOnto William_jefferson_Clinton a owl:sameAs

      MyOnto Bill Clinton.




                                        Rdf :description
MyOnto :William_Jefferson_Clinton
                                                                MyOnto :Bill Clinton




           Rdf :type




          Owl :sameAs




                                            EQUIVALENTCLASS


      OWL :

      <owl:Class rdf:about="#PrésidentDesÉtatsUnis">
        <equivalentClass rdf:resource="#RésidentPrincipalDeLaMaisonBlanche"/>
      </owl:Class>

      RDF :



                                                      Page 71
      <rdf:description rdf:about=" http://www.owl-
      ontologies.com/Ontology1223114912.owl#PrésidentDesÉtatsUnis ">

             <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#equivalentClass "/>

             <rdf:type rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/>

              <rdf:Description rdf:resource=" http://www.owl-
      ontologies.com/Ontology1223114912.owl#RésidentPrincipalDeLaMaisonBlanche "/>

       </rdfs:Class>




      Notation Turtle



      @prefix myonto =<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

      @prefix owl =<”http://www.w3.org/2002/07/owl#”>.

      MyOnto:PresidentDesEtatsUnis Rdfs:Class

      Myonto ResidentPrincipalDeLaMaisonBlanche a Rdfs:Class

      MyOnto:PresidentDesEtatsUnis Owl:EquivalentClass




                                 Rdf :description
MyOnto : PrésidentDesÉtatsUnis                      MyOnto : RésidentPrincipalDeLaMaisonBlanche




                 Rdf :type
                                    Rdf :type




         Rdfs :Class                        Owl :EquivalentClass




                                                    Page 72
                                         ALLVALUESFROM


OWL :
<owl:Restriction>
  <owl:onProperty rdf:resource="#aPourParent" />
  <owl:allValuesFrom rdf:resource="#Humain" />
</owl:Restriction>

RDF :


<rdf:Description rdf:nodeID=”A1”>

        <rdf:Description rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#hasParent">

        <rdf : type rdf : resource= " http://www.w3.org/2002/07/owl#OnProperty "/>

        </rdf:description>

        <rdf:Description rdf:about=" http://www.owl-
ontologies.com/Ontology1223114912.owl#Humain">

        <rdf : type rdf : resource= " http://www.w3.org/2002/07/owl#allValuesFrom "/>

     </rdf:Description>

<rdf:type rdf:resource =" http://www.w3.org/2002/07/owl#Restriction"/>

</rdf:Description>




Notation Turtle



@prefix myonto =<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

@prefix owl =<”http://www.w3.org/2002/07/owl#”>.

A1 a Owl:Restriction

MyOnto:hasParents Owl:OnProperty

Myonto :Humain a Owl:AllValuesFrom




                                               Page 73
                        Rdf : description                        Rdf : type       Owl :onProperty
         A1                                 MyOnto : HasParent




                                                     Rdf :type
                            MyOnto : Humain
                                                                  allValuesFrom




                                             INVERSEOF

OWL :

<owl:ObjectProperty rdf:ID="aPourEnfant">
  <owl:inverseOf rdf:resource="#aPourParent"/>
</owl:ObjectProperty>

RDF :

<rdf:Description rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#aPourEnfant">

      <rdf:type rdf :
resource= " http://www.w3.org/2002/07/owl#ObjectProperty "/>

        <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#inverseOf"/>

      <rdf:Description rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#aPourParent">

</rdf:Description>


NotationTurtle



@prefix myonto =<"http://www.owl-ontologies.com/Ontology1223114912.owl#>.

@prefix owl =<”http://www.w3.org/2002/07/owl#”>.



                                                Page 74
  MyOnto:aPourEnfant a owl:ObjectProperty

  MyOnto:aPourEnfant a owl:InverseOf

  Myonto: aPourParent a owl:ObjectProperty




                         Rdf :description

  MyOnto : aPourEnfant                      MyOnto : aPourParent




                                    Rdf :type
             Rdf :type




Owl :ObjectProperty                             Owl :inverseOf




  Voila qui termine l’étude du passage de RDF/RDFS vers OWL. Nous avons pu apporter des solutions à une
  bonne partie des traductions non existantes dans l’API Jena. Cela nous permettra un gain de temps précieux
  lors de l’implémentation.


  3.3 ETUDE DE L’EXISTANT

  Avant de commencer tout action de développement il est impératif d’étudier les solutions existantes ou se
  rapprochant des besoins énoncés. « Réinventer la roue » est quelque chose de catastrophique en terme
  d’investissement aussi bien au niveau du temps que de l’argent. Même si nous ne sommes pas soumis à la
  contrainte économique lors de notre projet, il est tout de même important de réaliser une recherche de
  solutions approfondi. Nous avons découpé cette étude en trois parties. Tout d’abord nous réaliserons une
  étude des API Java traitant la sémantique. Ensuite nous étudierons un convertisseur sémantique réalisé par
  Michel Klein issu d’internet. Enfin nous conclurons sur les choix que nous avons effectués quant au choix de




                                                     Page 75
la technologie à employer. Lors des différentes études de capacité de conversion nous utiliserons un
document OWL de notre invention contenant toutes les propriétés de ce langage.


3.3.1 PRESENTATION ET COMPARATIF DES API JAVA JENA ET SESAME

                                                 API JENA

L’API Jena est utilisé dans de nombreuses applications utilisant la sémantique (70 % des applications
sémantiques utilise Jena) notamment dans le logiciel Protégé. C’est un outil performant supportant le
langage RDF et permettant la gestion des ontologies OWL. De plus cet outil est doté d’un langage de requête
sur des graphes : RDQL . Jena permet également l’utilisation de raisonneur.

Afin de faire le test de conversion, nous avons codé le petit programme Java suivant :

import jena.*;

import com.hp.hpl.jena.ontology.OntModel;

import com.hp.hpl.jena.rdf.model.Model;

import com.hp.hpl.jena.rdf.model.ModelFactory;

import com.hp.hpl.jena.rdf.model.Resource;

import com.hp.hpl.jena.ontology.OntClass;

import java.io.InputStream;

import com.hp.hpl.jena.util.FileManager;

import java.io.OutputStream;

public class test {

  public test() {

  }

  public static void main(String[] args) {

      test test = new test();

OntModel model = ModelFactory.createOntologyModel();

model.read("http://www.sp-marcigny.fr/PartageProjet/test.owl");



model.write(System.out);

  }

Dans ce programme on créé tout d’abord un OntModel (Ontologie) à partir du fichier OWL (méthode
model.read) Ensuite on écrit dans la console la traduction de ce dernier, Jena effectuant implicitement la
conversion vers RDF/RDFS. Après étude de la console, on constate que plusieurs balises OWL n’ont pas été
traduites. Afin de mieux cerner les réelles capacités de Jena, nous réalisons un tableau récapitulatif de ces
possibilités en termes de traductions.


                                                  Page 76
-Toutes les propriétés OWL Lite sont en vert.

-Toutes les propriétés de OWL DL sont en bleu et s’ajoutent ou sont une extension (bleu-vert) de OWL Lite
(vert) à l’exception des propriétés en rouge qui sont interdite par OWL DL.

-Toutes les propriétés sont incluses dans OWL Full.


        Terme de vocabulaire                                   Pris en charge par Jena



                                      Propriétés relatives aux classes

        owl:equivalentClass                                              non

          owl:disjointWith                                               non

              owl:Class                                                  oui

             owl:oneOf                                                   non

         owl:complementOf                                                non

         owl:intersectionOf                                              non

            owl:unionOf                                                  non

            owl:Nothing                                                  oui

              owl:Thing                                                  oui

                                    Propriétés relatives au versionning

   owl:backwardCompatibleWith                                            non

       owl:incompatibleWith                                              non

          owl:priorVersion                                               non

             owl:imports                                                 non

        owl:DeprecatedClass                                              oui

      owl:DeprecatedProperty                                             oui

            owl:Ontology                                                 oui

       owl:OntologyProperty                                              oui

           owl:versionInfo                                               non

                                    Propriétés relatives aux restrictions


                                                 Page 77
          Terme de vocabulaire                                  Pris en charge par Jena


             owl:onProperty                                                 non

              owl:hasValue                                                  non

           owl:allValuesFrom                                                non

         owl:someValuesFrom                                                 non

             owl:cardinality                                                non

          owl:minCardinality                                                non

          owl:maxCardinality                                                non

             owl:Restriction                                                non

                          Propriétés relatives aux Object property et Datatype Property

        owl:FunctionalProperty                                              oui

   owl:InverseFunctionalProperty                                            oui

        owl:TransitiveProperty                                              oui

       owl:SymmetricProperty                                                oui

        owl:equivalentProperty                                              non

       owl:AnnotationProperty                                               oui

             owl:DataRange                                                  oui

         owl:DatatypeProperty                                               oui

          owl:ObjectProperty                                                oui

              owl:inverseOf                                                 non

                                       Propriétés relatives aux instances

           owl:differentFrom                                                non

               owl:sameAs                                                   non

         owl:distinctMembers                                                non
Figure 36 Tableau de conversion Jena


                                                API SESAME




                                                   Page 78
Cette API java est utilisé pour créer, stocké, et utilisé des fichiers au format RDF et RDFS, il est ensuite
possible de les utiliser pour faire des raisonnements et des requêtes. Il peut être utilisé comme une base de
donné RDF et RDFS .Sésame peut être utilisé comme un serveur avec des applications clients. Un concept
important dans sésame est celui de « repository » cela représente un espace de stockage pour du RDF
comme un objet java en mémoire ou une base de données. Cette notion est importante car chaque opération
s’effectue dans ou avec un « repository », quand il faut ajouter une données RDF il faut le faire a l’intérieur
d’un « repository », de même pour une requête, elle s’effectue sur un « repository » donné. Sésame possède
aussi le moyen de faire des raisonnements par inférence(RDF Schema inferencing) a partir donc des formats
RDF et RDFS, ainsi il est possible de trouvé des donné implicitement en ajoutant toute les informations
nécessaire au « repository » auquel on veut récupéré l’inférence .Ainsi sésame ne manipule pas le format
OWL , et n’effectue aucune traduction entre le format OWL et le format RDF. Il n’est donc a première vue
pas envisageable de l’utilisé dans le cadre de notre projet.


3.3.2 PRESENTATION DU CONVERTISSEUR DE MICHEL KLEIN

Dans le but de tester une nouvelle conversion de la syntaxe OWL vers RDF(S), nous somme allez sur la page
web du convertisseur créé par Michel Klein, auteur du livre : « Change Management For Distribuate
Ontologie ». La page web se présente sous la forme d’un convertisseur « classique » :




                                                                     Il est donc simple à première vue, de
                                                                     transcrire une page OWL en un
                                                                     document RDF il suffit juste de charger le
                                                                     fichier OWL présent sur la machine ou
                                                                     d’en fournir L’URL. Ainsi, après avoir
                                                                     cliqué sur Submit, on obtient une
                                                                     nouvelle page : la page RDF « traduite ».




Figure 37 Capture d’écran du convertisseur de Michel Klein 1




                                                                     Après étude du document fournit, on se
                                                                     rend compte que tout n’est pas traduit en
                                                                     syntaxe RDF et que quelques balises
                                                                     OWL persistent. Il est donc important de
                                                                     mettre en place un tableau permettant de
                                                                     déterminer ce qui a été traduit par le
                                                                     convertisseur de Michel Klein et ce qui
                                                                     ne l’a pas été.




                                                           Page 79
Figure 38 Capture d’écran du convertisseur de Michel Klein 2

De même que pour le tableau comparatif de l’API JENA, on met en place une légende à notre tableau :

-Toutes les propriétés OWL Lite sont en vert.

-Toutes les propriétés de OWL DL sont en bleu et s’ajoutent ou sont une extension (bleu-vert) de OWL Lite
(vert) à l’exception des propriétés en rouge qui sont interdite par OWL DL.

-Toutes les propriétés sont incluses dans OWL Full.


          Terme de vocabulaire                                        Pris en charge par Jena



                                              Propriétés relatives aux classes

          owl:equivalentClass                                                    non

            owl:disjointWith                                                     non

                 owl:Class                                                       oui

                owl:oneOf                                                        non

           owl:complementOf                                                      non

           owl:intersectionOf                                                    non

               owl:unionOf                                                       non

               owl:Nothing

                owl:Thing

                                            Propriétés relatives au versionning

   owl:backwardCompatibleWith                                                    non

         owl:incompatibleWith                                                    non

            owl:priorVersion                                                     non

               owl:imports                                                       non

         owl:DeprecatedClass                                                     oui

       owl:DeprecatedProperty                                                    oui

              owl:Ontology                                                       oui

         owl:OntologyProperty                                                    oui



                                                           Page 80
     Terme de vocabulaire                                 Pris en charge par Jena


       owl:versionInfo                                                non

                                Propriétés relatives aux restrictions

       owl:onProperty                                                 non

        owl:hasValue                                                  non

     owl:allValuesFrom                                                non

    owl:someValuesFrom                                                non

       owl:cardinality                                                non

     owl:minCardinality                                               non

     owl:maxCardinality                                               non

       owl:Restriction                                                non

                 Propriétés relatives aux Object property et Datatype Property

   owl:FunctionalProperty                                             oui

owl:InverseFunctionalProperty                                         oui

   owl:TransitiveProperty                                             oui

   owl:SymmetricProperty                                              oui

   owl:equivalentProperty                                             non

   owl:AnnotationProperty                                             oui

       owl:DataRange                                                  oui

    owl:DatatypeProperty                                              oui

     owl:ObjectProperty                                               oui

       owl:inverseOf                                                  non

                                 Propriétés relatives aux instances

     owl:differentFrom                                                non

        owl:sameAs                                                    non

    owl:distinctMembers                                               non


                                            Page 81
Figure 39 Tableau de conversion du convertisseur de Michel Klein

On constate que le convertisseur traduit à peine la moitié de la syntaxe OWL, cependant on obtient un code
RDF intuitif avec l’absence des espaces de noms remplacé par les valeur des sujets et objets utilisé par les
propriétés. Les propriétés sont elles bien délimité et clairement exprimé : notamment avec la balise rdf :
property qui désigne le fait d’avoir à faire à une propriété et qui est juste suivi de rdf :ID comprenant le nom
de la propriété. Ensuite, arrive le rdfs :domain et rdfs :range : sujet et objet de la propriété.

Nous avons terminé la présentation des différentes solutions existantes, nous pouvons désormais faire notre
choix en connaissance de cause.


3.3.3 CHOIX RESULTANT DE L’ETUDE DE L’EXISTANT

Tout d’abord nous utiliserons le logiciel Protégé lors de notre projet, en effet sa capacité à manier les
ontologies nous sera utile pour créer les exemples qui nous serviront de tests pour notre application. De plus
ce logiciel nous a été fort utile lors de notre apprentissage du langage OWL et du concept d’ontologie.

Nous avons ensuite choisi pour base de notre application l’API Jena pour les raisons suivantes : on peut dire
que la traduction est sensiblement la même entre le convertisseur de Michel Klein et l’API Jena, a ceci prés
que Jena utilise les espaces de noms et pas le convertisseur de Michel Klein, ce qui apporte certes une
meilleur lisibilité pour un utilisateur mais l’utilisation d’espace de nom permet une meilleur indépendance
du code. De plus la lisibilité n’est pas une qualité recherchée dans notre cas, puisque la sortie de notre
application ne sera pas utilisée par un humain mais par une machine. Nous recherchons donc avant tout la
qualité et la robustesse de la traduction. De plus, étant une API Jena peut être utilisé facilement car elle
bénéficie d’une documentation complète, qui pourra nous permettre de reprendre aisément les fonctions
fournit. Enfin, les sources du convertisseur de Michel Klein n’étant pas mis a disposition il est donc
impossible de repartir de son convertisseur pour chercher a convertir les propriété OWL restante.

Ce bilan clôture notre phase d’analyse et conceptions. Elle nous aura permis d’apercevoir les grandes lignes
de l’implémentation de notre future solution mais aussi de prendre le meilleur de l’existant. Ainsi nous
gagnerons un temps précieux lors du développement. Le temps gagné à ne pas implémenter ce qui existait
déjà sera utilisé pour créer de la nouveauté.


4 CONCLUSION

Grâce à cette phase d’analyse poussée, nous voyons désormais les grandes lignes de notre projet. Encore une
fois nous avons été amenés devant le fait qu’une analyse complète et réfléchi du sujet est primordiale pour la
réussite d’un projet. La réflexion poussé que nous avons mené vis-à-vis de la gestion globale du projet nous
a entre autres permis de rendre ce dossier en temps et en heure grâce à une gestion du temps harmonieuse.
Nous abordons donc la phase de développement beaucoup plus sereinement qu’au tout début de notre
projet et avec la certitude d’utiliser les outils les plus adaptés à nos besoins.




                                                          Page 82
5 SOURCES

                                     DOCUMENTATION OWL

http://www.w3.org/2004/OWL/

http://websemantique.org/OWL




                                      DOCUMENTATION RDF

http://www.w3.org/RDF/

http://websemantique.org/RDF

http://xmlfr.org/documentations/tutoriels/041015-0001/




                                                 API JENA

http://jena.sourceforge.net/javadoc/index.html




                                            API SESAME

http://www.openrdf.org/doc/sesame2/api/




                                                 Page 83
                                           LOGICIEL PROTEGE

http://protege.stanford.edu/doc/users_guide/

http://protege.stanford.edu/publications/ontology_development/ontology101.pdf




                                 CONVERTISSEUR DE MICHEL KLEIN

http://www.cs.vu.nl/cgi-bin/mcaklein/owl2rdfs




                                                    AUTRES

http://websemantique.org

http://www.developpez.com/

http://www.siteduzero.com

6 ANNEXES

                                     COMPTE RENDU DE REUNION

   •   Voici le compte rendu de notre première réunion :

       Travaux rendu : Ebauche du dossier de description du sujet ==> Suivra une correction de Mr Cruz

       Apports de ressources :  Plusieurs nouvelles pistes à étudier ont été évoqués:
                              -Le convertisseur de Michel Klein
                              -Lien web (Rechercher: OWL web ontology langage semantics and abstract syntax
       mapping to RDF graphs ==> source contenant des informations relatives aux passages OWL vers RDF
                              -Logiciel Protegé 2000
                              -Dossier Archi3D se basant sur des ontologies disponible sur le partage

       Définition des taches : la phase de conception (Fin le 24 Octobre) se décomposera en 5 parties :
                               -Description du sujet (Partir du dossier déjà constitué mais à étoffer)
                               -Caractéristiques du langage RDF et RDFS
                               -Caractéristiques du langage OWL
                               -Techniques de passage entre OWL et RDF/RDFS
                               -Solutions existantes (Ce qui a été fait avant nous)



   •   Voici le compte rendu de notre deuxième réunion :

       Travaux rendu : Deuxième version du dossier de description du sujet (Les parties sur OWL,RDF et Jena sont
       volontairement peu développé pour laisser de la matière aux chapitres suivants Pour la partie sur le logiciel
       protégé 2000 je suis entrain d'étudier plus en détail son fonctionnement donc la partie du dossier à ce propos
       suivra sans trop tarder )


                                                    Page 84
          Modification du planning :
           -J'ai modifié la date de fin concernant la présentation des caractéristiques des langages OWL et RDF/RDFS.
          Cette partie du dossier devra être terminé pour jeudi prochain

          Création d'un forum de travail pour faciliter nos échanges d'infos:
           adresse : http://owltordf.forum-actif.eu/



      •   Voici le compte rendu de la 3ème réunion:

          Travaux rendus : Dossier comprenant la partie de présentation et les parties relatives aux langages

          Travaux à rendre : Etude des techniques de passage entre OWL et RDF/RDFS
                            Etude et comparatif des API Jena et Sésame




      •   Voici le compte rendu de notre 4 ème réunion :



          Travaux rendus : Compte rendu sur l'API Sésame , Compte rendu de traduction Jena

          Travaux à effectuer: -Etude de l'existant à terminer : Reproduire le travail effectué pour Jena aux
          programmes suivants : Kaon2 (Chercher Kaon2 OWL tools) , le convertisseur de Michel Klein ...
                                -Terminer le tableau de conversion syntaxique : rajouter une colonne donnant la
          classification de la balise owl (OWL Full , Lite ou DL) , une colonne avec la notation N3 et une colonne avec
          un graphe.
                                -Description des langages par des diagrammes UML

          Remarques : Pour le convertisseur et l'étude en général (Pour le tableau de conversion syntaxique) nous
          nous contenterons du OWL DL car OWL Full ne prend pas en charge l'inférence




                     ONTOLOGIE UTILISE POUR LES TESTS (VERSION REDUITE)

<?xml version="1.0"?>

<!DOCTYPE rdf:RDF [

     <!ENTITY owl "http://www.w3.org/2002/07/owl#" >

     <!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >

     <!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#" >

     <!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#" >

]>



                                                        Page 85
<rdf:RDF xmlns="http://www.owl-ontologies.com/Ontology1223114912.owl#"

  xml:base="http://www.owl-ontologies.com/Ontology1223114912.owl"

  xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"

  xmlns:xsd="http://www.w3.org/2001/XMLSchema#"

  xmlns:owl="http://www.w3.org/2002/07/owl#"

  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">

 <owl:Ontology rdf:about=""/>

 <Pays rdf:ID="Allemagne">

   <nomPays rdf:datatype="&xsd;string">Allemagne</nomPays>

 </Pays>

 <owl:ObjectProperty rdf:ID="aPourPere">

   <rdfs:domain rdf:resource="#Humain"/>

   <rdfs:range rdf:resource="#Homme"/>

 </owl:ObjectProperty>

 <owl:ObjectProperty rdf:ID="aUnLienDeFraternite">

   <rdf:type rdf:resource="&owl;SymmetricProperty"/>

   <rdfs:domain rdf:resource="#Humain"/>

   <rdfs:range rdf:resource="#Humain"/>

   <owl:inverseOf rdf:resource="#aUnLienDeFraternite"/>

 </owl:ObjectProperty>

 <owl:DatatypeProperty rdf:ID="dateDeNaissance">

   <rdfs:domain rdf:resource="#Humain"/>

   <rdfs:range rdf:resource="&xsd;date"/>

 </owl:DatatypeProperty>

 <owl:ObjectProperty rdf:ID="estMarieA">

   <rdf:type rdf:resource="&owl;SymmetricProperty"/>

   <rdfs:domain rdf:resource="#Humain"/>

   <rdfs:range rdf:resource="#Humain"/>

   <owl:inverseOf rdf:resource="#estMarieA"/>

 </owl:ObjectProperty>


                                             Page 86
<owl:Class rdf:ID="Femme">

  <rdfs:subClassOf rdf:resource="#Humain"/>

</owl:Class>

<Pays rdf:ID="France">

  <nomPays rdf:datatype="&xsd;string">France</nomPays>

</Pays>

<owl:ObjectProperty rdf:ID="habiteA">

  <rdfs:domain rdf:resource="#Humain"/>

  <rdfs:range rdf:resource="#Ville"/>

</owl:ObjectProperty>

<owl:Class rdf:ID="Homme">

  <rdfs:subClassOf rdf:resource="#Humain"/>

</owl:Class>

<owl:Class rdf:ID="Humain">

  <rdfs:subClassOf rdf:resource="&owl;Thing"/>

  <rdfs:subClassOf>

    <owl:Restriction>

      <owl:onProperty rdf:resource="#aPourPere"/>

      <owl:cardinality rdf:datatype="&xsd;int">1</owl:cardinality>

    </owl:Restriction>

  </rdfs:subClassOf>

</owl:Class>

<Homme rdf:ID="Jacques">

  <nom rdf:datatype="&xsd;string">Dupond</nom>

  <dateDeNaissance rdf:datatype="&xsd;date">2008-10-16</dateDeNaissance>

  <prenom rdf:datatype="&xsd;string">Jacques</prenom>

  <aPourPere rdf:resource="#Unknow"/>

  <habiteA rdf:resource="#Paris"/>

</Homme>

<Femme rdf:ID="Marie">


                                              Page 87
  <nom rdf:datatype="&xsd;string">Dupond</nom>

  <nomDeJeuneFille rdf:datatype="&xsd;string">Martin</nomDeJeuneFille>

  <dateDeNaissance rdf:datatype="&xsd;date">2008-10-15</dateDeNaissance>

  <prenom rdf:datatype="&xsd;string">Marie</prenom>

  <aPourPere rdf:resource="#Unknow"/>

  <estMarieA rdf:resource="#Paul"/>

  <habiteA rdf:resource="#Paris"/>

</Femme>

<owl:DatatypeProperty rdf:ID="nom">

  <rdfs:domain rdf:resource="#Humain"/>

  <rdfs:range rdf:resource="&xsd;string"/>

</owl:DatatypeProperty>

<owl:DatatypeProperty rdf:ID="nomDeJeuneFille">

  <rdfs:domain rdf:resource="#Femme"/>

  <rdfs:range rdf:resource="&xsd;string"/>

</owl:DatatypeProperty>

<owl:DatatypeProperty rdf:ID="nomPays">

  <rdfs:domain rdf:resource="#Pays"/>

  <rdfs:range rdf:resource="&xsd;string"/>

</owl:DatatypeProperty>

<owl:DatatypeProperty rdf:ID="nomVille">

  <rdfs:domain rdf:resource="#Ville"/>

  <rdfs:range rdf:resource="&xsd;string"/>

</owl:DatatypeProperty>

<Ville rdf:ID="Paris">

  <nomVille rdf:datatype="&xsd;string">Paris</nomVille>

  <seTrouveEn rdf:resource="#France"/>

</Ville>

<Homme rdf:ID="Paul">

  <nom rdf:datatype="&xsd;string">Dupond</nom>


                                             Page 88
  <dateDeNaissance rdf:datatype="&xsd;date">2008-10-09</dateDeNaissance>

  <prenom rdf:datatype="&xsd;string">Paul</prenom>

  <aUnLienDeFraternite rdf:resource="#Pierre"/>

  <aPourPere rdf:resource="#Jacques"/>

  <estMarieA rdf:resource="#Marie"/>

  <habiteA rdf:resource="#Paris"/>

</Homme>

<owl:Class rdf:ID="Pays"/>

<Homme rdf:ID="Pierre">

  <nom rdf:datatype="&xsd;string">Dupond</nom>

  <dateDeNaissance rdf:datatype="&xsd;date">2008-08-18</dateDeNaissance>

  <prenom rdf:datatype="&xsd;string">Pierre</prenom>

  <aUnLienDeFraternite rdf:resource="#Paul"/>

  <aPourPere rdf:resource="#Jacques"/>

  <habiteA rdf:resource="#Ulm"/>

</Homme>

<owl:DatatypeProperty rdf:ID="prenom">

  <rdfs:domain rdf:resource="#Humain"/>

  <rdfs:range rdf:resource="&xsd;string"/>

</owl:DatatypeProperty>

<owl:ObjectProperty rdf:ID="seTrouveEn">

  <rdfs:domain rdf:resource="#Ville"/>

  <rdfs:range rdf:resource="#Pays"/>

</owl:ObjectProperty>

<Ville rdf:ID="Ulm">

  <nomVille rdf:datatype="&xsd;string">Ulm</nomVille>

  <seTrouveEn rdf:resource="#Allemagne"/>

</Ville>

<Homme rdf:ID="Unknow">

  <aPourPere rdf:resource="#Unknow"/>


                                             Page 89
 </Homme>

 <owl:Class rdf:ID="Ville">

   <rdfs:subClassOf rdf:resource="&owl;Thing"/>

   <rdfs:subClassOf>

     <owl:Restriction>

       <owl:onProperty rdf:resource="#seTrouveEn"/>

       <owl:cardinality rdf:datatype="&xsd;int">1</owl:cardinality>

     </owl:Restriction>

   </rdfs:subClassOf>

 </owl:Class>

</rdf:RDF>




                               ONTOLOGIE EN SORTIE DE JENA

<rdf:RDF

 xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"

 xmlns:xsd="http://www.w3.org/2001/XMLSchema#"

 xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"

 xmlns:owl="http://www.w3.org/2002/07/owl#"

 xmlns="http://www.owl-ontologies.com/Ontology1223114912.owl#" >



<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Paris">

      <seTrouveEn rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#France"/>

      <nomVille rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Paris</nomVille>

      <rdf:type rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Ville"/>

</rdf:Description>

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#nomVille">

      <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>

      <rdfs:domain rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Ville"/>

      <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DatatypeProperty"/>

</rdf:Description>


                                              Page 90
 <rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Pays">

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>

</rdf:Description>

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Humain">

       <rdfs:subClassOf rdf:nodeID="A0"/>

       <rdfs:subClassOf rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>

</rdf:Description>

 <rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Paul">

       <habiteA rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Paris"/>

       <estMarieA rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Marie"/>

       <aPourPere rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Jacques"/>

        <aUnLienDeFraternite rdf:resource="http://www.owl-
ontologies.com/Ontology1223114912.owl#Pierre"/>

       <prenom rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Paul</prenom>

       <dateDeNaissance rdf:datatype="http://www.w3.org/2001/XMLSchema#date">2008-10-
09</dateDeNaissance>

       <nom rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Dupond</nom>

       <rdf:type rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Homme"/>

</rdf:Description>

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#prenom">

       <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>

        <rdfs:domain rdf:resource="http://www.owl-
ontologies.com/Ontology1223114912.owl#Humain"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DatatypeProperty"/>

</rdf:Description>

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#nomPays">

       <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>

       <rdfs:domain rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Pays"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DatatypeProperty"/>

</rdf:Description>



                                             Page 91
<rdf:Description rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#dateDeNaissance">

       <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#date"/>

        <rdfs:domain rdf:resource="http://www.owl-
ontologies.com/Ontology1223114912.owl#Humain"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DatatypeProperty"/>

</rdf:Description>

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl">

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Ontology"/>

</rdf:Description>

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#aPourPere">

       <rdfs:range rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Homme"/>

        <rdfs:domain rdf:resource="http://www.owl-
ontologies.com/Ontology1223114912.owl#Humain"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty"/>

</rdf:Description>

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Homme">

        <rdfs:subClassOf rdf:resource="http://www.owl-
ontologies.com/Ontology1223114912.owl#Humain"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>

</rdf:Description>

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Unknow">

       <aPourPere rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Unknow"/>

       <rdf:type rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Homme"/>

</rdf:Description>

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Pierre">

       <habiteA rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Ulm"/>

       <aPourPere rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Jacques"/>

        <aUnLienDeFraternite rdf:resource="http://www.owl-
ontologies.com/Ontology1223114912.owl#Paul"/>

       <prenom rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Pierre</prenom>




                                              Page 92
       <dateDeNaissance rdf:datatype="http://www.w3.org/2001/XMLSchema#date">2008-08-
18</dateDeNaissance>

       <nom rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Dupond</nom>

       <rdf:type rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Homme"/>

</rdf:Description>

 <rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Allemagne">

       <nomPays rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Allemagne</nomPays>

       <rdf:type rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Pays"/>

 </rdf:Description>

 <rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#nom">

       <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>

        <rdfs:domain rdf:resource="http://www.owl-
ontologies.com/Ontology1223114912.owl#Humain"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DatatypeProperty"/>

 </rdf:Description>

<rdf:Description rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#nomDeJeuneFille">

       <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>

       <rdfs:domain rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Femme"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DatatypeProperty"/>

</rdf:Description>

 <rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Marie">

       <habiteA rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Paris"/>

       <estMarieA rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Paul"/>

       <aPourPere rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Unknow"/>

       <prenom rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Marie</prenom>

       <dateDeNaissance rdf:datatype="http://www.w3.org/2001/XMLSchema#date">2008-10-
15</dateDeNaissance>

        <nomDeJeuneFille
rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Martin</nomDeJeuneFille>

       <nom rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Dupond</nom>

       <rdf:type rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Femme"/>



                                             Page 93
 </rdf:Description>

 <rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Jacques">

       <habiteA rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Paris"/>

       <aPourPere rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Unknow"/>

       <prenom rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Jacques</prenom>

       <dateDeNaissance rdf:datatype="http://www.w3.org/2001/XMLSchema#date">2008-10-
16</dateDeNaissance>

       <nom rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Dupond</nom>

       <rdf:type rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Homme"/>

 </rdf:Description>

 <rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#habiteA">

       <rdfs:range rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Ville"/>

        <rdfs:domain rdf:resource="http://www.owl-
ontologies.com/Ontology1223114912.owl#Humain"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty"/>

</rdf:Description>

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#estMarieA">

        <owl:inverseOf rdf:resource="http://www.owl-
ontologies.com/Ontology1223114912.owl#estMarieA"/>

       <rdfs:range rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Humain"/>

        <rdfs:domain rdf:resource="http://www.owl-
ontologies.com/Ontology1223114912.owl#Humain"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#SymmetricProperty"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty"/>

</rdf:Description>

 <rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Femme">

        <rdfs:subClassOf rdf:resource="http://www.owl-
ontologies.com/Ontology1223114912.owl#Humain"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>

 </rdf:Description>

 <rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Ville">

       <rdfs:subClassOf rdf:nodeID="A1"/>



                                              Page 94
       <rdfs:subClassOf rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>

 </rdf:Description>

 <rdf:Description rdf:about="http://www.owl-
ontologies.com/Ontology1223114912.owl#aUnLienDeFraternite">

        <owl:inverseOf rdf:resource="http://www.owl-
ontologies.com/Ontology1223114912.owl#aUnLienDeFraternite"/>

       <rdfs:range rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Humain"/>

        <rdfs:domain rdf:resource="http://www.owl-
ontologies.com/Ontology1223114912.owl#Humain"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#SymmetricProperty"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty"/>

</rdf:Description>

<rdf:Description rdf:nodeID="A1">

       <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#int">1</owl:cardinality>

        <owl:onProperty rdf:resource="http://www.owl-
ontologies.com/Ontology1223114912.owl#seTrouveEn"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Restriction"/>

 </rdf:Description>

 <rdf:Description rdf:nodeID="A0">

       <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#int">1</owl:cardinality>

        <owl:onProperty rdf:resource="http://www.owl-
ontologies.com/Ontology1223114912.owl#aPourPere"/>

       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Restriction"/>

 </rdf:Description>

 <rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#France">

       <nomPays rdf:datatype="http://www.w3.org/2001/XMLSchema#string">France</nomPays>

       <rdf:type rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Pays"/>

 </rdf:Description>

 <rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#Ulm">

        <seTrouveEn rdf:resource="http://www.owl-
ontologies.com/Ontology1223114912.owl#Allemagne"/>




                                             Page 95
      <nomVille rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Ulm</nomVille>

      <rdf:type rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Ville"/>

</rdf:Description>

<rdf:Description rdf:about="http://www.owl-ontologies.com/Ontology1223114912.owl#seTrouveEn">

      <rdfs:range rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Pays"/>

      <rdfs:domain rdf:resource="http://www.owl-ontologies.com/Ontology1223114912.owl#Ville"/>

      <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty"/>

</rdf:Description>

</rdf:RDF>




                                            Page 96

								
To top