Du Graphe aux Motifs

Du triplet simple au langage d'ingénieur

Dans le cours #2, on a découvert Turtle : sujet prédicat objet. Dans le cours #3, on a utilisé RDF pour représenter des ontologies OWL. Mais Turtle, c'est bien plus qu'une syntaxe à triplet unique.

Ce quatrième cours explore la face cachée de Turtle : les raccourcis qui transforment un listing verbeux en un graphe compact, les nœuds anonymes qui évitent de nommer l'innommable, les listes qui encodent des séquences, et les chemins de propriétés qui parcourent le graphe comme on suivrait une piste dans une forêt profonde.

Ce cours suppose que vous maîtrisez les bases de Turtle (cours #2, chapitre 6). On va maintenant ouvrir le capot et voir tout ce que le standard peut faire pour vous.

Arrêtez d'écrire le même sujet 40 fois

Le problème existentiel de tout rédacteur Turtle : on a un seul sujet et plein de triplets à écrire. Socrate a 15 propriétés. Vous allez recopier ex:Socrate 15 fois ? Non. Vous allez utiliser le point-virgule et la virgule.

Le point-virgule ; : même sujet, prédicats différents

Quand plusieurs triplets partagent le même sujet, on peut chaîner les prédicats avec ; :

Turtle
# Version longue (11 lignes, on pleure)
ex:Socrate  rdf:type          ex:Humain .
ex:Socrate  ex:estLeMaitreDe  ex:Platon .
ex:Socrate  ex:estLeMaitreDe  ex:Aristote .
ex:Socrate  ex:age            "70"^^xsd:integer .
ex:Socrate  ex:nom            "Socrate"@grc .
ex:Socrate  ex:nom            "Σωκράτης"@grc .

# Version courte (point-virgule, plus de larmes)
ex:Socrate  rdf:type          ex:Humain ;
            ex:estLeMaitreDe  ex:Platon ,
                              ex:Aristote ;
            ex:age            "70"^^xsd:integer ;
            ex:nom            "Socrate"@grc ,
                              "Σωκράτης"@grc .

La virgule , : même sujet ET même prédicat

Quand en plus le prédicat est identique, la virgule permet de lister les objets sans répéter le prédicat. C'est magique.

Turtle
# Avant : répétition du prédicat
ex:Socrate  ex:estLeMaitreDe  ex:Platon .
ex:Socrate  ex:estLeMaitreDe  ex:Aristote .
ex:Socrate  ex:estLeMaitreDe  ex:Xenophon .

# Après : point-virgule + virgule
ex:Socrate  ex:estLeMaitreDe  ex:Platon ,
                              ex:Aristote ,
                              ex:Xenophon .

# Mélange des deux :
ex:Socrate  rdf:type          ex:Humain ;
            ex:estLeMaitreDe  ex:Platon ,
                              ex:Aristote ,
                              ex:Xenophon ;
            ex:age            "70"^^xsd:integer .

La notation a : sucre pour rdf:type

Le prédicat rdf:type (qui signifie « est un ») est tellement courant qu'il a sa propre notation abrégée : a.

Turtle
# Version classique
ex:Socrate  rdf:type  ex:Humain .

# Version sucrée (les deux sont strictement identiques)
ex:Socrate  a  ex:Humain .

# Avec les raccourcis :
ex:Socrate  a       ex:Humain ;
            ex:nom  "Socrate"@grc .

# On peut enchaîner les types :
ex:Socrate  a  ex:Humain , ex:Philosophe , ex:Athénien .

Nœuds anonymes : nommer l'innommable

Parfois, un nœud existe, mais on ne veut pas (ou on ne peut pas) lui donner d'URI. C'est une ressource sans nom. En RDF, on appelle ça un nœud blanc (blank node).

Syntaxe [] avec contenu

Un nœud anonyme se note avec des crochets []. On peut y mettre des propriétés à l'intérieur :

Turtle
# Un Humain sans nom (littéralement)
ex:Socrate  ex:aPourEleve  [
    a  ex:Humain ;
    ex:nom  "Inconnu"@fr
] .

# Ceci crée deux triplets avec un blank node intermédiaire :
ex:Socrate  ex:aPourEleve  _:b1 .
_:b1  rdf:type  ex:Humain .
_:b1  ex:nom     "Inconnu"@fr .

Les crochets ouvrent un scope : tout ce qui est à l'intérieur décrit un nœud anonyme qui est l'objet du triplet parent.

Syntaxe [] vide : nœud anonyme sans propriété

Parfois on veut juste dire « il existe une relation » sans décrire la cible :

Turtle
# Socrate a un maître (qu'on ne connaît pas / qu'on ne décrit pas)
ex:Socrate  ex:aPourMaitre  [] .

# Strictement équivalent à :
ex:Socrate  ex:aPourMaitre  _:b1 .

Nœuds anonymes comme sujets

On peut aussi décrire un nœud anonyme en le réutilisant avec [] comme sujet. Turtle permet d'utiliser des crochets des deux côtés :

Turtle
# Un événement anonyme (sans URI)
[
    a  ex:Evenement ;
    ex:type  "naissance"@fr ;
    ex:lieu  ex:Athenes ;
    ex:date  "-470"^^xsd:gYear
]  ex:aPourActeur  ex:Socrate .

# Noter le sujet entre crochets, suivi du prédicat-objet

Quand utiliser les nœuds anonymes ?

Listes : quand l'ordre compte

RDF est un graphe, pas un arbre. En théorie, il n'y a pas d'ordre entre les triplets. Mais parfois, l'ordre est important : les ingrédients d'une pizza, les enfants dans l'ordre de naissance, les étapes d'une recette. Pour ça, RDF a inventé les listes.

Le pattern rdf:first / rdf:rest

Une liste RDF est une liste chaînée à la Lisp. Chaque élément pointe vers le suivant :

Turtle
# Une liste de deux ingrédients (en interne RDF)
ex:Margherita  ex:ingredients  _:l1 .
_:l1  rdf:first  ex:Mozzarella .
_:l1  rdf:rest    _:l2 .
_:l2  rdf:first  ex:Tomate .
_:l2  rdf:rest    rdf:nil .

La syntaxe raccourcie (...)

Fort heureusement, personne n'écrit les listes RDF à la main. Turtle propose une syntaxe parenthésée :

Turtle
# La même liste, en 10 fois moins de lignes
ex:Margherita  ex:ingredients  ( ex:Mozzarella ex:Tomate ) .

# Liste vide
ex:Platon  ex:enfants  () .

# Liste avec des littéraux
ex:Socrate  ex:oeuvres  ( "Apologie" "Criton" "Phédon" "République" ) .

# Liste avec des nœuds anonymes
ex:Socrate  ex:eleves  ( [ ex:nom "Platon" ] [ ex:nom "Aristote" ] ) .

Attention : liste ≠ ensemble de triplets

Il y a une différence fondamentale entre une liste et une série de triplets avec le même prédicat :

Turtle
# ENSEMBLE (pas d'ordre, pas de notion de totalité)
ex:Socrate  ex:eleve  ex:Platon , ex:Aristote .

# LISTE (ordre préservé, notion de « ces éléments et pas d'autres »)
ex:Socrate  ex:eleves  ( ex:Platon ex:Aristote ) .

# Sémantique différente :
# La 1ʳᵉ version dit : Socrate a des élèves (parmi d'autres peut-être)
# La 2ᵉ version dit : la liste des élèves de Socrate EST [Platon, Aristote]

Littéraux : quand les mots ont des types

Les littéraux sont les valeurs concrètes : chaînes, nombres, dates, booléens. En Turtle, ils peuvent être enrichis d'étiquettes de langue et de types de données.

Étiquettes de langue avec @

Un même nom dans différentes langues, c'est le quotidien du web multilingue :

Turtle
ex:Socrate  ex:nom  "Socrate"@fr ,
                     "Socrates"@en ,
                     "Σωκράτης"@grc ,
                     "سقراط"@ar .

# Les étiquettes suivent le standard BCP47
# @fr = français, @en = anglais, @grc = grec ancien, @ar = arabe
# On peut préciser la région : @en-US, @fr-CA, @zh-Hans

Typage avec ^^

Pour préciser qu'une valeur est un entier, une date, un booléen :

Turtle
# Littéraux typés
ex:Socrate  ex:age          "70"^^xsd:integer .
ex:Platon   ex:anneeNaiss  "-428"^^xsd:gYear .
ex:Aristote ex:estVivant   "false"^^xsd:boolean .
ex:Socrate  ex:taille      "1.70"^^xsd:decimal .

# Les types XSD les plus courants :
# xsd:string, xsd:integer, xsd:decimal, xsd:boolean
# xsd:date, xsd:dateTime, xsd:gYear, xsd:gYearMonth
# xsd:float, xsd:double, xsd:hexBinary, xsd:base64Binary

Sucre : les raccourcis de types

Turtle offre des raccourcis syntaxiques pour les types courants :

Turtle
# Entiers (xsd:integer implicite)
ex:Socrate  ex:age  70 .

# Décimaux (xsd:decimal implicite)
ex:Socrate  ex:taille  1.70 .

# Booléens (xsd:boolean implicite)
ex:Socrate  ex:mortel  true .    # ou false

# Chaîne simple (xsd:string implicite)
ex:Socrate  ex:nom  "Socrate" .

# Identiques en interne :
ex:Socrate  ex:age  "70"^^xsd:integer .
# et
ex:Socrate  ex:age  70 .
# produisent exactement le même triplet

Chaînes multilignes et échappement

Pour les textes longs, Turtle propose des triples guillemets :

Turtle
# Chaîne longue (peut contenir des retours à la ligne)
ex:Socrate  ex:citation  """
    Je ne sais qu'une chose :
    c'est que je ne sais rien.
    — Socrate
"""@fr .

# Échappement dans les chaînes
ex:Socrate  ex:citation  "Il disait : \"Connais-toi toi-même\""@fr .

Property Paths : naviguer dans le graphe

Les chemins de propriétés (property paths) sont l'un des ajouts les plus puissants de SPARQL 1.1 (et Turtle les supporte pour la définition de graphes). Ils permettent de parcourir le graphe sans connaître sa structure exacte.

Les opérateurs de base

Exemples SPARQL avec property paths

SPARQL
# 1. Qui est le maître du maître de X ? (grand-maître)
# Séquence : ex:maitreDe / ex:maitreDe
SELECT ?grandMaitre ?eleve WHERE {
  ?grandMaitre  ex:maitreDe / ex:maitreDe  ?eleve .
}
# → (Socrate → Platon → Aristote) ⇒ Socrate est grand-maître d'Aristote

# 2. Tous les ancêtres académiques (chaîne de maîtres)
# Un ou plus : ex:maitreDe+
SELECT ?ancetre ?descendant WHERE {
  ?ancetre  ex:maitreDe+  ?descendant .
}
# → remonte toute la chaîne : maître, maître du maître, etc.

# 3. Toute la famille académique (maîtres + élèves)
# Union : ex:maitreDe | ^ex:maitreDe
SELECT ?x ?y WHERE {
  ?x  ( ex:maitreDe | ^ex:maitreDe )  ?y .
}
# → toutes les paires maître-élève, dans les deux sens

# 4. Qui est influencé par Socrate (directement ou indirectement) ?
# Zéro ou plus : ex:influence*
SELECT ?influence WHERE {
  ex:Socrate  ex:influence*  ?influence .
}
# → Socrate lui-même, ses élèves directs, ses élèves d'élèves, ...

# 5. Les Humains qui ont un surnom (optionnel)
SELECT ?h ?surnom WHERE {
  ?h  a  ex:Humain .
  ?h  ex:surnom?  ?surnom .
}
# → tous les Humains, avec surnom si présent (None sinon)

# 6. L'inverse : qui est élève de qui ?
SELECT ?eleve ?maitre WHERE {
  ?eleve  ^ex:maitreDe  ?maitre .
}
# Strictement équivalent à : ?maitre ex:maitreDe ?eleve

Property paths en Turtle (SHACL)

Les chemins de propriétés ne sont pas réservés à SPARQL. En Turtle, on peut les utiliser dans les définitions de SHACL (Shapes Constraint Language) ou de OWL 2 pour décrire des propriétés complexes :

Turtle
# SHACL : une shape qui utilise un property path
ex:AncetreShape  a  sh:NodeShape ;
    sh:targetClass  ex:Humain ;
    sh:property  [
        sh:path  ( ex:maitreDe [ sh:zeroOrMorePath ex:maitreDe ] ) ;
        sh:minCount  1
    ] .

# OWL 2 : propriété transitive (chemin de longueur ≥ 1)
ex:ancetre  a  owl:TransitiveProperty .

# OWL 2 : propriété composée (chemin séquence)
ex:grandMaitre  a  owl:ObjectProperty ;
    owl:propertyChainAxiom  ( ex:maitreDe ex:maitreDe ) .

Collections, conteneurs et RDF

Au chapitre 3, on a vu les listes RDF (rdf:first/rdf:rest). Mais RDF propose d'autres structures pour grouper des ressources : les conteneurs et les collections.

rdf:Bag, rdf:Seq, rdf:Alt

Avant les listes, RDF avait des conteneurs (un peu l'ancêtre un peu poussiéreux). Ils existent toujours dans le standard :

Turtle
# rdf:Seq — une séquence (avec indices rdf:_1, rdf:_2, …)
ex:Socrate  ex:oeuvres  [
    a  rdf:Seq ;
    rdf:_1  "Apologie" ;
    rdf:_2  "Criton" ;
    rdf:_3  "Phédon"
] .

# rdf:Bag — un sac (pas d'ordre, avec rdf:_1, rdf:_2, …)
ex:Socrate  ex:eleves  [
    a  rdf:Bag ;
    rdf:_1  ex:Platon ;
    rdf:_2  ex:Aristote ;
    rdf:_3  ex:Xenophon
] .

# rdf:Alt — des alternatives (la première est la valeur par défaut)
ex:Platon  ex:ecole  [
    a  rdf:Alt ;
    rdf:_1  ex:Academie ;
    rdf:_2  ex:Lycee
] .

Les collections RDF en pratique

Au quotidien, vous utiliserez presque exclusivement la syntaxe parenthésée vue au chapitre 3. C'est plus propre, plus court, et sémantiquement plus clair. Les conteneurs rdf:Bag/rdf:Seq sont surtout utiles quand vous importez des données d'anciens systèmes RDF.

Turtle
# Recommandé : liste RDF (propre, fermée, ordonnée)
ex:Socrate  ex:oeuvres  ( "Apologie" "Criton" "Phédon" "République" ) .

# Acceptable : rdf:Seq (si vous avez besoin de compatibilité ascendante)
ex:Socrate  ex:oeuvres  [ a rdf:Seq ; rdf:_1 "Apologie" ; rdf:_2 "Criton" ] .

# À éviter : rdf:Bag (sauf si vraiment pas d'ordre)
ex:Socrate  ex:oeuvres  [ a rdf:Bag ; rdf:_1 "Apologie" ; rdf:_2 "Criton" ] .

SHACL : la grammaire du graphe

Turtle (et RDF) est très permissif : n'importe quel sujet peut avoir n'importe quelle propriété avec n'importe quelle valeur. C'est la liberté. Mais la liberté sans règles, c'est le chaos.

SHACL (Shapes Constraint Language) est le langage qui permet de valider un graphe RDF. C'est comme une grammaire pour vos données : « un Humain DOIT avoir un nom, PEUT avoir un âge, et son âge DOIT être un entier. »

Une shape SHACL

Turtle
# Définition d'une forme (shape) pour les Humains
ex:HumainShape  a  sh:NodeShape ;
    sh:targetClass  ex:Humain ;          # s'applique à tous les Humain
    sh:property  [
        sh:path  ex:nom ;
        sh:minCount  1 ;                 # au moins 1 nom
        sh:maxCount  3 ;                 # au plus 3 noms
        sh:datatype  xsd:string ;        # doit être une chaîne
        sh:minLength  2 ;
        sh:maxLength  100
    ] ;
    sh:property  [
        sh:path  ex:age ;
        sh:datatype  xsd:integer ;
        sh:minInclusive  0 ;
        sh:maxInclusive  150
    ] ;
    sh:property  [
        sh:path  ex:estLeMaitreDe ;
        sh:class  ex:Humain              # l'objet doit être un Humain
    ] .

Avec cette shape, tout graphe RDF contenant des ex:Humain peut être validé : chaque Humain doit avoir entre 1 et 3 noms (chaînes de 2 à 100 caractères), un âge entier entre 0 et 150, et ses élèves doivent être des Humains.

Combinaison avec les property paths

SHACL supporte les chemins de propriétés dans les contraintes. Vous pouvez exprimer des règles complexes :

Turtle
# Règle : un Humain ne peut pas être son propre ancêtre
ex:AntiHeritage  a  sh:NodeShape ;
    sh:targetClass  ex:Humain ;
    sh:property  [
        sh:path  ( ex:maitreDe+ ) ;      # chemin « un ou plus »
        sh:maxCount  0 ;                 # interdit
        sh:message  "Pas d'auto-heritage academique"@fr
    ] .

# Règle : un maître doit avoir au moins un élève
ex:MaitreShape  a  sh:NodeShape ;
    sh:targetClass  ex:Humain ;
    sh:property  [
        sh:path  ( ^ex:estLeMaitreDe ) ; # inverse
        sh:minCount  1 ;
        sh:message  "Un maitre doit avoir au moins un eleve"@fr
    ] .

Et après ? Turtle n'a pas fini de vous surprendre

Turtle est souvent présenté comme « la syntaxe simple de RDF ». J'espère que ce cours vous a montré qu'il est bien plus que ça. Avec ses raccourcis (;, ,, a), ses nœuds anonymes ([]), ses listes ((...)), ses littéraux typés (^^, @), et ses chemins (/, |, +, *), Turtle est un langage riche et expressif.

Ce que vous savez maintenant faire

1. Écrire du Turtle concis — fini les répétitions, vous maîtrisez ; et ,.
2. Créer des nœuds anonymes — vous savez représenter des ressources sans URI, imbriquées si nécessaire.
3. Encoder des listes — des séquences ordonnées avec la syntaxe ( ... ).
4. Typer vos littéraux — langues, nombres, dates, booléens : vos données sont précises.
5. Parcourir le graphe avec des chemins — séquence, union, étoile, inverse : vous naviguez dans RDF comme dans un GPS.
6. Valider avec SHACL — vos données respectent des contraintes, ou elles ne sont pas validées.

Directions pour la suite

Références