Logica in informatica

Transcript

1 Logica La logica è lo studio del ragionamento. Obiettivo: analizzare e rappresentare la forma dei ragionamenti, in base alla quale si può determinare se siano corretti o no. Logica in informatica Formalismo per rappresentare conoscenza in Intelligenza Artificiale Strumento metodologico per l informatica (prova di proprietà di programmi) Alla base della programmazione logica (risoluzione di un problema riconducibile all essere un teorema ) Alla base della programmazione funzionale (λ-calcolo) Risultati d impatto sull informatica teorica Programmazione Funzionale (Roma Tre) 11: Logica 1 / 25

2 Logica proposizionale (booleana) Linguaggio formale (sintassi + semantica) + Sistema di inferenza Sintassi: insieme delle espressioni ben formate (linguaggio) Semantica: interpretazione M del linguaggio Logica classica: rappresentazione di conoscenza dichiarativa e studio delle forme di ragionamento su questo tipo di conoscenza Ragionamento logico: non si basa su alcuna proprietà degli oggetti o concetti coinvolti nel ragionamento, si astrae dal contenuto specifico del ragionamento per considerare solo la sua forma. Logica proposizionale: gli elementi di base (atomici) sono proposizioni 1. SE c è il sole, ALLORA fa caldo 2. c è il sole QUINDI: fa caldo Forma comune: 1. SE A, ALLORA B 2. A QUINDI: B 1. SE il compito è sufficiente, ALLORA sei esonerato dallo scritto 2. il compito è sufficiente QUINDI: sei esonerato dallo scritto A B B Programmazione Funzionale (Roma Tre) 11: Logica 2 / 25 A

3 Logica Classica Elementi di base: proposizioni (o enunciati), che possono essere VERE o FALSE Logica proposizionale: ogni enunciato è un atomo non ulteriormente analizzabile Caino è fratello di Abele è rappresentato da un atomo p A ogni paziente piace qualche dottore è rappresentato da un atomo q Gli enunciati semplici (atomi o variabili proposizionali) possono essere composti per formare enunciati complessi (formule proposizionali), mediante operatori logici (connettivi proposizionali, o operatori booleani): NOT (negazione) IF/THEN (implicazione) AND (congiunzione) IFF (doppia implicazione) OR (disgiunzione) Programmazione Funzionale (Roma Tre) 11: Logica 3 / 25

4 Formule: esempi Caino è fratello di Abele OPPURE a ogni paziente piace qualche dottore Programmazione Funzionale (Roma Tre) 11: Logica 4 / 25

5 Formule: esempi Caino è fratello di Abele OPPURE a ogni paziente piace qualche dottore Caino NON è fratello di Abele p q Programmazione Funzionale (Roma Tre) 11: Logica 4 / 25

6 Formule: esempi Caino è fratello di Abele OPPURE a ogni paziente piace p q qualche dottore Caino NON è fratello di Abele p Caino è fratello di Abele E a ogni paziente piace qualche dottore Programmazione Funzionale (Roma Tre) 11: Logica 4 / 25

7 Formule: esempi Caino è fratello di Abele OPPURE a ogni paziente piace p q qualche dottore Caino NON è fratello di Abele p Caino è fratello di Abele E a ogni paziente piace qualche p q dottore SE Caino è fratello di Abele, ALLORA a ogni paziente piace qualche dottore Programmazione Funzionale (Roma Tre) 11: Logica 4 / 25

8 Formule: esempi Caino è fratello di Abele OPPURE a ogni paziente piace p q qualche dottore Caino NON è fratello di Abele p Caino è fratello di Abele E a ogni paziente piace qualche p q dottore SE Caino è fratello di Abele, ALLORA a ogni paziente p q piace qualche dottore Caino è fratello di Abele SE E SOLO SE a ogni paziente piace qualche dottore Programmazione Funzionale (Roma Tre) 11: Logica 4 / 25

9 Formule: esempi Caino è fratello di Abele OPPURE a ogni paziente piace p q qualche dottore Caino NON è fratello di Abele p Caino è fratello di Abele E a ogni paziente piace qualche p q dottore SE Caino è fratello di Abele, ALLORA a ogni paziente p q piace qualche dottore Caino è fratello di Abele SE E SOLO SE a ogni paziente p q piace qualche dottore Ricorsivamente: SE Caino NON è fratello di Abele, ALLORA Caino è fratello di Abele OPPURE a ogni paziente piace qualche dottore Programmazione Funzionale (Roma Tre) 11: Logica 4 / 25

10 Formule: esempi Caino è fratello di Abele OPPURE a ogni paziente piace p q qualche dottore Caino NON è fratello di Abele p Caino è fratello di Abele E a ogni paziente piace qualche p q dottore SE Caino è fratello di Abele, ALLORA a ogni paziente p q piace qualche dottore Caino è fratello di Abele SE E SOLO SE a ogni paziente p q piace qualche dottore Ricorsivamente: SE Caino NON è fratello di Abele, ALLORA Caino è fratello di Abele OPPURE a ogni paziente piace qualche dottore p (p q) Programmazione Funzionale (Roma Tre) 11: Logica 4 / 25

11 Logica Proposizionale Classica La logica proposizionale studia il significato dei connettivi e le forme di ragionamento corretto rappresentabili mediante formule proposizionali Sintassi: la sintassi di un linguaggio determina quali sono le espressioni corrette del linguaggio. Espressioni della logica proposizionale: formule Un linguaggio proposizionale è costruito sulla base di un determinato insieme P di variabili (o lettere) proposizionali P = {p, q, r} P = {p 0, p 1, p 2,...} P = {caino_fratello_di_abele, pazienti_dottori,...} Alfabeto: P {,,,,, (, )} Linguaggio (insieme delle formule): sottoinsieme delle stringhe sull alfabeto della logica considerata Programmazione Funzionale (Roma Tre) 11: Logica 5 / 25

12 Sintassi: l insieme delle formule Sia P un insieme P di variabili proposizionali. L insieme delle formule proposizionali costruite sulla base di P, Prop[P], è definito induttivamente: 1 ogni variabile proposizionale è una formula 2 e sono formule 3 se A è una formula, allora anche A è una formula 4 se A e B sono formule, allora anche (A B), (A B), (A B), (A B) sono formule 5 nient altro è una formula Esempi: Se P = {p, q, r, s}, allora sono in Prop[P]: p, q, r, s,,, p, q, r, s,,, (p q), (p q), (q r), (r s),... (p q), ((p q) (q r)), ((q r) s),... ( (p q) ((p q) (q r))), ((q r) s) ),... Programmazione Funzionale (Roma Tre) 11: Logica 6 / 25

13 Rappresentazione delle formule e definizioni ricorsive su di esse Osservazione: non rappresentiamo la doppia implicazione type form = True False Prop of string Not of form And of form * form Or of form * form Imp of form * form (p q): Not (Imp (Prop "p",prop "q")) Programmazione Funzionale (Roma Tre) 11: Logica 7 / 25

14 Rappresentazione delle formule e definizioni ricorsive su di esse Osservazione: non rappresentiamo la doppia implicazione type form = True False Prop of string Not of form And of form * form Or of form * form Imp of form * form (p q): Not (Imp (Prop "p",prop "q")) (* atomlist : form -> string list *) let rec atomlist = function True False -> [] Prop s -> [s] Not f -> atomlist f Or(f1,f2) -> union (atomlist f1) (atomlist f2) And(f1,f2) -> union (atomlist f1) (atomlist f2) Imp(f1,f2) -> union (atomlist f1) (atomlist f2) Programmazione Funzionale (Roma Tre) 11: Logica 7 / 25

15 Moduli e file Vogliamo arrivare a scrivere un parser per le formule proposizionali. A questo scopo conviene racchiudere la dichiarazione del tipo form in un file a parte, che andrà a costituire un modulo, come i moduli della libreria standard di OCaml. Creiamo il file language.ml che contiene soltanto la dichiarazione del tipo form (CODICE/11-logica/language.ml). Occorre poi compilare il modulo, dando il comando (da una command shell): > ocamlc -c language.ml che genera i file language.cmi (l interfaccia compilata del modulo) e language.cmo (bytecode del modulo Language). Per caricare in memoria il modulo Language: # #load "language.cmo";; Ma i costruttori sono relativi al modulo Language: # Prop "p";; ====> Unbound constructor Prop # Language.Prop "p";; - : Language.form = Language.Prop "p" Programmazione Funzionale (Roma Tre) 11: Logica 8 / 25

16 Aprire i moduli Per evitare di scrivere Language.Prop, Language.And,..., occorre aprire il modulo: # open Language;; # Prop "p";; - : Language.form = Prop "p" D ora in poi assumiamo di scrivere le nostre definizioni in un file (logic.ml) che inizia con: #load "language.cmo";; open Language (il file, ovviamente, deve stare nella stessa directory in cui si trovano language.cmi e language.cmo). Programmazione Funzionale (Roma Tre) 11: Logica 9 / 25

17 Stampa di una formula Vai al codice file: CODICE/11-logica/logic.ml Programmazione Funzionale (Roma Tre) 11: Logica 10 / 25

18 Convenzioni sull uso delle parentesi si possono omettere le parentesi esterne: (p q) si può scrivere p q associatività: da sinistra a destra (se non indicato altrimenti dall uso di parentesi) ((p q) r) si può scrivere p q r ((p q) r) si può scrivere p q r (p (q r)) NON si può scrivere p q r precedenza dei connettivi:,,,, (se non indicato altrimenti dall uso di parentesi) (p (q r)) si può scrivere p q r (p (q r)) si può scrivere (p q r) (p (q r)) NON si può scrivere p q r (p (q r)) NON si può scrivere p q r Quindi: s p q r abbrevia (s ((p q) r)) p (p r q) abbrevia (p (p (r q))) p q r s abbrevia ((p q) (r s)) p q r è diverso da p (q r) Programmazione Funzionale (Roma Tre) 11: Logica 11 / 25

19 Un parser per formule proposizionali Utilizziamo i costruttori di parser: ocamllex e ocamlyacc. Generatore di parser (compiler-compiler): strumento per la generazione del codice sorgente di un parser, a partire dalla descrizione data nella forma di grammatica (in genere BNF). I nomi derivano dai due più noti generatori di parser, Lex e Yacc. Lex: genera codice C per un lexical analyzer. Yacc: Yet Another Compiler Compiler!. A partire dalla grammatica, genera un parser o analizzatore sintattico (in C): la sequenza di token prodotta dall analisi lessicale è organizzata in un albero sintattico. In OCaml: ocamllex produce il codice OCaml dell analizzatore lessicale corrispondente ai pattern specificati in un file con estensione mll. ocamlyacc produce il codice OCaml di un parser, corrispondente alla grammatica specificata nel file (con estensione mly). Programmazione Funzionale (Roma Tre) 11: Logica 12 / 25

20 La dichiarazione dei simboli terminali Un file mly inizia con un header (codice OCaml che verrà copiato all inizio del file con il parser) e la dichiarazione dei simboli terminali (token) della grammatica. Nel nostro caso, il file parser.mly (in CODICE/11-logica) inizia con: %{ open Language %} %token <string> ATOM %token TRUE FALSE NOT AND OR IMP IFF RPAREN LPAREN EOF END %left IFF %left IMP %left OR %left AND %nonassoc NOT Le dichiarazioni %left, %right e %nonassoc associano la precedenza e l associatività ai simboli corrispondenti. Ogni simbolo ha precedenza più alta di quelli che lo precedono. Programmazione Funzionale (Roma Tre) 11: Logica 13 / 25

21 Dichiarazione degli entry point Il file prosegue con la dichiarazione degli entry point della grammatica: %start formula %type <Language.form> formula Per ogni entry point, il modulo prodotto da ocamlyacc avrà una funzione con lo stesso nome. val formula : (Lexing.lexbuf -> token) (* tipo della funzione di lexing *) -> Lexing.lexbuf (* tipo dei lexer buffer, tipo astratto del modulo Lexing *) -> Language.form Programmazione Funzionale (Roma Tre) 11: Logica 14 / 25

22 La grammatica Ogni simbolo non terminale deve essere definito mediante regole sintattiche, che associano un attributo (espressione OCaml) a ogni caso di espansione. formula : ATOM { Prop($1) } TRUE { True } FALSE { False } NOT formula { Not $2} formula IFF formula { And(Imp($1,$3),Imp($3,$1)) } formula IMP formula { Imp($1,$3) } formula OR formula { Or($1,$3) } formula AND formula { And($1,$3) } LPAREN formula RPAREN { $2 } ; A ogni sequenza di simboli (parte sinistra) è associato un attributo semantico, nella parte destra: questo sarà valutato a riportato come valore nel caso corrispondente. Nella parte destra: $1 corrisponde all attributo del primo simbolo della corrispondente parte sinistra, $2 quello del secondo simbolo, ecc. Programmazione Funzionale (Roma Tre) 11: Logica 15 / 25

23 L analisi lessicale (I) I file con estensione mll contengono un insieme di espressioni regolari con associata azione semantica (un Parser.token). Il file inizia con un header: { open Parser } E la definizione dell entry point token: Vai al codice CODICE/11-logica/lexer.mll rule token = parse (* keywords *)... Per ogni entry point (possono essercene diversi), il file lexer.ml prodotto da ocamllex conterrà la definizione di una corrispondente funzione di lexing: val token : Lexing.lexbuf -> Parser.token Programmazione Funzionale (Roma Tre) 11: Logica 16 / 25

24 L analisi lessicale (II) rule token = parse [ \t \n ] { token lexbuf } "T" { TRUE } "F" { FALSE }... La funzione è definita per casi: a sinistra c è un espressione regolare, a destra l attributo semantico associato. token lexbuf: applicare la funzione token al (resto del) lexer buffer. [ a - z A - Z ] [ a - z A - Z 0-9 _ ]* { ATOM(Lexing.lexeme lexbuf) } A sinistra: espressione regolare, a destra: Lexing.lexeme lexbuf riporta la stringa corrispondente all espressione regolare letta. Programmazione Funzionale (Roma Tre) 11: Logica 17 / 25

25 I moduli Abbiamo compilato il file language.ml, generando il file language.cmo (il modulo Language): ocamlc -c language.ml Ora è possibile generare il parser: ocamlyacc parser.mly ocamllex lexer.mll OCamlyacc genera parser.ml (modulo) e parser.mli (l interfaccia); OCamllex genera lexer.ml. Ora possiamo compilare questi file: ocamlc -c parser.mli parser.ml lexer.ml generando i corrispondenti file cmi e cmo. Per utilizzarli, da una shell OCaml: #load "language.cmo";; #load "parser.cmo";; #load "lexer.cmo";; Ora abbiamo a disposizione i moduli Language, Parser e Lexer. Programmazione Funzionale (Roma Tre) 11: Logica 18 / 25

26 Uso del parser (e dei moduli) in modalità interattiva Lexer.token: Lexing.lexbuf -> Parser.token Parser.formula: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> Language.form Parser.formula Lexer.token: Lexing.lexbuf -> Language.form Per analizzare una stringa, si deve trasformare in un Lexing.lexbuf Lexing.from_string: string -> lexbuf #load "language.cmo";; open Language;; #load "parser.cmo";; #load "lexer.cmo";; (* parse: string -> Language.form *) (* solleva Parsing.parse_error in caso di fallimento *) let parse stringa = let lexbuf = Lexing.from_string stringa in Parser.formula Lexer.token lexbuf Vai al codice Programmazione Funzionale (Roma Tre) 11: Logica 19 / 25

27 Compilazione separata e codice eseguibile (ocamlc) I nomi dei file <nome-file>.mli: codice sorgente per interfacce. La compilazione produce un interfaccia compilata nel file <nome-file>.cmi <nome-file>.ml: codice sorgente per unità di compilazione. La compilazione produce bytecode nel file <nome-file>.cmo Per compilare separatamente un unità o un interfaccia: ocamlc -c <nome-file>.mli ocamlc -c <nome-file>.ml Mediante linking del bytecode (file.cmo) si ottiene un programma eseguibile indipendente. ocamlc -o <nome-programma> <file_1.cmo>... <file_n.cmo> ocamlc -o <nome-programma> <f1.mli> <f1.ml>... <fn.ml> Per eseguire il programma, si invoca l interprete di bytecode: ocamlrun <nome-programma> Programmazione Funzionale (Roma Tre) 11: Logica 20 / 25

28 Compilazione di programmi stand-alone ocamlc -custom -o <nome-programma>... (per la creazione di programma stand-alone su sistemi Windows, vedere il sito di OCaml) Programmazione Funzionale (Roma Tre) 11: Logica 21 / 25

29 Moduli e file Contenuto del file queue.mli (* interfaccia per le code *) type a t exception Empty val Tempty : a t val dequeue : a t -> a t val head : a t -> a val enqueue : a t -> a -> a t val null : a t -> bool Contenuto del file queue.ml: type a t = a list * a list exception Empty let norm = function... let empty = ([],[]) let dequeue =... let head =... let enqueue (h,t) x =... let null q = q = ([],[]) Il compilatore riconosce un modulo Queue, la cui segnatura è quella specificata in queue.mli. queue.mli definisce l interfaccia del file di nome queue.ml. Il tipo concreto utilizzato per rappresentare le code è nascosto. (vedere capitolo 5 del libro) Programmazione Funzionale (Roma Tre) 11: Logica 22 / 25

30 Accesso al contenuto di una unità di compilazione Le altre unità di compilazione (altri file), possono accedere al contenuto del file queue.mli (al modulo Queue) nello stesso modo in cui accedono ai moduli della libreria standard: if Queue.null (Queue.enqueue Queue.empty 3) then... Ovviamente vedono soltanto ciò che è specificato nell interfaccia. Per caricare bytecode in modalità interattiva: #load "queue.cmo";; Programmazione Funzionale (Roma Tre) 11: Logica 23 / 25

31 Esecuzione di un programma compilato Se vogliamo eseguire un programma creato con ocamlc -o <nome-programma>... il file principale (quello dal quale non dipende nessun altro), deve contenere una richiesta di valutazione che dia l avvio all esecuzione. Ad esempio: let _ = <Espressione-da-valutare> È anche possibile scrivere programmi che accettano argomenti: vedere il modulo Arg della libreria standard. Programmazione Funzionale (Roma Tre) 11: Logica 24 / 25

32 Esempio Abbiamo scritto i file language.ml, lexer.mll e parser.mly, abbiamo creato il parser (i file lexer.ml, parser.mli e parser.mly): ocamlc -c language.ml ocamlyacc parser.mly ocamllex lexer.mll Ora scriviamo un file prova.ml con il seguente contenuto: Vai al codice CODICE/11-logica/prova.ml Compiliamo, creando il file prova, e possiamo eseguirlo: ocamlc -o prova language.ml parser.mli parser.ml \ lexer.ml prova.ml ocamlrun prova Programmazione Funzionale (Roma Tre) 11: Logica 25 / 25