 | |
Il progetto dsy.it è l'unofficial support site dei corsi di laurea del Dipartimento di Scienze dell'Informazione e del Dipartimento di Informatica e Comunicazione della Statale di Milano. E' un servizio degli studenti per gli studenti, curato in modo no-profit da un gruppo di essi. I nostri servizi comprendono aree di discussione per ogni Corso di Laurea, un'area download per lo scambio file, una raccolta di link e un motore di ricerca, il supporto agli studenti lavoratori, il forum hosting per Professori e studenti, i blog, e molto altro...
In questa sezione è indicizzato in textonly il contenuto del nostro forum |
Appunti dalla lezione del 21/12 (preparazione al secondo compitino)
Clicca QUI per vedere il messaggio nel forum |
| Walter |
Ecco gli argomenti ripassati nella lezione di Venerdì 21 Dicembre e che saranno presenti nel secondo compitino di Giovedì.
Correzioni o integrazioni sono sempre benvenute!
1. clausole di Horn
===================
Ripasso sulle clausole in generale.
Le clausole sono divise in tre classi:
a. clausole definite
b. clausole di Horn
c. clausole "normali"
1.1 clausole definite
---------------------
Sono del tipo "H" o "H <- Body" (Body senza il not!).
Hanno sempre modello minimo.
1.2 clausole di Horn
--------------------
Sono del tipo "<- Body" o "false <- Body" (nb: sono due modi di scrivere la stessa cosa).
Hanno modello minimo solo se sono consistenti.
L'insieme delle clausole di Horn include l'insieme delle clausole definite.
1.3 clausole "normali"
----------------------
Sono le più generali, si può usare anche il not nel Body.
Possono avere nessun modello, un modello minimo o più modelli minimali.
L'insieme delle clausole "normali" include l'insieme delle clausole di Horn (che a sua volta include l'insieme delle clausole definite).
es.
a <- not b
b <- not a
I modelli sono {a,b}, {a}, {b}, quindi non c'è modello minimo ma due modelli minimali (e Prolog andrebbe in loop).
Si ricorda che a <- b vale sempre true tranne nel caso in cui b è vero e a è falso.
Vincoli di integrità sulla base di dati: se c'è modello, posso eliminare le clausole del tipo "<- Body" e "false <- Body".
Floundering: si ha floundering in not(X) se X non è istanziata al momento della chiamata. es. Se X è un input (modo +), non si ha floundering.
es. Se X è un output (modo -), si ha floundering
es. b(X) <- not a(X,Y) è un esempio di floundering a causa di Y
es. b(X) <- not \esiste Y a(X,Y) va invece bene perchè Y è istanziata dal quantificatore esistenziale \esiste
es. b(X,Y) <- not a(X,Y) è un esempio di floundering se X e/o Y hanno modo -
NB. con il quantificatore universale \per_ogni non c'è floundering, ad es. va bene scrivere not a(X,_) perchè l'underscore quantifica universalmente.
2. Reti semantiche
==================
Significato di prop(X,Y,Z):
- X è un oggetto
- Y è una proprietà
- Z è un valore
La rappresentazione grafica vede l'oggetto e il valore rappresentati da due rettangoli distinti, e la proprietà da una freccia che collega l'oggetto al valore.
3. Meta programmazione
======================
Un meta interprete ha la seguente struttura:
linguaggio oggetto ----sintassi-astratta-----> termini prolog (aperti o ground) -----regole-di-ragionamento-(interprete)-----> Prolog
Come riferimento, per comprendere come funziona una meta interpretazione, vedere ad es. la meta object facility (MOF) definita in UML (Unified Modeling Language) [la MOF non è nel programma per il compitino!].
4. Ragionamento basato su assunzioni
===================================
- nei casi di default (es. assunzioni di normalità tipo "gli uccelli normalmente volano", ...)
- nei casi di abduzione (es. diagnosi dei guasti di un impianto elettrico)
4.1 Ragionamento basato su assunzioni nei casi di default
---------------------------------------------------------
Il ragionamento parte da fatti F, veri, e da assunzioni H (ipotesi).
Considero D come un sottoinsieme di H (è quindi una parte delle assunzioni).
Uso D per inferire g: D |= g
Posso anche scrivere: KB U D |= g (dove KB è la solita knowledge base).
es.
H = {not a, not b}
F = {a, b}
KB = {a <- not b, b <- not a}
allora
D = {not a, not b} non è consistente, perchè secondo la KB not b implica a e non possono essere veri sia a che non a (idem per b e not b).
D = {not a} è consistente perchè non c'è nessun assurdo, inferisco b, il modello è b
D = {not b} è consistente perchè non c'è nessun assurdo, inferisco a, il modello è a
NB: a e b sono quindi i due modelli minimali.
4.1 Ragionamento basato su assunzioni nei casi di abduzione
-----------------------------------------------------------
E' il contrario del caso di default.
Considerando sempre D |= g, nei casi di abduzione osservo qualcosa in g e mi chiedo perchè vale true secondo le mie ipotesi D.
Mentre nel caso di default ragiono in avanti, da D a g, nel casi di abduzione ragiono all'indietro, da g a D. |
|
|
|
|
