F-logic - Université de Genève

F-logic
Références
M. Kifer, G. Lausen. "F-logic: A Higher Order Language for Reasoning about Objects,
Inheritance, and Scheme", Proc. SIGMOD Conf, 1989.
M. Kifer, G. Lausen,J. Wu. "Logical Foundations of Object-Oriented and Frame-Based
Langues". Journal of the ACM, vol. 42, no. 4, 741-843, July 1995.
P.-Th. Kandzia, C. Schlepphorst. "Florid - A Prototype for F-logic", in Proc. 12th
German Workshop on Logic Programming, Sept. 1997, Munich.
Intérêt pour nous
Forme
Présentation « classique » d’une proposition de langage (syntaxe + sémantique).
Fond
Langage avec de « bonnes propriétés » (décidabilité, calculabilité, héritage, …).
Langage utilisé actuellement en représentation des connaissances.
G. Falquet, CUI, Université de Genève
1 de 28
Motivations
Bases de données OO : manque de sémantique formelle.
Systèmes déductifs :
utilisent un modèle de données « plat » ;
pas d’identité d’objets;
pas d’abstraction de données.
Objectifs :
bdoo + déduction + traitement des schémas
« programmer » les méthodes dans le même formalisme
ne pas utiliser une logique du second ordre (trop complexe)
mais permettre des « méta-traitements »
Une logique pour les systèmes à « cadres ».
G. Falquet, CUI, Université de Genève
2 de 28
Idée 1 : treillis des classes/objets
T
children(john)
sally
john
assistant
student
children(person)
20 30 40
mary
faculty
empl
person
bob
"CS"
"Mary"
string
yuppie
young
midaged
⊥
G. Falquet, CUI, Université de Genève
3 de 28
Classes, objets, relations
Pas de distinction classe - objet : tous dans le même domaine
Une classe peut être considérée comme un objet
=> pas besoin de notion de méta-classe
Pas de différence entre « instance de » et « sous-classe de »
=> sous-classe pas de sémantique de sous-ensemble
=> (à voir) pas de problèmes de définition de l’héritage
Notion de « plus défini », donne la relation d’ordre du treillis
Treillis => il existe toujours A sup B et A inf B
(plus petit (grand)élément supérieur (inférieur) à A et B)
Pas de distinction en relations et objets ( ≠ entity - relationship)
=> un objet peut être vu comme entité ou relation suivant son rôle (position
syntaxique)
G. Falquet, CUI, Université de Genève
4 de 28
Exemples
Faits
faculty:bob[name → "Bob", age → 40,
works → dept: cs1[dname → "CS", mngr → empl: phil] ]
• bob est une instance de faculty
• l’attribut name associe bob à "Bob"
• etc.
faculty: mary[…, friends → {bob, sally}, age → 30,
works → dept:cs2[…], …]
• attribut multivalué friends
• attributs non obligatoires
student: sally[age → midaged]
• on ne connaît pas l’age exact de sally (valeur moins définie qu’un nombre)
G. Falquet, CUI, Université de Genève
5 de 28
Exemples (suite)
Information sur les classes (c.f. schémas)
faculty[supervisor → faculty, age → midaged]
student[age → young]
empl[supervisor → empl]
Règle
E[supervisor → M] <= empl: E[works → dept: D[mngr → empl: M]]
Requête
empl:X[supervisor → Y, age → midaged:Z,
works → D[dname → "CS"]] ?
résultats:
mary[supervisor → faculty, age → 30, works → cs2]
supervisor → faculty est hérité
G. Falquet, CUI, Université de Genève
6 de 28
Syntaxe - Id-termes
Constantes:
ce sont les objets de base (ensemble O)
Symboles de fonctions:
servent de constructeurs d’objets (ensemble F)
Id-termes:
composés de fonctions, objets de base et variables (les « object identities »)
pere(X)
Termes de base
(ground terms): id-termes sans variables (ensemble O*)
pere(roger)
universite(californie)
Id-termes non constants ~=> objets construits à partir d’autres
G. Falquet, CUI, Université de Genève
7 de 28
Etiquettes
Un objet peut jouer le rôle d’étiquette (c.f. nom de relation/attribut/méthode)
En tant qu’étiquette un objet peut être fonctionnel ou multivalué (type)
Les symboles de fonction sont également typés (types des paramètres et du résultat)
Ils peuvent être surchargés:
p.ex.
f(fonc, multi, fonc) → multi
et
f(multi, multi, multi) → fonc
On peut calculer le type de chaque terme de O*
G. Falquet, CUI, Université de Genève
8 de 28
F-termes
Ce sont les formules atomiques du langage
(i.e. celles qui s’interprètent comme vrai ou faux)
F-termes simples
P :Q
P, Q des id-termes
(signifie : Q est un objet de la classe P)
F-termes complexes
P : Q [F1 → T1, …, Fm → Tm, M1 → {m1,1, …, mk1, 1}, M2 → …]
G. Falquet, CUI, Université de Genève
9 de 28
Typage des termes
Les variables et constantes n’ont pas de sorte (typage)
a [ X → b]
ne peut être vérifié statiquement
X fonctionnel ou multivaluée ?
sémantique : ∀X. a [ X → b] sera toujours interprété comme faux
a[E → c, E → {d, e}]
est insatisfaisable
G. Falquet, CUI, Université de Genève
10 de 28
Treillis sur O*
But : Placer les id-termes dans un treillis
relation ≤ signifie "moins défini que"
Extension (objets) d’une classe :
tous les objets au dessus d’elle dans le treillis (plus définis)
Bas du treillis = le tout = l’indéfini, Sommet du treillis = le rien (trop défini)
T
children(john)
sally
john
assistant
student
children(person)
20 30 40
mary
faculty
empl
person
bob
"CS"
"Mary"
string
yuppie
young
midaged
⊥
G. Falquet, CUI, Université de Genève
11 de 28
Etablissement du treillis sur O*
1. On spécifie la relation ≤ sur les objets de base (O)
étudiant ≤ john
personne ≤ étudiant
date ≤ 1.6.2002
etc.
2. On spécifie les classes des arguments et résultats des fonctions de construction
voiture(personne) → véhicule
propriétaire(date, véhicule) → personne
On peut ensuite typer les autres id-termes par inférence de types:
propriétaire(1.6.2002, voiture(albert)) → personne
On peut vérifier si t ≤ s avec un algorithme (proche de l’algorithme d’unification des
termes)
G. Falquet, CUI, Université de Genève
12 de 28
Sémantique - Interprétation des termes de O*
O*
gO est un homomorphisme de treillis
conserve l’ordre
Ufonc
pere(bob)
O
age
mary
bob
enfants
gO
Termes de base
Umulti
Univers des objets
G. Falquet, CUI, Université de Genève
13 de 28
Sémantique
Interprétation d’un langage en F-logique (constantes, fonctions, termes)
U : l’univers des objets
domaine d’interprétation, avec une struct. de treillis ≤U
U = Ufonc ∪ Umulti (disjoints)
Homomorphisme gO : O* → U
interprétation des «noms d’objets» par des «vrais» objets
gO (Lfonc) ⊆ Ufonc, gO(Lmulti) ⊆ Umulti
Application gF : F → Mon(Uk, U)
interprétation des noms de constructeurs k-aires
par des applications monotones dans U
gO (f(t1, …, tk)) = gF(f)(gO(t1), …, gO(tk )).
G. Falquet, CUI, Université de Genève
14 de 28
Sémantique - Interprétation des fonctions
O*
Ufonc
pere(bob)
age
O mary
bob
enfants
gO
gF
F
pere
Umulti
Fonctions (constructeurs)
G. Falquet, CUI, Université de Genève
15 de 28
Sémantique - Interprétation des objets comme
étiquettes de fonctions
O*
Mon(U, U)
Ufonc
pere(bob)
O
age
mary
bob
enfants
gO
jfonc
Fonctions monotones
Termes de base
jmulti
Mon(U, 2U )
F
pere
Fonctions
G. Falquet, CUI, Université de Genève
Umulti
Univers des objets
16 de 28
Interprétation (suite)
Interprétation des objets dans leur rôle d’étiquette (relation)
jfonc : Ufonc → Mon(U, U)
associe une application monotone à chaque objet de U fonc
jmulti : Umulti → Mon(U, 2U)
associe une application multivaluée monotone à chaque objet de Umulti
Interprétation des variables
assignation de variables : application v : {variables} → U
Interpréation des termes avec variables
v(d) = gO(d)
/* constante */
v(f(T1, …, Tk)) = gF(f)(v(T1), …, v(Tk))
v(P: Q[…]) = v(Q)
G. Falquet, CUI, Université de Genève
/* fonction */
/* F-terme */
17 de 28
Signification d’un F-terme
I une interprétation, v une assignation des variables
T = P : Q[…, Fi → Ti, …, Gj → {S1, …, Sm}, …]
MI, v (T) = vrai si
1) Q est dans la classe P : v(P) ≤ v(Q)
2) pour i = 1, k
v(Fi ) ∈ Ufonc
/* type correct */
v(Ti ) ≤U jfonc (v(Fi))(v(Q))
/* valeurs Fi pour Q plus définie que Ti */
MI, v (Ti) = vrai
/* au moins un objet qui satisfait Ti */
2) pour j = 1, r
v(G) ∈ Umulti
{v(S1), …, v(Sm)} ≤*U jmulti (v(Gi))(v(Q))
MI, v (Sn) = vrai pour n = 1, m
G. Falquet, CUI, Université de Genève
18 de 28
Signification des formules
Calcul habituel avec les opérateurs logiques et, ou, implique
Idem avec les quantificateurs:
MI, v (∀X.φ) est vrai si
pour tout assignation de variables w partout égale à v sauf éventuellement sur X
MI, w (φ) = vrai
Une formule fermée n’a pas de variables non quantifiées.
Sa signification est indépendant de toute assignation de variables.
Un modèle de ψ est une interprétation I telle que MI(ψ) = vrai.
G. Falquet, CUI, Université de Genève
19 de 28
Bases de données et requêtes
Base de données = ensemble de formules
Partie extensionnelle : les F-termes
Partie en compréhension (« intension ») : formules plus compliquées (et, ou, =>, …)
Conséquence logique ( « entailment » )
S
φ
Dans tout modèle de S (ensemble de formules fermées), φ est vrai.
Substitution
Application Variables → id-termes,
s’étend aux id-termes, F-termes et formules.
substition de base : s’il ne reste plus de variables
Instance d’une formule : application d’une substitution (évent. de base)
G. Falquet, CUI, Université de Genève
20 de 28
Requêtes
F-terme: Q?
Réponses par rapport à une base D
Le plus petit ensemble de F-termes de base tel que
(1) il est fermé pour
(2) il contient toutes les instances de Q conséquences ( ) de D
G. Falquet, CUI, Université de Genève
21 de 28
Propriétés: héritage
Théorème
Base de données D
F-terme T = p[E → Q, E' → {R}]
tel que D
T
Si v est un id-terme tel que p ≤O v (i.e. v est instance de p)
Alors D
v[E → Q, E' → {R}]
Preuve : provient de la monotonicité de jfonc (v(E)) et jmulti(v(E'))
Exemple
faculty ≤ sally
faculty[supervisor → faculty]
donc
sally[supervisor → faculty]
G. Falquet, CUI, Université de Genève
22 de 28
Héritage (exemple)
student: sally[age → midaged]
student[age → young]
student ≤ sally donc sally hérite age → young
on en déduit
sally[age → “least upper bound”(young, midaged) = yuppie]
Raison
dans toute interprétation on doit avoir :
j(gO (age))(gO(sally)) ≥ gO(young) et j(g O(age))(gO(sally)) ≥ gO(midaged)
gO homomorphisme de treillis
=> lub(gO (young), gO(midaged)) = gO(lub(young, midaged)
=> j(gO (age))(gO(sally)) = gO(yuppie)
“ Surcharge monotone de l’héritage ”
G. Falquet, CUI, Université de Genève
23 de 28
Héritage (suite)
(1) faculty: bob[works → dept: cs1[mgr → empl: phil]]
(5) faculty[supervisor → faculty]
(8) E[supervisor → M] <=
empl: E[works → dept:D[mgr → empl: M]
empl: X[supervisor -> Y]?
par (1) et (8) et empl ≤ faculty : on a
empl: bob[supervisor → phil]
par (5) et empl ≤ faculty : on a
empl: bob[supervisor → faculty]
donc
empl: bob[supervisor → lub(faculty, phil)]
== bob[supervisor → Top]
L’information à propos du superviseur de bob est inconsistante.
G. Falquet, CUI, Université de Genève
24 de 28
Accès au "schéma" de la base - méta requêtes
On peut raisonner sur le schéma car les étiquettes sont des objets
Tous les attributs de X qui sont de type personne :
attributs(X)[attr -> {L}] <= faculty: X [ L -> person: Z]
attributs(X)[attr -> {L}] <= faculty: X [ L -> {person: Z}]
Tous les objets qui mentionnent "CS"
directement
trouver("CS")[contenu -> {X}] <= X[Y -> "CS"]
trouver("CS")[contenu -> {X}] <= X[Y -> {"CS"}]
+ indirectement
trouver("CS")[contenu -> {X}] <= X[Y -> Z],
trouver("CS")[contenu -> {Z}]
trouver("CS")[contenu -> {X}] <= X[Y -> {Z}],
trouver("CS")[contenu -> {Z}]
G. Falquet, CUI, Université de Genève
25 de 28
F-logic et modèle relationnel
On peut utiliser des termes pour fixer le domaine de certains attributs
personne[age → nombre, nom → string, amis → {personne}]
on n’empêche pas d’avoir d’autres attributs !
c.f. modèles semi-structurés
On peut fiexer les attributs d’un type comme dans le relationnel:
personne[A → Top] <=
personne[A → ⊥], A ≠ age, A ≠ nom, A ≠ amis
G. Falquet, CUI, Université de Genève
26 de 28
Méthodes
Définition de méthodes en F-logique = définition d’étiquette non basiques
Définition non procédurale de la méthode graduation_date(université)
person: X[graduation_date(I) → Y] <=
university: I[alumni →
{alumn_rec: G[stud → person: X, date → year: Y]}]
Questions possibles
X[graduation_date(I) → 1988] ?
john[graduation_date(I) → Y] ?
Un méthode de recherche globale
trouveur[trouver(Quoi) → {X}] <= X[Y → Quoi]
trouveur[trouver(Quoi) → {X}] <= X[Y → Z],
trouveur[trouver(Quoi) → {Z}]
G. Falquet, CUI, Université de Genève
27 de 28
Méthodes: redéfinition et surcharge
X[nom(Date) → {N}] <=
année: Date, personne: X[nom_famille(Date) → string:N]
X[nom(Date) → {N}] <=
année: Date, femme: X[nom_jeune_fille(Date) → string:N].
X[nom(Date) → {N}]
<= année: Date, écrivain: X[nom_plume(Date) → string:N].
Différent de la redéfinition habituelle
Si marie en 2000 est écrivain elle peut avoir jusqu’à trois noms différents
Surcharge
P.ex. On peut définir une méthode nom(Date) pour des entreprises, avec d’autres
règles
G. Falquet, CUI, Université de Genève
28 de 28