Scarica Struttura della classe P e trattabilità - Fondamenti di Informatica - Modulo 2, 2016/2017 e più Sintesi del corso in PDF di Fondamenti di informatica solo su Docsity!
Fondamenti di Informatica - modulo 2 2016/2017 M.Di Ianni
La classe P
Indice
8.1 Classe P e trattabilita........................................... 2 8.2 La struttura della classe P......................................... 2 8.3 Il problema 2-SODDISFACIBILIT A.................................... 3 8.4 Il problema 2-COLORABILIT A`...................................... 6 8.5 Trasformazione di una funzione booleana in forma congiuntiva normale................ 8
In questa dispensa studiamo la classe P. Inizialmente, cerchiamo di capire perch´e la classe P e considerata la classe deiproblemi trattabili computazionalmente. Successivamente, dopo avere brevemente descritto la (semplice) struttura di questa classe, presenteremo qualche esempio di dimostrazione di appartenenza di problemi alla classe P. Ricordando quanto dimostrato nella Didpensa 6 circa la correlazione polinomiale fra macchine di Turing e programmi scritti nel linguaggio PascalMinimo, potremo riferirci a programmi scritti in tale linguaggio piuttosto che a macchine di Turing per dimostrare l’appartenenza di un linguaggio (o, equivalentemente, di un problema decisionale) alla classe P. Nel Paragrafo 8.3 torniamo ad occuparci di funzioni booleane in forma congiuntiva normale, mostrando che, se una funzione booleana fe in forma congiuntiva normale e le sue clausole contengono due letterali ciascuna, allora decidere se esiste una assegnazione di verita che soddisfa f richiede tempo polinomiale in | f |. Nel Paragrafo 8.4 definiamo il concetto di colorabilita di un grafo e dimostriamo che decidere se un grafo puo essere colorato con 2 colorie un problema in P. Infine, nel Paragrafo 8.5 mostriamo che trasformare una qualsiasi funzione booleana in forma congiuntiva normale richiede tempo polinomiale nelle sue dimensioni: si tratta di un esempio di algoritmo polinomiale che corrisponde ad una macchina di Turing di tipo trasduttore, ossia, di un algoritmo che calcola una funzione in FP. In tutti gli algoritmi che descriveremo in questa dispensa, per maggiore chiarezza, nella linea successiva a quella in cui viene specificato l’input, indicheremo anche l’output calcolato dall’algoritmo.
8.1 Classe P e trattabilit`a
La classe P e, genericamente, considerata la classe dei problemi` trattabili, ossia, dei problemi di cui si riesce a calcolare una soluzione in tempi ragionevoli. Cerchiamo, ora, di capire il significato del termine “ragionevole” e la portata della precedente affermazione.
Sia Γ un problema decisionale, e siano T 1 e T 2 due macchine di Turing deterministiche che lo decidono tali che, per ogni x ∈ IΓ, dtime(T 1 , x) ≤ 2 |x|^ e dtime(T 2 , x) ≤ |x|^2. Ragionando grossolanamente, supponiamo di disporre di un calcolatore in grado di eseguire 1000000000 = 109 istru- zioni di una macchina di Turing al secondo ed eseguiamo su tale calcolatore la computazione T 2 ( xˆ), per qualche ˆx ∈ IΓ tale che |x| = 106 : allora, il calcolatore termina la computazione in 10^12 / 109 = 1000 secondi, ossia, in poco pi`u di un quarto d’ora. Se, invece, utilizziamo lo stesso calcolatore per eseguire la computazione T 1 (x), allora dovremo attendere 210 6
109
6
2 9 log^2
6
290
(^6) − 90
210
4
secondi, ossia, piu di 2^10 3 anni: una quantita di tempo senza dubbio irragionevole! Dunque, intuitivamente, con la locuzione “in tempi ragionevoli” intendiamo riferirci ad un lasso di tempo che permetta all’interessato di utilizzare la risposta.
Osserviamo, ora, che, anche eseguendo sul calcolatore di cui all’esempio precedente la computazione T 3 ( xˆ), dove T 3 decide Γ e dtime(T 3 , x) ≤ |x|^3 , il tempo di attesa della risposta (dell’ordine di 10^9 secondi) e ancora estremamente minore di quello richiesto dalla computazione T 1 ( xˆ). In effetti, se indichiamo con Tk una macchina che decide Γ tale che dtime(Tk, x) ≤ |x|k. Perch´e il tempo di attesa della risposta della computazione Tk( xˆ sia paragonabile al tempo di attesa della risposta della computazione T 1 ( xˆ, l’esponente k deve essere tanto, tanto grande. E, anche una volta individuato un valore ˆk tale che | xˆ|kˆ^ ≈ 2 |^ xˆ|, per tutte le parole y ∈ IΓ tali che |y| ≥ 10 | xˆ|, si avra che |y|kˆ^ e infinitamente piu piccolo di 2|y|. Generalizzando (e ricordando la teoria dei limiti dall’analisi matematica), per ogni intero k ∈ N e per ogni funzione super-polinomiale f : N → N, esiste un n 0 tale che, per ogni n ≥ n 0 , nk^ e infinitamente pi`` u piccolo di f (n).
Per quanto osservato sino ad ora, un problema e considerato trattabile quando esiste una macchina di Turing determi- nistica (o, come vedremo a breve, un algoritmo) che lo decide in tempo polinomiale. Ossia, Pe la classe dei problemi trattabili.
8.2 La struttura della classe P
La classe P ha una struttura molto semplice. infatti, gia sappiamo che coP = P (Corollario 6.2 della Dispensa 6). Inoltre, i linguaggi (o, equivalentemente, i problemi decisionali) in P sono indistinguibili se confrontati per mezzo della riducibilita polinomiale, come dimostrato nel seguente teorema.
- S 2 SAT ( f , X) = {a : X → {vero, f also}};
- π 2 SAT ( f , XS 2 SAT ( f , X)) = ∃a ∈ S 2 SAT ( f , X) : f (a(X)).
Dimostriamo ora che 2-SAT appartiene alla classe P presentando un algoritmo polinomiale che, data f ∈ I2SAT, decide se f ∈ 2-SAT. Prima di affrontare questo compito, abbiamo bisogno di premettere alcune notazioni. Intanto, poich´e per soddisfare una funzione booleana f in forma 2-congiuntiva normale e necessario soddisfare tutte le clausole che la compongono, in quanto segue, per semplicita, rappresenteremo f nella forma di insieme di clausole piuttosto che nella forma di congiunzione di clausole. Poi, indichiamo con il termine letterale una variabile in X oppure la sua negazione: lh = xh oppure lh = ¬xh. In questo modo, possiamo sempre esprimere una clausola in f come la disgiunzione di due letterali, ossia, c (^) j = l (^) j 1 ∨ l (^) j 2. Osserviamo che, se cp = x 1 ∨x 2 = lp 1 ∨lp 2 e cq = ¬x 1 ∨x 3 = lq 1 ∨lq 2 , allora lp 1 6 = lq 1. Infine, se il letterale l corrisponde alla variabile booleana x, allora ¬l corrisponde a ¬x; viceversa, se il letterale l corrisponde alla variabile booleana ¬x, allora ¬l corrisponde a x. Infine, diciamo che un letterale lp e vincolato da x` i (o da ¬xi) se esiste in f la clausola xi ∨ lp (rispettivamente, la clausola ¬xi ∨ lp).
L’algoritmo che decide 2-SAT e basato sulla seguente, fondamentale, osservazione: ogni volta che assegniamo un valore di verita ad una variabile xi ∈ X, partizioniamo l’insieme delle clausole nei tre sottoinsiemi descritti di seguito.
- Se abbiamo assegnato ad xi il valore vero, allora ogni clausola di f che contiene il letterale xi e soddisfatta
indipendentemente dalla assegnazione di verita alla rimanente variabile che la compone; chiamiamo queste clausole soddisfatte da xi. Allo stesso modo, se abbiamo assegnato ad xi il valore falso, allora ogni clausola di f che contiene il letterale ¬xi e soddisfatta indipendentemente dalla assegnazione di verit`` a alla rimanente variabile; sono queste le clausole soddisfatte da ¬xi. - Se abbiamo assegnato ad xi il valore vero, allora ogni clausola di f che contiene il letterale ¬xi
e soddisfatta se e soltanto se l’altro letterale che compare in essa assume il valore vero; sono queste le clausole direttamente vincolate da xi. A loro volta, ogni clausola di f che contiene la negazione di un letterale che compare in una clausola direttamente vincolata da xi (che chiameremo clausola vincolata di livello 1 da xi)e soddisfatta se e soltanto se l’altro letterale assume valore vero. In generale, ogni clausola di f che contiene la negazione di un letterale che compare in una clausola vincolata di livello k da xi (che chiameremo clausola vincolate di livello k + 1 da xi) e soddisfatta se e soltanto se l’altro letterale assume valore vero. Dunque, assegnare ad xi il valore vero implica, ai fini della soddisfacibilita della funzione f , una assegnazione di verita ai letterali di tutte e sole le clausole che sono (direttamente o di qualsiasi livello) vincolate da xi. Allo stesso modo, assegnare ad xi il valore falso implica, ai fini della soddisfacibilita della funzione f , una assegnazione di verit`a ai letterali di tutte e sole le clausole che sono (direttamente o di qualsiasi livello) vincolate da ¬xi. - Se abbiamo assegnato ad xi il valore vero (o il valore falso), allora tutte le clausole di f che non sono vincolate dalla variabile xi (o dalla sua negazione) sono indipendenti da tale assegnazione.
Possiamo ora descrivere formalmente l’algoritmo che decide f ∈ 2-SAT, diretta conseguenza delle osservazioni sopra riportate.
L’algoritmo A:2SAT descritto in Tabella 8.1, codificato in linguaggio PascalMinimo (senza specificare le strutture dati che rappresentano le collezioni), e una successione di (al piu 2n) tentativi di assegnazioni di valori di verita alle variabili che compaiono in f , implementata mediante il ciclo while nelle linee 4-30: durante l’iterazione i-esima si tenta di assegnare un valore di verita (vero o falso) alla variabile xi, se ad essa non e gia stato assegnato alcun valore di verita durante le iterazioni precedenti. L’algoritmo utilizza tre variabili di tipo insieme, XA, LA e LV , che durante la i- esima iterazione del ciclo while hanno il seguente significato: XAe l’insieme delle variabili cui e stato definitivamente assegnato il valore vero o il valore falso durante qualche iterazione j con j < i (quindi, inizialmente, XA = 0),/ LA e l’insieme dei letterali cui si sta tentando di assegnare un valore di verit a durante l’iterazione i, e LVe l’insieme dei letterali vincolati da qualche letterale in LA. Come abbiamo premesso, durante l’i-esima iterazione del ciclo while alle linee 4-30, se alla variabile xi era stato assegnato in precedenza un valore di verita (ossia, xi 6 ∈ XA, linea 5 del codice), si verifica se ad xi si puo assegnare il
Input: f = {c 1 , c 2 ,... , cm}, con c (^) j = (c (^) j 1 ∨ c (^) j 2 ) e c (^) ji ∈ {x 1 ,... , xn} per ogni i = 1 , 2 e j = 1 ,... , m. Output: accetta o rigetta.
1 XA ← 0;/ 2 contradd ← falso; 3 i ← 1; 4 while (i ≤ n ∧ contradd = falso) do begin 5 if (xi 6 ∈ XA) then begin 6 LA ← {xi}; LA contiene i letterali cui stiamo tentando di assegnare un valore 7 LV ← {xi}; LV contiene i letterali che vincolano altri letterali 8 g ← f − {c (^) j = xi ∨ l per qualche letterale l}; eliminiamo da f le clausole soddisfatte da xi = vero 9 while (LV 6 = 0 / ∧ contradd = falso) do begin 10 estrai lh da LV ; 11 for (c ∈ g) do begin 12 if ([c = ¬lh ∨ ls] ∧ [¬ls 6 ∈ LA]) then LA ← LA ∪ {ls}; 13 else contradd ← vero; 14 LV ← LV ∪ {ls}; 15 g ← g − {c = ls ∨ l per qualche letterale l}; eliminiamo da g le clausole soddisfatte da ls = vero; 16 end 17 if (contradd = vero e xi ∈ LA) then begin 18 contradd ← falso; 19 LA ← {¬xi}; 20 LV ← {¬xi}; 21 g ← f − {c (^) j = ¬xi ∨ l per qualche letterale l}; 22 end 23 end 24 if (contradd = falso) then begin 25 XA ← XA ∪ {x ∈ X : ∃l ∈ LA[l = x ∨ l = ¬x]}; 26 f ← g; 27 end 28 end 29 i ← i + 1; 30 end 31 if (contradd = vero) then Output: rigetta; 32 else Output: accetta.
Tabella 8.1: Algoritmo A:2SAT.
- S 2 COL(G) = {c : V → { 1 , 2 }};
- π 2 COL(G, S 2 COL(G)) = ∃c ∈ S 2 COL(G) : ∀ u, v ∈ V [ c(u) = c(v) → (u, v) 6 ∈ E ] o, equivalentemente,
π 2 COL(G, S 2 COL(G)) = ∃c ∈ S 2 COL(G) : ∀(u, v) ∈ E [ c(u) 6 = c(v) ].
Invece di descrivere un algoritmo che risolve direttamente il problema 2-COLORABILIT A, mostriamo nel seguito una riduzione polinomiale da 2-COLORABILIT A a 2-SODDISFACIBILIT A; tale riduzione, insieme all’algoritmo che decide 2-SODDISFACIBILIT A, induce un algoritmo che decide 2-COLORABILIT A. Infatti, dato un grafo G istanza di 2-COLORABILIT A, tale algoritmo opera come segue:
- utilizzando la riduzione da 2-COLORABILIT A
a 2-SODDISFACIBILIT A, trasforma G in una funzione booleana f istanza di 2-SODDISFACIBILIT A`; - esegui l’algoritmo A:2SAT in Tabella 8.1 con input f.
Le proprieta della riduzione implicano che, se l’esecuzione dell’algoritmo A:2SAT con input f termina accettando f allora G e 2-colorabile, altrimenti G non e 2-colorabile. Quindi, l’algoritmo descritto dai punti 1) e 2) soprae corretto. Inoltre, esso opera in tempo polinomiale, infatti: il punto 1) richiede tempo polinomiale, perch´e esegue una riduzione polinomiale, e calcola una funzione f tale che | f | = p(|G|) per qualche polinomio p; infine, il punto 2) richiede tempo in O(| f |^3 ) = O(p(|G|)^3 ).
Descriviamo ora la riduzione da 2-COLORABILIT Aa 2-SODDISFACIBILIT A. Sia G = (V, E) un grafo non orientato; osserviamo che una funzione c : V → { 1 , 2 } `e una 2-colorazione per G se e soltanto se
∀(u, v) ∈ E : [(c(u) = 1 ) ∧ (c(v) = 2 )] ∨ [(c(u) = 2 ) ∧ (c(v) = 1 )].
Questo `e equivalente a
∀(u, v) ∈ E : [(c(u) = 1 ) ∧ ¬(c(v) = 1 )] ∨ [¬(c(u) = 1 ) ∧ (c(v) = 1 )] ,
da cui, applicando le leggi di De Morgan,
∀(u, v) ∈ E : {(c(u) = 1 ) ∨ [¬(c(u) = 1 ) ∧ (c(v) = 1 )]} ∧ {¬(c(v) = 1 ) ∨ [¬(c(u) = 1 ) ∧ (c(v) = 1 )]},
∀(u, v) ∈ E : [(c(u) = 1 ) ∨ ¬(c(u) = 1 )] ∧ [(c(u) = 1 ) ∨ (c(v) = 1 )]∧
∧[¬(c(v) = 1 ) ∨ ¬(c(u) = 1 )] ∧ [¬(c(v) = 1 ) ∨ (c(v) = 1 )],
∀(u, v) ∈ E : vero ∧ [(c(u) = 1 ) ∨ (c(v) = 1 )] ∧ [¬(c(v) = 1 ) ∨ ¬(c(u) = 1 )] ∧ vero,
ossia, G `e 2-colorabile se e soltanto se
∀(u, v) ∈ E : [(c(u) = 1 ) ∨ (c(v) = 1 )] ∧ [¬(c(v) = 1 ) ∨ ¬(c(u) = 1 )].
Possiamo, a questo punto, associare ad ogni nodo u di G la variabile booleana xu = (c(u) = 1 ) ed ottenere che G `e 2-colorabile se e soltanto se
∀(u, v) ∈ E : (xu ∨ xv) ∧ (¬xu ∨ ¬xv)
e soddisfacibile. `
Denotiamo ora con E = {e 1 ,... , em} l’insieme degli archi di G e con ei = (ui, vi) l’i-esimo arco. Allora, possiamo concludere che G e 2-colorabile se e soltanto se l’istanza di 2-SODDISFACIBILIT A
f (G) = (xu 1 ∨ xv 1 ) ∧ (¬xu 1 ∨ ¬xv 1 ) ∧ (xu 2 ∨ xv 2 ) ∧ (¬xu 2 ∨ ¬xv 2 ) ∧... ∧ (xum ∨ xvm ) ∧ (¬xum ∨ ¬xvm )
e soddisfacibile. Banalmente, il calcolo di ` f (G) richiede tempo polinomiale: infatti, ad ogni arco in G corrisponde in f (G) un insieme di un numero costante (pari a 2) di clausole ed il calcolo di ciascuna di esse richiede tempo polinomiale in |G|.
Input: formula booleana f , contenente i soli operatori ∧, ∨, ¬, e priva di quantificatori esistenziali e universali. Output: insieme C di clausole. 1 C ← 0;/ 2 Y ← 0;/ 3 CNF-RIC( f , C, Y ); 4 Output: C.
Tabella 8.2: Algoritmo A:toCNF.
8.5 Trasformazione di una funzione booleana in forma congiuntiva normale
Ci proponiamo, in questo paragrafo, di dimostrare il teorema seguente.
Teorema 8.2: Data una qualunque formula booleana f contenente i soli operatori ∧, ∨ e ¬ , e possibile derivare da essa in tempo polinomiale una formula booleana f ′^ in forma congiuntiva normale tale che f ′^e soddisfacibile se e soltanto se f `e soddisfacibile.
Dimostrazione:. Osserviamo, innanzi tutto, che, poich´e f contiene i soli operatori ∧, ∨ e ¬, allora una delle seguenti eventualit`a deve necessariamente verificarsi:
- esistono due funzioni booleane, f 1 ed f 2 , contenenti i soli operatori ∧, ∨ e ¬, tali che
f = f 1 ∧ f 2 ;
- esiste una funzione booleana f 1 contenente i soli operatori ∧, ∨ e ¬, tale che
f = ¬ f 1 ;
- esistono due funzioni booleane, f 1 ed f 2 , contenenti i soli operatori ∧, ∨ e ¬, tali che
f = f 1 ∨ f 2.
Nel primo caso, per dimostrare il teorema, e sufficiente dimostrarlo separatamente per f 1 e per f 2. Nel secondo caso,e necessario applicare le leggi di De Morgan e ridursi ad uno degli altri due casi. Infine, nel terzo caso osserviamo che, se denotiamo con y una variabile booleana che non compare in f , allora f e equivalente alla formula( f 1 ∨ y) ∧ (¬y ∨ f 2 ). Pertanto, in questo terzo caso, f ′^ viene derivata calcolando una formula f 1 ′ in forma CNF ed equivalente ad f 1 e una formula f 2 ′ in forma CNF ed equivalente ad f 2 e, successivamente, applicando la proprieta distributiva dell’operatore ∨ alle due sotto-formule ( f 1 ′ ∨ y) e (¬y ∨ f 2 ′). Osserviamo che questa ultima operazione si implementa semplicemente aggiungendo a ciascuna clausola di f 1 ′ il letterale y ed a ciascuna clausola di f 2 ′ il letterale ¬y.
Queste osservazioni conducono naturalmente alla definizione dell’algoritmo ricorsivo A:toCNF descritto in Tabel- la 8.2. dove CNF-RIC e la funzione ricorsiva, descritta in Tabella 8.3. Essa utilizza tre parametri,g, D e Z, che hanno semantica differente: il parametro g e un parametro di input, ossia, viene utilizzato nella funzione in sola lettura, men- tre D e Z sono parametri di output, ossia, vengono modificati nel corso dell’esecuzione della funzione e le modifiche rimangono visibili al termine dell’esecuzione (in analogia con i parametri di tipo puntatore nel linguaggio C, o di tipo riferimento nel linguaggio Java). In particolare, il parametro D e l’insieme delle clausole costruite sulla funzioneg ad un certo istante della computazione: la prima invocazione di CNF-RIC da parte dell’algoritmo A:toCNF avviene con tale parametro inizializzato all’insieme vuoto e, al termine delle invocazioni ricorsive, essoe l’insieme delle clausole corrispondente a g.
Calcoliamo ora la complessit`a dell’algoritmo A:CNF, che coincide con quella della funzione CNF-RIC. Indichiamo con TRIC( f ) il numero di passi eseguiti dalla funzione CNF-RIC con input f. Dalla definizione di CNF-RIC segue che
TRIC( f ) =
| f | + TRIC( f 1 ) se f = ¬ f 1 TRIC( f 1 ) + TRIC( f 2 ) se f = f 1 ∧ f 2 4 + TRIC( f 1 ) + |D 1 | + TRIC( f 2 ) + |D 2 | se f = f 1 ∨ f 2 | f | se f e una disgiunzione di letterali`.
- Se f = f 1 ∨ f 2 , allora TRIC( f ) = 4 + |D 1 | + |D 2 | + TRIC( f 1 ) + TRIC( f 2 ) con |D 1 | + |D 2 | ≤ | f |, | f 1 | + | f 2 | = k, | f 1 | = k 1 < k e | f 2 | = k 2 < k. Allora, dall’ipotesi induttiva segue che
TRIC( f ) = 4 + | f | + TRIC( f 1 ) + TRIC( f 2 ) = k + 5 + TRIC( f 1 ) + TRIC( f 2 ) ≤ k + 5 + 5 k^21 + 5 k^22 = k + 5 + 5 (k^21 + k^22 ) ≤ k + 5 + 5 (k 1 + k 2 )^2 = k + 5 + 5 k^2 < 5 (k + 1 )^2.
Questo conclude la prova del teorema. 2
