Upload
hoangtu
View
225
Download
0
Embed Size (px)
Citation preview
HTTP://WWW.BERTADANILO.NAME
Tecniche di analisi dei
requisiti e modelli software. Le tabelle decisionali, le macchine a stati finiti e le
reti di Petri nella descrizione dei requisiti e del
software.
Danilo Berta
18/03/2013
[Versione 1.1]
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 2 di 91
Contenuti
Introduzione ................................................................................................................................................ 4
Capitolo 1 - Tabelle Decisionali .................................................................................................................... 7
Definizione di tabella decisionale ............................................................................................................. 8
Logic Friday .............................................................................................................................................14
Care or don’t care ? .............................................................................................................................17
Esempio # 1 – il form di registrazione utente ..........................................................................................21
Tabelle funzionali ....................................................................................................................................25
Riduzione della tabella funzionale in decisionale .................................................................................25
Il caso degenere della funzione ...........................................................................................................27
Esempio # 2 – la scuola guida ..................................................................................................................29
Esempio #3 - un caso un po’ complesso. .................................................................................................32
Riduzione delle tabelle di decisione .....................................................................................................36
Capitolo 2 – Automa a stati finiti .................................................................................................................42
Definizione di automa o macchina a stati finiti ........................................................................................43
Esempio #4 – Le scuole medie inferiori ...................................................................................................43
Riduzione di un ASF in tabella decisionale. ..........................................................................................45
Esempio #4bis – vacanza o studio punitivo? ............................................................................................48
Definizione formale di automa agli stati finiti in termini di tabella decisionale. ........................................51
Capitolo 3 – Reti di Petri .............................................................................................................................52
Definizioni ...............................................................................................................................................53
Dinamicità nelle reti di Petri: i token. ......................................................................................................55
Esempio # 5 – Cucire le … stringhe! .........................................................................................................61
Valore semantico e definizioni formali ....................................................................................................64
Descrizione operativa di una rete di Petri. ...............................................................................................70
Combinazioni parziali distinte di N numeri interi. ....................................................................................72
Vasi, tubi e palline... ................................................................................................................................73
Algoritmo di soluzione del problema fondamentale per una rete di Petri ................................................77
Passo # 1 – Aggiunta delle combinazioni distinte a ti,j ..........................................................................78
Passo # 2 – Riduzione dei valori nelle colonne con più valori negativi ..................................................78
Passo # 3 – Calcolo della configurazione finale. ...................................................................................79
Calcolo delle successive configurazioni. ...............................................................................................80
Un esempio più complesso..................................................................................................................84
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 3 di 91
Altro esempio: numero token maggiore della somma delle molteplicità del posto. .............................86
Ultimo esempio: più configurazioni finali.............................................................................................87
Reti di Petri binarie .................................................................................................................................89
Nota conclusiva ..........................................................................................................................................91
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 4 di 91
# Numero versione Data Pubblicazione Descrizione
2 1.1 29 marzo 2012 Aggiunti i seguenti paragrafi: • Descrizione operativa di una rete di Petri.
• Combinazioni parziali distinte di N numeri interi.
• Vasi, tubi e palline...
• Algoritmo di soluzione del problema
fondamentale per una rete di Petri
• Passo # 1 – Aggiunta delle combinazioni distinte
a ti,j
• Passo # 2 – Riduzione dei valori nelle colonne
con più valori negativi
• Passo # 3 – Calcolo della configurazione finale.
• Calcolo delle successive configurazioni.
• Un esempio più complesso
• Altro esempio: numero token maggiore della
somma delle molteplicità del posto.
• Ultimo esempio: più configurazioni finali
• Reti di Petri binarie
1 1.0 18 marzo 2013 Versione iniziale
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 5 di 91
Introduzione
Nel linguaggio verbale (scritto e parlato) il verbo indica l’azione che è svolta dal soggetto. Nella lingua
italiana i tempi e modi dei verbi sono i seguenti:
Figura 1 – Schema dei tempi e modi dei verbi italiani
Nella tabella che segue riportiamo la descrizione dei modi verbali, copiata integralmente dalla pagina web
http://grammatica-italiana.dossier.net/grammatica-italiana-10.htm:
# Modo verbale Descrizione
1 Indicativo È il modo della realtà e della certezza ed esprime un fatto reale o supposto come tale.
2 Infinito È uno dei modi indefiniti del verbo ed esprime genericamente l'idea del verbo senza determinazione di persona e di numero.
3 Participio È così detto perché partecipa della funzione nominale come un aggettivo e si usa in funzione attributiva, predicativa e verbale.
4 Gerundio Esprime un complemento di mezzo, di modo o di maniera, di coincidenza (simultaneità), in genere un'azione secondaria rispetto alla principale.
5 Congiuntivo È il modo che esprime una azione possibile, incerta o desiderata.
6 Condizionale È il modo dell'incertezza e dell'irrealtà.
Tabella 1 – Descrizione dei modi dei verbi nella lingua italiana
Non vogliamo tenere una lezione di grammatica. Vogliamo semplicemente evidenziare che, per esprimere
un concetto, la lingua italiana (ma anche altri idiomi, in modi diversi) permette costrutti raffinati e ricchi di
decorazioni. Ora, riducendosi all’osso, osserviamo che i modi verbali possono essere ridotti in due grandi
classi:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 6 di 91
1. ASSOLUTA, quando – indipendentemente dal tempo passato, presente o futuro – si vuole
esprimere una azione CERTA.
2. CONDIZIONALE, quando – indipendentemente dal tempo passato, presente o futuro – si vuole
esprimere una azione che avrà luogo SE SI VERIFICANO DETERMINATE CONDIZIONI.
Un software è costruito con due elementi di base (1):
1. Istruzioni
2. Costrutti condizionali (singoli o multipli)
Le istruzioni sono elementi fondamentali che sono sempre eseguiti, mentre i costrutti condizionali (if, iif,
switch, case, etc) permettono l’esecuzione delle istruzioni quando è verificata una o più condizioni. Il
confronto con le classi Assoluta e Condizionale è immediato.
Quando si ha a che fare con la progettazione di un sistema software, ci si trova a dover gestire dei requisiti
espressi in linguaggio naturale e posti nella forma:
“Se accade questo e quest’altro, fai quest’ azione; altrimenti se occorre la condizione A oppure la B, fai una
seconda azione”.
Semplificando, abbiamo a che fare con dei costrutti che richiedono che, dato il verificarsi di certe
condizioni, devono essere svolte certe azioni. Le condizioni possono essere (e in genere lo sono) molto
complesse e lo stesso vale per le azioni che devono essere svolte. In altre parole dobbiamo – nell’analisi dei
requisiti – sfrondare la complessità del linguaggio verbale, fondato su sei modi verbali e su una dozzina di
tempi, in due classi: ASSOLUTO (si fa) o CONDIZIONALE (si fa a condizione che).
Le azioni possono essere descritte come sottorequisiti (per i quali valgono comunque la logica condizioni →
azioni e come tali vanno analizzati), oppure possono essere considerati come algoritmi o funzioni, oppure
ancora possono essere delle altre condizioni (ad esempio, se x è divisibile per 2 – condizione – allora x è pari
, che può essere interpretato come una nuova condizione).
Analizzare un requisito significa innanzi tutto individuare azioni e condizioni e quindi correlare questi due
elementi tra di loro.
Le tabelle decisionali possono essere utilizzate per descrivere i requisiti sotto forma di condizioni e di azioni.
1 Si dovrebbe tenere conto anche dei costrutti ciclici (for, do-while, while, etc..), ma tali costrutti non fanno altro che
eseguire più volte istruzioni e condizioni.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 7 di 91
Capitolo 1 - Tabelle Decisionali
TTAABBEELLLLEE DDEECCIISS IIOONNAALLII
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 8 di 91
Definizione di tabella decisionale
Quanto riportato in Tabella 2 rappresenta una tabella decisionale :
Condizioni 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
A – Condizione # 1 T T F F T T F F T T F F T T F F
B - Condizione # 2 T F T F T F T F T F T F T F T F
C - Condizione # 3 T T T T F F F F T T T T F F F F
…. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
N - Condizione # N T .. .. .. .. .. .. .. .. .. .. .. .. .. .. F
Azioni
F0: Azione # 1 1 1 1 1 1 1 1 1 1
F1: Azione # 2 1 1 1 1 1 1 1 1 1
… .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
F(N-1) : Azione # N+1 1 1 1 1 1 1 1 1 1 Tabella 2 – Struttura di Tabella Decisionale
La prima colonna è divisa in due parti: la sezione “alta” contiene le condizioni booleane, una per ogni riga.
La sezione “bassa” contiene le azioni che devono essere eseguite, quando sono verificate le corrispondenti
azioni . Nella nostra tabella, le colonne sono numerate per maggior chiarezza, ma non vi è nessun obbligo di
numerarle; la nostra numerazione parte da 0, cosa che potrebbe sembrare un po’ strana; nel prossimo
capitolo capiremo il perché.
Chiariamo ora la modalità di lettura della tabella decisionale e consideriamo la colonna # 0. La colonna # 0
può essere interpretata con la seguente espressione:
Quando (A è vera) e (B è vera) e (C è vera) … e (N è vera) allora (Eseguo F0) e (Eseguo F1) e (Eseguo FN)
Analogamente, per la colonna # 6 si ha:
Quando (A è falsa) e (B è vera) e (C è falsa) … allora (Eseguo F1) …
Con il linguaggio booleano, possiamo scrivere:
Colonna # 0: (A=True) AND (B=True) AND (C=True) → (F0 = True) AND (F1 = True) AND (FN = True)
Colonna # 6: (A=False) AND (B=True) AND (C=False) → (F1 = True)
Ricordiamo che:
a) Una condizione booleana (o semplicemente condizione) può sempre e solo assumere uno dei due
valori TRUE o FALSE, indicati anche come T o F oppure ancora 1 o 0;
b) Le condizioni booleane che compaiono nella stessa colonna sono in AND;
c) Le azioni che compaiono nella stessa colonna sono in AND;
d) Le condizioni booleane sono da considerarsi indipendenti tra di loro.
Chiariamo che cosa s’intende per condizione booleana indipendente o dipendente con un esempio.
Consideriamo le seguenti affermazioni:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 9 di 91
1. Avere i capelli biondi
2. Avere gli occhi scuri
Una persona può avere gli occhi scuri o chiari indipendentemente dal colore dei capelli. Se considero le due
affermazioni sopra come condizioni, posso sempre scrivere la seguente tabella:
Condizione # 1: Avere i capelli biondi Condizione # 2: Avere gli occhi scuri
TRUE TRUE TRUE FALSE
FALSE TRUE FALSE FALSE
Tabella 3 – Condizioni indipendenti.
Tutte le possibili combinazioni (C1,C2) di valori TRUE e FALSE sono ammissibili; non vi sono vincoli tra le due
condizioni. Le condizioni booleane C1 e C2 sono in questo caso indipendenti.
Consideriamo invece le seguenti affermazioni concernenti uno stesso individuo:
1. Essere maggiorenne
2. Avere un’età inferiore a 18 anni.
Considerando le due affermazioni sopra come condizioni, possiamo scrivere la seguente tabella:
Condizione # 1: Essere maggiorenne Condizione # 2: Età inferiore a 18 anni
TRUE TRUE
TRUE FALSE FALSE TRUE
FALSE FALSE Tabella 4 – Condizioni dipendenti, primo esempio
E’ ovvio che è impossibile che entrambe le condizioni siano TRUE per uno stesso individuo; e non è neanche
possibile che siano entrambi FALSE; se l’una e vera, l’altra deve necessariamente essere falsa. In questo
caso, la relazione tra le due condizioni C1 e C2 è evidente: C1 = NOT (C2) oppure la duale: C2 = NOT (C1). La
tabella sopra riportata la chiameremo “tabella di dipendenza” e le condizioni booleane C1 e C2 sono in
questo caso dipendenti, nel senso che:
a) Specificate alcune, si possono conoscere le altre, in modo univoco per almeno alcuni valori.
b) Esistono delle combinazioni delle condizioni che non sono permesse.
Un ragionamento analogo si può fare per più di due variabili booleane.
Nel seguito, data una condizione C, indicheremo con l’apice la condizione negata, ossia: C’= NOT (C).
Per fare un altro esempio di condizioni dipendenti consideriamo il seguente mini-requisito. Supponiamo
che in un form di registrazione a un sito web vi sia un campo e-mail in cui inserire la propria e-mail; è
richiesto che: “L’indirizzo di e-mail non è obbligatorio, ma se inserito la mail deve essere formalmente
valida”. Leggendolo vengono in mente le seguenti due condizioni:
1. Indirizzo di mail vuoto
2. Indirizzo di mail valido
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 10 di 91
Possiamo costruire la seguente tabella della verità:
# A: Indirizzo di mail vuoto B: Indirizzo di mail valido
1 True True 2 True False
3 False True 4 False False
Tabella 5 – Condizioni dipendenti, secondo esempio
Ora, se il campo e-mail è vuoto, non può essere valido; la combinazione #1 (TRUE, TRUE) non ha senso. Ha
senso la combinazione #2; se l’indirizzo di mail è vuoto, non è valido per definizione (un indirizzo di e-mail =
“” non è sicuramente formalmente valido!). Se l’indirizzo di e-mail non è vuoto, allora contiene una stringa
alfanumerica, che può essere una mail formalmente valida ([email protected]) – e siamo nel caso #3
(FALSE, TRUE) – oppure non essere una mail valida (uyhiuy89iuoj@) – e siamo nel caso #4 (FALSE, FALSE).
Le due condizioni A e B sono tra di loro dipendenti, in quanto:
a) Nel caso si fissi A = FALSE, la condizione A può assumere entrambi i valori TRUE o FALSE (e lo stesso
dicasi se B = FALSE). Il fatto però che fissato A = TRUE la B può essere solo FALSE ovvero fissata B =
TRUE, la condizione A può essere solo FALSE, è sufficiente per dire che esiste una relazione tra A e
B, che sono tra di loro dipendenti.
b) La combinazione #1 (TRUE,TRUE) è proibita.
Consideriamo ancora il seguente caso di condizioni dipendenti. Consideriamo una variabile X che può
assumere uno dei tre numeri interi {1,2,3}. Se X=1 ovviamente non può valere 2 e neppure 3. Al posto della
variabile X consideriamo le tre condizioni:
1. A: X = 1
2. B: X = 2
3. C: X = 3
Le tre condizioni sono dipendenti. Vale la seguente tabella di dipendenza:
# A: X = 1 B: X = 2 C: X = 3
1 TRUE FALSE FALSE 2 FALSE TRUE FALSE
3 FALSE FALSE TRUE 4 TRUE TRUE TRUE
5 TRUE FALSE TRUE
6 FALSE TRUE TRUE
7 TRUE TRUE FALSE 8 FALSE FALSE FALSE
Tabella 6 –Condizioni dipendenti, terzo esempio
Solo le combinazioni (TRUE,FALSE,FALSE), (FALSE, TRUE, FALSE) e (FALSE,FALSE,TRUE) sono valide; in altri
termini solo una condizione alla volta è TRUE. La condizione #4 (TRUE,TRUE,TRUE) è evidentemente
impossibile in quanto la variabile X non può contemporaneamente assumere tutte e tre i valori {1,2,3}. Un
ragionamento analogo vale per le combinazioni #5 → #8. Anche la combinazione (FALSE,FALSE,FALSE) non
è valida, perché la variabile X deve (obbligatoriamente) assumere un valore; nel caso non ci fosse questo
obbligo, la combinazione #8 dovrebbe essere considerata valida.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 11 di 91
Dalla tabella sopra, considerando solo i casi validi, si possono scrivere le seguenti equazioni booleane, che
definiscono la dipendenza delle condizioni A,B,C tra di loro(2):
• (A=TRUE) AND (B=FALSE) AND (C=FALSE) = A
• (A=FALSE) AND (B=TRUE) AND (C=FALSE) = B
• (A=FALSE) AND (B=FALSE) AND (C=TRUE) = C
Nel caso in cui dovesse essere presa in considerazione la riga #8, quindi dando la possibilità alla variabile X
di non assumere nessun valore, si deve anche considerare l’equazione:
• (A=FALSE) AND (B=FALSE) AND (C=FALSE) = FALSE
In casi in cui una variabile può assumere N valori distinti, si può genericamente dire che è possibile derivare
N condizioni dipendenti (A,B,C,…,N) , essendo valide le N equazioni booleane di dipendenza seguenti:
(A=FALSE) AND (B=FALSE) AND (C=FALSE)…AND (K=TRUE) AND … AND (N=FALSE) = K
per tutte le condizioni K = A,B,..,N. Si deve considerare anche l’equazione:
(A=FALSE) AND (B=FALSE) AND (C=FALSE)…AND (K=FALSE) AND … AND (N=FALSE) = FALSE
se si suppone che la variabile possa non assumere nessuno degli N valori.
Un caso particolare è quello di una variabile X che possa assumere uno ed un sol valore, poniamo X=1. In
questo caso, l’unica condizione che si può derivare è A: X=1 che è sempre TRUE. In pratica abbiamo una
variabile binaria assoluta o auto-vincolata in cui la tabella di vincolo è la seguente:
# A: X = 1
1 TRUE 2 FALSE
Tabella 7 – variabile binaria auto-vincolata
Continuando nella lettura della tabella decisionale, consideriamo il seguente esempio di tabella decisionale:
Condizioni 0 1 2 3
A – Condizione # 1 T T F F
B - Condizione # 2 T F T F
Azioni
F0: Azione # 1 1 1 1
F1: Azione # 2 1 1 1
Tabella 8 – Tabella decisionale con 2 condizioni e 2 azioni
La tabella ha due condizioni A e B e due azioni F0 ed F1. Leggendo le colonne, come abbiamo mostrato
prima, abbiamo:
2 Dire infatti (A=TRUE) AND (B=FALSE) AND (C=FALSE) è come dire se (x=1) e (x≠2) e (x≠3), quanto vale x? Ovviamente
x=1. Stesso ragionamento per le altre due condizioni.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 12 di 91
# Relazione Colonna Relazione Azione - Condizione
1 Colonna 0 F0 = (A = True) AND (B = True)
2 Colonna 0 F1 = (A = True) AND (B = True) 3 Colonna 1 F1 = (A = True) AND (B = False)
4 Colonna 2 F0 = (A = False) AND (B = True) 5 Colonna 3 F0 = (A = False) AND (B = False)
6 Colonna 3 F1 = (A = False) AND (B = False)
Tabella 9 – Tabella esplicativa della decisionale (prima forma)
Per semplificare la scrittura conveniamo che:
1. Quando scriviamo la condizione A è da intendersi A = True
2. Quando scriviamo la condizione A’ ( = A negata) è da intendersi A = False
3. Sostituiamo all’operatore AND il simbolo ∙ che può anche essere tralasciato; in pratica:
(A AND B) ≡ (A∙ B) ≡ AB
4. Sostituiamo all’operatore OR il simbolo + ; in pratica:
(A OR B) ≡ (A + B)
La tabella sopra si riscrive più semplicemente:
# Relazione Colonna Relazione Azione - Condizione
1 Colonna 0 F0 = AB 2 Colonna 0 F1 = AB
3 Colonna 1 F1 = AB’ 4 Colonna 2 F0 = A’B
5 Colonna 3 F0 = A’B’ 6 Colonna 3 F1 = A’B’
Tabella 10 – Tabella esplicativa della decisionale (seconda forma)
Raggruppando insieme le azioni F0 e F1:
• F0 = A B + A' B + A' B';
• F1 = A B + A B' + A' B';
Ci poniamo la seguente domanda: esiste un metodo che mi permette di ridurre al minimo le espressioni
trovate per F0 ed F1 ? Si potrebbe pensare – visto l’esempio sopra – che la domanda sia “oziosa” perché le
due espressioni non sono poi così complicate. Per rispondere all’obiezione, supponiamo di dover
implementare uno spezzone di codice che, controllando le condizioni A e B, esegua le azioni F0 o F1. Il
codice è quello sotto riportato:
if((A=true AND B=true) OR (A=false AND B=true) OR (A=false AND B=false)){
print "Sto eseguendo F0";}
if((A=true AND B=true) OR (A=true AND B=false) OR (A=false AND B=false)){
print "Sto eseguendo F1";}
Vediamo ora se riusciamo a ridurre le espressioni trovate per F0 ed F1. Con un po’ di algebra booleana:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 13 di 91
• F0 = A B + A' B + A' B' = AB + A’ (B + B’) = AB + A’ = (A’)’ B + A’ = A’ + (A’)’B = A' + B;
• F1 = A B + A B' + A' B' = AB + B’ (A + A’) = AB + B’ = A(B’)’ + B’ = B’ + A(B’)’ = B’ + A = A + B'
Avendo considerato che:
1. Data una qualunque condizione booleana X si ha che: X + X’ = 1 (TRUE). Quindi A + A’ = 1 e B + B’ = 1
2. Data una qualunque condizione booleana X si ha: (X’)’ = X; quindi (A’)’ = A e (B’)’ = B.
3. Date due condizioni booleane X ed Y vale la proprietà commutativa: X + Y = Y + X
4. Il teorema dell’assorbimento del complemento mi dice che, date due qualunque condizioni
booleane A e B vale la relazione: A + A’B = A + B .
Non preoccupatevi troppo se non riuscite a seguire nel dettaglio i passaggi; la difficoltà sta nell’eseguire i
conti usando l’algebra booleana, ma l’espressione ridotta è molto più semplice rispetto l’originale e il
nostro codice diventa molto più comprensibile:
if((A=false AND B=true)){
print "Sto eseguendo F0";}
if((A=true AND B=false)){
print "Sto eseguendo F1";}
Ora, a livello pratico e operativo, nel lavoro di tutti i giorni, non è pensabile di mettersi a fare dei calcoli con
l’algebra booleana, che – in genere nei problemi reali – sono molto più complessi rispetto a quelli appena
mostrati; l’unico sistema è di utilizzare un software adatto allo scopo. Il software che utilizzeremo si chiama
Logic Friday e sarà l’oggetto del prossimo capitolo.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 14 di 91
Logic Friday
Il presente capitolo non vuole essere un manuale esaustivo di utilizzo del software Logic Friday, ma fornire
solo le informazioni di base utili per compiere le operazioni di minimizzazione delle tabelle decisionali.
Esiste per altro un ottimo “help on line” e l’interfaccia è semplice e intuitiva da utilizzare.
Per prima cosa si scarichi il software (gratuito alla data di stesura del presente manuale) dal sito
http://www.sontrak.com/ e lo si installi sulla propria macchina; il software gira solo in ambienti Windows.
Una volta lanciato, appare la schermata seguente:
Figura 2 – Videata principale di Logic Friday.
Click con il mouse su File →New→Truth Table ed appare la seguente videata:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 15 di 91
Figura 3 – Scelta degli input ed output della Truth Table.
Selezionare in numero di valori di input (sono le condizioni) e il numero di valori di output (sono le azioni)
corretti per il problema in analisi. Ad esempio, nel caso visto nel paragrafo precedente (Tabella 8) abbiamo
due input A e B (condizioni) e due output F0 e F1 (azioni). Premendo OK, il software presenta la seguente
videata:
Figura 4 – Esempio di Truth Table.
Il software prepara la tabella con tutte le possibili combinazioni dei valori delle condizioni (che sono
considerate indipendenti) e tale tabella (in nero a sinistra) non è modificabile.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 16 di 91
Cliccando gli zeri in blu in corrispondenza dell’incrocio tra le combinazioni delle condizioni A e B e le azioni
F0 e F1, il valore cambia in modo ciclico da 0 → 1 → X. In pratica non abbiamo altro che la nostra tabella
decisionale, ma vista in forma trasposta. Il valore X sta per “don’t care” (“non importa” in inglese) e
capiremo meglio di cosa si tratta tra un po’.
Ricordiamo che Logic Friday usa la notazione 1 per TRUE e 0 per FALSE, mentre nelle tabelle sul presente
documento usiamo direttamente TRUE e FALSE; inoltre noi non inseriamo il valore 0 nella parte in basso
delle tabelle riservata alle azioni per non appesantire troppo.
Provando ad inserire i valori della Tabella 8 abbiamo:
Figura 5 – Esempio di Truth Table compilata.
Premendo invio (oppure la voce di menù Truthtable→Submit) il software mostra le equazioni per F0 ed F1
che ha dedotto dai valori inseriti nella tabella (lato destro sotto la scritta “Entered by truthtable”):
Figura 6 – Equazioni delle azioni equivalenti ai valori inseriti nella Truth Table.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 17 di 91
A questo punto se clicchi su Operation → Minimize… e compare la seguente videata di scelta:
Figura 7 – Selezione delle modalità di ottimizzazione dei calcoli di minimizzazione
Manteniamo le opzioni che sono selezionate di default e premiamo OK. Otteniamo la seguente schermata:
Figura 8 – Equazioni minimizzate
Abbiamo ottenuto così le equazioni minimizzate nel riquadro di destra sotto la scritta “Minimized”.
Care or don’t care ?
Consideriamo il seguente (semplice) requisito: “La pagina di login ad un sito web richiede l’inserimento di
user, password e codice captcha. Perché il login abbia successo, login e password devono appartenere ad
uno stesso utente (registrato in una tabella anagrafica) ed il codice capcha deve essere uguale a quello
proposto a video”.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 18 di 91
Figura 9 – Pagina di Login
Abbiamo tre variabili binarie indipendenti: user, password e codice captca.
Le condizioni sono:
• A: utente inserito uguale ad un utente U presente sul database.
• B: password inserita uguale a quella dell’utente U.
• C: codice captcha uguale a quello mostrato a video.
Le azioni sono:
• F0: Messaggio di errore.
• F1: Login effettuato
Ora, perché sia possibile eseguire il login (azione F1), le tre condizioni devono essere tutte TRUE. Negli altri
casi,quando almeno una condizione è falsa, viene sempre inviato il messaggio di errore. La tabella
decisionale è la seguente:
Condizioni 0 1 2 3
A – utente = U T F d.c. d.c
B – Password = U T d.c. F d.c
C – Codice = codice a video T d.c d.c F
Azioni
F0: messaggio errore 1 1 1
F1: login effettuato 1 Tabella 11 – Tabella decisionale per Login Form con don’t care
Abbiamo utilizzato d.c. (acronimo per “don’t care”) per le condizioni ininfluenti sull’azione da
intraprendere. In pratica, la colonna #2 ci dice che, qualunque valore assuma la condizione B o C, è
sufficiente che la condizione A sia FALSE perché sia prodotto il messaggio di errore F0. In altri termini, i
“don’t care” sono le condizioni che sono ininfluenti sulle le azioni da intraprendere.
La Tabella 11 scritta in forma “ridotta” – utilizzando i don’t care – può essere sviluppata in forma estesa,
sostituendo i d.c. con le combinazioni dei valori TRUE e FALSE; si ottiene:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 19 di 91
Condizioni 0 1.1 1.2 1.3 1.4 2.1 2.2 2.3 2.4 3.1 3.2 3.3 3.4
A – utente = U T F F F F T T F F T T F F
B – Password = U T T T F F F F F F T F T F
C – Codice = codice a video T T F T F T F T F F F F F
Azioni
F0: messaggio errore
1 1 1 1 1 1 1 1 1 1 1 1
F1: login effettuato 1
Tabella 12 – Tabella decisionale per Login Form sviluppata in forma estesa.
Nella Tabella 12 abbiamo indicato con 1.1, 1.2, 1.3 ed 1,4 lo sviluppo della colonna 1 della Tabella 11 e così
via per la colonna 2 e 3.
Notiamo che la Tabella 12 ha delle colonne duplicate: colonne 1.4, 2.4 e 3.4 per la combinazione (FALSE,
FALSE, FALSE), 1.3 e 2.3 per la combinazione (FALSE, FALSE, TRUE), colonne 1.2 e 3.3 per la combinazione
(FALSE, TRUE, FALSE) e colonne 2.2 e 3.2 per la combinazione (TRUE,FALSE, FALSE). Eliminando le
ridondanze, si ottiene:
Condizioni 0 1.1 2.1 2.2 2.3 3.1 3.3 3.4
A – utente = U T F T T F T F F
B – Password = U T T F F F T T F
C – Codice = codice a video T T T F T F F F
Azioni
F0: messaggio errore
1 1 1 1 1 1 1
F1: login effettuato 1
Tabella 13 – Tabella decisionale per Login Form senza ridondanze.
Quest’ultima è la tabella decisionale sviluppata e senza ridondanze (le colonne sono 8 = 23).
Utilizzando i d.c. si semplifica e si riducono di molto le dimensioni della tabella condizionale; occorre però
fare attenzione che in alcuni casi potreste trovarvi con degli errori. Consideriamo ad esempio la seguente
generica tabella (derivante da un qualche requisito che non staremo a specificare):
Condizioni 0 1 2 3
A T T d.c. d.c
B T d.c. T d.c
C F d.c d.c T
Azioni F0
1 1 1
F1 1 Tabella 14 – Tabella decisionale con don’t care NON corretti
Se sviluppiamo la Tabella 14 otteniamo la seguente:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 20 di 91
Condizioni 0 1 2 3 4 5 6 7 8 9 10 11 12
A T T T T T T F T F T F T F
B T T F T F T T T T T T F F
C F T T F F T T F F T T T T
Azioni
F0
1 1 1 1 1 1 1 1 1 1 1 1
F1 1
Tabella 15 – Tabella decisionale con don’t care NON corretti in forma sviluppata
Vediamo che la colonna #0 e la colonna #7 sono in contraddizione; la #0 dice che per la combinazione
(TRUE, TRUE, FALSE) si verifica l’azione F1 mentre la colonna #7 la stessa combinazione è associata
all’azione F0. Non ha senso, la tabella è errata. Gli altri casi di pari colore fanno riferimento alla stessa
azione, ma sono ridondanti e vanno eliminati, come abbiamo fatto poc’anzi. La morale è che è possibile
usare i d.c. , ma occorre fare molta attenzione a non fare errori logici; eventuali errori logici saltano fuori
solo sviluppando completamente la tabella.
Usare i d.c. in una tabella condizionale può essere utile per capire “al volo” le relazioni che legano le
condizioni e le azioni. Ad esempio, nel caso della Tabella 11, è abbastanza immediato capire che :
• F0 = A’ + B’ + C’
• F1 = ABC
Consideriamo F0; la colonna 2 dice che se A=FALSE, per qualunque valore di B e C si ha F0=1. Allora F0
dipende solo da A’ (A negato) e non dipende da B e C (o dalle loro negazioni). Dove compare d.c. la
condizione non deve comparire nella equazione che definisce l’azione in funzione delle condizioni (3).
In Logic Friday non è possibile inserire manualmente i valori d.c. nell’input; è però possibile importare
tabelle con valori d.c. (indicati nel tool con la X). Si veda a questo scopo l’help in linea alla voce “Importing a
truth table”.
Logic Friday permette di inserire i d.c. nelle azioni. In pratica è possibile dire che non interessa, per una data
combinazione di input, se l’azione di output viene eseguita o no. Ma che senso ha ?
Logic Friday è un tool che è principalmente utilizzato per la progettazione di circuiti logici digitali; nei
circuiti, le condizioni sono interpretabili come segnali di corrente (TRUE = passa corrente e FALSE = non
passa corrente) mentre le azioni sono interpretabili come dei circuiti elettronici digitali che elaborano i
segnali di corrente in input producendo in output un segnale di corrente (TRUE) o non producendolo
(FALSE). Ora, possono esistere dei casi in cui, per alcuni segnali di input, non si ha alcun interesse a sapere
se il segnale di corrente in output c’è o no (semplicemente, tale segnale non ha importanza nell’economia
globale del circuito che si sta progettando).
E’ ovvio che, nel nostro caso, usando Logic Friday come ausilio alla definizione dei requisiti utente, le azioni
hanno il significato di operazioni che devono o non devono essere eseguite e quindi non ha nessun senso
dire che “non mi interessa se un’azione viene eseguita o no”; quindi noi non useremo mai i d.c. sulle azioni.
3 Provate a inserire la Tabella 13 in Logic Friday e verificate che restituisce lo stesso risultato una volta che si sono
minimizzate le equazioni
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 21 di 91
Esempio # 1 – il form di registrazione utente
Consideriamo un form di registrazione di un utente. Il form, e relativo codice che implementa la
funzionalità “Inserisci nuovo utente”, contiene i seguenti campi:
1. Nome utente, obbligatorio
2. E-mail formalmente valida, obbligatoria
3. Password, obbligatoria e tale da possedere almeno un carattere alfabetico minuscolo, uno
maiuscolo, uno numerico e deve essere lunga almeno 8 caratteri.
4. Conferma password: in tale campo deve essere reinserita la password, uguale a quella che è stata
inserita nel campo “Password”.
Figura 10 – Esempio di form per l’inserimento di un nuovo utente.
Le azioni che possono essere svolte sono:
I. F0: Errore, non sono stati inseriti i campi obbligatori.
II. F1: Errore, e-mail non formalmente valida.
III. F2: Errore, la password non rispetta le regole di sicurezza.
IV. F3: Errore, campo password e conferma password differenti.
V. F4: Successo, utente correttamente registrato!
Tutte le azioni pertinenti, in funzione dei dati di input inseriti, sono scatenate alla pressione del pulsante
“Registra”. Le condizioni che possono essere estratte dalle variabili di cui ai punti 1→ 4 sono le seguenb:
A. Stringa nome utente inserita non vuota
B. E-mail inserita valida(*)
C. Password inserita valida (*)
D. Password = Conferma Password
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 22 di 91
Le azioni sono esattamente quelle indicate nei punti I→IV. La tabella decisionale che segue definisce il
comportamento della funzionalità “Inserisci nuovo utente”.
Condizioni
A - Stringa nome utente inserita non vuota T T F F T T F F T T F F T T F F
B - E-mail inserita valida T F T F T F T F T F T F T F T F
C - Password inserita valida T T T T F F F F T T T T F F F F
D - Password = Conferma Password T T T T T T T T F F F F F F F F
Azioni
F0: Errore, non sono stati inseriti i campi obbligatori. X X X X X X X X
F1: Errore, e-mail non formalmente valida. X X X X X X X X
F2: Errore, la password non rispetta le regole di sicurezza. X X X X X X X X
F3: Errore, campo password e conferma password differenti. X X X X X X X X
F4: Successo, utente correttamente registrato! X
Tabella 16 – Tabella decisionale per form registrazione utente
Ora, per com’è stato costruito il problema, è abbastanza evidente notare che per ogni condizione non
verificata è associata uno specifico errore; in particolare:
Condizione non verificata Errore associato
A - Stringa nome utente inserita non vuota F0: Errore, non sono stati inseriti i campi obbligatori.
B - E-mail inserita valida F1: Errore, e-mail non formalmente valida.
C - Password inserita valida F2: Errore, la password non rispetta le regole di sicurezza.
D - Password = Conferma Password F3: Errore, campo password e conferma password differenti.
Tabella 17 – Tabella condizione-errore per form registrazione utente
E’ quindi immediato in questo caso trovare la relazione tra le azioni F0→F4 alle condizioni A →D. Sono le
seguenti (4):
• F0 = A’
• F1=B’
• F2=C’
• F3=D’
• F4 = A∙B∙C∙D
In particolare, la F4 (utente correttamente registrato) deve essere attivata solo qualora tutte le condizioni
A, B, C e D siano verificate.
Eseguendo lo stesso calcolo con Logic Friday , otteniamo lo stesso risultato (ovviamente!). Si veda la figura
sotto nella quale è mostrata la matrice iniziale:
4 Si provi ad effettuare la verifica riscrivendo la tabella condizionale con i don’t care.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 23 di 91
Figura 11 – Truth Table Logic Friday
L’immagine che segue riporta il valore minimizzato calcolato dal software:
Figura 12 – Equazioni minimizzate
Si noterà che le espressioni “originali” delle azioni F0→F4 inserite mediante la tabella sono in pratica
ingestibili, mentre la loro espressione minimizzata è trattabile e può tranquillamente essere direttamente
utilizzata nella logica del programma che implementa la funzionalità “Inserisci nuovo utente”.
Riportiamo, a puro titolo di completezza, l’espressione originale e quella minimizzata da Logic Friday:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 24 di 91
Originale:
• F0 = A' B' C' D' + A' B' C' D + A' B' C D' + A' B' C D + A' B C' D' + A' B
C' D + A' B C D' + A' B C D;
• F1 = A' B' C' D' + A' B' C' D + A' B' C D' + A' B' C D + A B' C' D' + A B'
C' D + A B' C D' + A B' C D;
• F2 = A' B' C' D' + A' B' C' D + A' B C' D' + A' B C' D + A B' C' D' + A B'
C' D + A B C' D' + A B C' D;
• F3 = A' B' C' D' + A' B' C D' + A' B C' D' + A' B C D' + A B' C' D' + A B'
C D' + A B C' D' + A B C D';
• F4 = A B C D;
Minimizzata:
• F0 = A' ;
• F1 = B' ;
• F2 = C' ;
• F3 = D';
• F4 = A B C D;
Esercizio: provare a rieseguire il calcolo, supponendo di avere solo i seguenti errori:
i. F0: Campi obbligatori non inseriti o formalmente non validi.
ii. F1: Password non valida o campo conferma password non correttamente valorizzato.
Alcune volte, per rendere difficile la vita agli hacker, la descrizione degli errori di inserimento è volutamente
generica (o, almeno, questa è la scusa che si da quando la descrizione dell’errore è molto generica). Il
calcolo “a mano” della dipendenza di F0 ed F1 dalle condizioni A →D non è più tanto semplice.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 25 di 91
Tabelle funzionali
Consideriamo un requisito descritto nel modo che segue; si abbiano le tre variabili:
• X che può assumere solo il valore x1.
• Y che può assumere uno dei due valori {y1, y2}
• Z che può assumere uno dei tre valori {z1, z2, z3}.
Secondo i valori che le variabili X, Y e Z assumono, può verificarsi un’azione F0 e/o F1. In altri termini,
possiamo scrivere la seguente tabella:
Variabili X x1 x1 x1 x1 x1 x1 Y y1 y1 y1 y2 y2 y2
Z z1 z2 z3 z1 z2 z3
Azioni F0 X X X X F1 X X X X
Tabella 18 – Tabella funzionale
La tabella sopra riportata rappresenta la descrizione funzionale del requisito in analisi; la possiamo anche
chiamare tabella funzionale o tabella variabili-azioni, in modo da distinguerla da una tabella decisionale, o
tabella condizioni-azioni. La tabella funzionale può essere generalizzata a un numero qualsiasi di variabili,
potendo ciascuna assumere un numero finito e maggiore o uguale a uno di valori.
Una tabella funzionale è molto simile a una tabella decisionale; ciò che le distingue è che la funzionale
lavora con variabili, quella decisionale con condizioni (che altro non sono che variabili booleane). Una
tabella funzionale non è ulteriormente riducibile; in altri termini, una volta scritte le equazioni:
F0 = x1y1z1 + x1y1z3 + x1y2z1 + z1y2z3
F1= x1y1z2 + x1y1z3 + x1y2z2 + x1y2z3
non è più possibile ridurle ulteriormente. Ricordiamo cha abbiamo usato la solita notazione per cui: x1y1z1 ≡
(x1) AND (y1) AND ( z1) e che x1y1z1 + x1y1z3 ≡ [(x1) AND (y1) AND ( z1)] OR [(x1) AND (y1) AND ( z3)]
Domanda: non è possibile ridurre una tabella funzionale in una tabella condizionale equivalente e quindi, su
di essa, utilizzare le tecniche di minimizzazione viste nei capitoli precedenti ? La risposta è affermativa e
sarà l’oggetto del prossimo paragrafo.
Riduzione della tabella funzionale in decisionale
Se, nella Tabella 18 al posto delle variabili X, Y e Z si considerano le seguenti condizioni:
• A: x=x1
• B: y=y1
• C: z=z1
• D: z=z2
• E: z=z3
è immediatamente possibile ricondurre la Tabella 18 alla seguente tabella decisionale equivalente:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 26 di 91
Condizioni
A T T T T T T B T T T F F F
C T F F T F F D F T F F T F
E F F T F F T
Azioni F0 X X X X
F1 X X X X
Tabella 19 – Tabella decisionale equivalente alla tabella funzionale
Analizziamo una condizione alla volta per capire come l’abbiamo dedotta.
1) La variabile X può assumere il solo valore x1. Ciò equivale a dire che X=x1 è una condizione sempre
verificata e quindi uguale a TRUE. Non può neanche mai essere FALSE, poiché per definizione
abbiamo deciso che X può solo e soltanto valere x1. Abbiamo trasformato la variabile X in una
condizione A che è di tipo assoluto o auto-vincolata, nel senso descritto nel paragrafo “Definizione
di tabella decisionale”.
2) La variabile Y può solo e soltanto assumere uno dei due valori y1 e y2. Se vale y1 non può valere y2 e
viceversa. Quindi se la condizione B: y=y1 è TRUE allora y=y1; quando è FALSE non può che essere
univocamente y=y2. E’ possibile anche usare la condizione duale B’:y=y2, per la quale valgono
ragionamenti analoghi. La condizione B è una classica condizione binaria indipendente, nel senso
descritto nel paragrafo “Definizione di tabella decisionale”.
3) La variabile Z può assumere solo uno tra i tre possibili valori z1, z2, z3. Le tre condizioni C: z=z1,D:
z=z2, E: z=z3 sono tra di loro dipendenti e ricordando quanto già discusso sempre nel paragrafo
“Definizione di tabella decisionale”, per esse vale la seguente tabella di vincolo:
# C: Z = x1 D: Z= z2 E: Z = z3
1 TRUE FALSE FALSE 2 FALSE TRUE FALSE
3 FALSE FALSE TRUE 4 TRUE TRUE TRUE
5 TRUE FALSE TRUE 6 FALSE TRUE TRUE
7 TRUE TRUE FALSE 8 FALSE FALSE FALSE
Tabella 20 – Tabella di vincolo
C, D ed E sono condizioni booleane dipendenti; il vincolo tra le condizioni è esprimibile nella forma:
• CD’E’ = C
• C’DE’ = D
• C’D’E = E
Una volta che una tabella funzionale è stata ridotta a una tabella decisionale, è possibile applicare ad essa i
metodi di riduzione noti, discussi nei paragrafi precedenti.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 27 di 91
Il caso degenere della funzione
Consideriamo la seguente tabella funzionale:
Variabili
X x1 x1 x1 x1 x1 x1
Y y1 y1 y1 y2 y2 y2 Z z1 z2 z3 z1 z2 z3
Azioni
F0 X
F1 X F2 X
F3 X F4 X
F5 X
Tabella 21 – Tabella funzionale degenere (funzione)
La differenza tra la Tabella 18 ed Tabella 21è che in quest’ultima vi sono tante azioni quante sono le
combinazioni dei valori delle variabili X, Y e Z. In pratica, ogni azione è univocamente determinata da una
specifica combinazione (tripletta) di valori delle variabili X, Y e Z. Siamo forse più abituati a vedere la tabella
in forma trasposta, ossia:
X Y Z Azione
x1 y1 z1 F0
x1 y1 z2 F1
x1 y1 z3 F2
x1 y2 z1 F3
x1 y2 z2 F4
x1 y2 z3 F5
Tabella 22 – funzione
Quest’ultima tabella non è altro che la “classica” funzione matematica in tre variabili (X,Y,Z), in cui al posto
della ordinata numerica abbiamo delle azioni F0→F5. La tabella decisionale equivalente della Tabella 21 è
la Tabella 23.
Condizioni
A T T T T T T B T T T F F F
C T F F T F F
D F T F F T F E F F T F F T
Azioni
F0 X
F1 X F2 X
F3 X F4 X
F5 X
Tabella 23 – Tabella decisionale per la funzione (equivalente alla funzionale)
E’ evidente che in questo caso è immediato dedurre l’equazione delle azioni F0 →F5, che sono:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 28 di 91
• F0 = ABCD’E’
• F1 = ABC’DE’
• F2 = ABC’D’E
• F3 = AB’CD’E’
• F4 = AB’C’DE’
• F5 = AB’C’D’E
Tali espressioni sono già ridotte nella forma minimizzata; in pratica, il caso in cui la descrizione funzionale
del requisito si riduca ad una funzione, il passaggio dalla tabella funzionale a quella decisionale è poco utile,
o almeno, non dice nulla di più di quello che si poteva dedurre dalla Tabella 21( o la sua equivalente
Tabella 22).
E’ però interessante notare che la descrizione funzionale ingloba, come caso particolare, la funzione
propriamente detta. Terminiamo dicendo che:
a) Una tabella funzionale è sempre riducibile a una tabella decisionale equivalente (ed anche possibile
l’inverso, ma in genere è poco utile)
b) Riducendo una tabella funzionale in decisionale, è possibile utilizzare le regole dell’algebra
booleana (a mano o mediante l’ausilio di tool di calcolo come Logic Friday) per minimizzare le
equazioni che esprimono le azioni in funzione delle condizioni.
c) La funzione classicamente intesa è deducibile come caso particolare della tabella funzionale.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 29 di 91
Esempio # 2 – la scuola guida
Consideriamo il seguente requisito:
Una persona con età minore di 14 anni (esclusi) non può prendere alcuna patente di guida. Se la persona ha
un’età compresa tra 14 anni (inclusa) e 18 anni (esclusi) può prendere la sola patente categoria A. Se la
persona ha un’età superiore a 18 anni (compresi) può scegliere se prendere la patente categoria A o
categoria B (una esclude l’altra). In tutti i casi, è possibile conseguire la patente se si superano con successo
la visita attitudinale e l’esame di guida.
L’analisi del requisito, mostra che si può distinguere tre categorie di età, che rappresentano tre condizioni:
• A : età < 14
• B : 14 <= età < 18
• C : età >= 18
Si devono anche considerare le seguenti due condizioni:
• D: superamento della visita attitudinale
• E: superamento esame di guida
Le azioni in questo caso sono 2
• F0 – Conseguimento patente categoria A
• F1 – Conseguimento patente categoria B
Tutte queste informazioni possono essere raccolte nella seguente tabella:
Condizioni
A : età < 14 T T T T F F F F F F F F
B : 14 <= età < 18 F F F F T T T T F F F F
C : età >= 18 F F F F F F F F T T T T
D : superamento della visita attitudinale T T F F T T F F T T F F
E : superamento esame di guida F T T F F T T F F T T F
Azioni
F0 – Conseguimento patente categoria A X X
F1 – Conseguimento patente categoria B X
Tabella 24 – Tabella decisionale conseguimento patente
Notiamo che, nei blocchi di diverso colore, non compaiono tutte le combinazioni delle condizioni A, B e C, in
quanto tali condizioni sono mutualmente esclusive; in altre parole, se una persona ha meno di 14 anni non
può averne più di 18. Le uniche combinazioni valide delle condizioni A, C e C sono quindi {(TRUE, FALSE,
FALSE),(FALSE,TRUE, FALSE),(FALSE, FALSE, TRUE)}. In pratica, queste condizioni sono dipendenti tra di loro
e determinate arbitrariamente due condizioni, la terza è automaticamente determinata. La tabella si limita
quindi a considerare solo 12 delle 32 = 25 combinazioni possibili.
In questo caso, è semplice verificare che le azioni sono intraprese se sono verificate le seguenti condizioni:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 30 di 91
F0 = (B AND D AND E) OR (C AND D AND E) = B∙D∙E + C∙D∙E = (B + C) ∙D∙E
F1 = (C AND D AND E) =C∙D∙E
Utilizzando il software Logic Friday, abbiamo nella matrice tutte e 32 le combinazioni; andremo ad inserire
il valore 1 alle funzioni F0 e F1 solo per le combinazioni riportate nella tabella sopra, ossia (F,T,F,T,T) =
(0,1,0,1,1) = riga 11 della truth table Logic Friday e (F,F,T,T,T) = (0,0,1,1,1) = riga 7 della truth table Logic
Friday.
Figura 13 – Truth Table del problema in analisi.
Se procediamo con la minimizzazione della tabella, il software ci fornisce il seguente risultato:
F0 = A' B C' D E + A' B' C D E;
F1 = A' B' C D E;
Ora, i risultati da noi ricavati e quelli ricavati dal software sembrano diversi, come vediamo nella tabella che
segue:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 31 di 91
Funzioni Ricavata senza software Ricavato con il Software
F0 B∙D∙E + C∙D∙E A' B C' D E + A' B' C D E
F1 C∙D∙E A' B' C D E
Tabella 25 – comparazione dei risultati
Ricordiamoci che, come visto poco fa, le condizioni A, B e C sono dipendenti tra di loro, vale la seguente
funzione logica:
A B C Risultato
TRUE FALSE FALSE A (True) FALSE TRUE FALSE B (True)
FALSE FALSE TRUE C (True)
Tutte le altre possibili combinazioni non hanno senso !
Tabella 26 – Tabella di vincolo A, B e C
In termini semplici, prendiamo la prima riga, nella quale abbiamo: AB’C’ = (età < 14 anni) AND (non 14 <=
età < 18) AND (non età >=18) = (età < 14 anni). A parole, se ha meno di 14 anni e non ha una età compresa
tra 14 anni e 18 anni e se non ha una età maggiore di 18 anni, che età ha ? Ovviamente ha meno di 14
anni….
Da una quest’ultima tabella, vediamo che:
• A' B C' = B
• A' B' C = C
I due risultati sono quindi perfettamente equivalenti.
Nel caso generale, la morale è la seguente: se ho delle condizioni booleane tra di loro dipendenti, il risultato
minimizzato ottenuto dal software Logic Friday può essere ulteriormente ridotto tenendo conto della
dipendenza funzionale tra le condizioni dipendenti. Detto in altri termini, Logic Friday considera sempre le
condizioni come indipendenti tra di loro ed eventuali dipendenze vanno “gestite a mano”.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 32 di 91
Esempio #3 - un caso un po’ complesso.
Consideriamo il seguente requisito:
“Se una persona di sesso maschile e maggiorenne risulta disoccupata, gli viene dato un assegno mensile di
700 Euro; se però ha un reddito annuale inferiore di 20.000 euro, gli viene dato in aggiunta un assegno di
300 euro; se il reddito annuale è superiore a 40.000 euro, vengono scalati 200 euro all’assegno principale.
Se la persona è minorenne, l’assegno è di 500 euro mensili. Se una persona ha un’occupazione, gli sono
scalati 300 euro forfait di tasse per ciascun mese. Se la persona è di sesso femminile, gli è corrisposto un
assegno di 500 euro mensili, ridotti a 300 se il reddito annuale supera i 40.000 euro; se la donna ha dei figli,
gli è dato in aggiunta un assegno di 100 euro per figlio, fino a un massimo di 500 euro.”
Iniziamo con l’analisi del requisito. Per prima cosa individuiamo le condizioni booleane dipendenti ed
indipendenti. Le condizioni booleane indipendenti sono:
• Essere maggiorenne (avere un’età superiore o inferiore a 18 anni)
• Sesso (essere maschio o femmina)
• Essere disoccupato (non avere un’occupazione o avercela)
La condizione booleana dipendente è:
• Reddito annuo. Le classi di reddito annuo individuabili sono:
o Minore di 20.000 euro (escluso)
o Da 20.000 euro (incluso) a 40.000 euro (incluso)
o Superiore a 40.000 euro (escluso)
Per ciascuna classe di reddito annuo, riscriviamo il requisito valido solo per quella classe. Si avranno quindi
tre requisiti, uno per ciascuna classe di reddito annuo, diversi – magari di poco – l’uno dall’altro. In pratica,
invece di considerare tutte le variabili indipendenti e dipendenti, dividiamo il requisito in sottorequisiti
validi ciascuno solo per un valore della variabile booleana dipendente (la classe di reddito). E’ questa una
modalità che viene comodo usare quando il requisito è complesso e/o contiene molte variabili dipendenti,
che andrebbero ad aumentare pesantemente le dimensioni delle tabelle decisionali.
1. Classe # 1 – Reddito annuo < 20.000 euro (limite escluso)
a. Se la persona è minorenne, l’assegno è di 500 euro mensili.
b. Se una persona ha un’occupazione, gli sono scalati 300 euro forfait di tasse per ciascun mese.
c. A una persona di sesso maschile, maggiorenne e disoccupata, gli è fornito un assegno mensile
standard di 700 Euro aumentato di un importo pari a 300 euro.
d. Se la persona è di sesso femminile, gli è corrisposto un assegno di 500 euro mensili. Se la donna
ha dei figli, gli è dato in aggiunta un assegno di 100 euro per figlio, fino a un massimo di 500
euro.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 33 di 91
2. Classe # 2 – Reddito annuo compreso tra 20.000 euro (incluso) e 40.000 euro (incluso)
a. Se la persona è minorenne, l’assegno è di 500 euro mensili.
b. Se una persona ha un’occupazione, gli sono scalati 300 euro forfait di tasse per ciascun mese.
c. A una persona di sesso maschile, maggiorenne e disoccupata, gli è fornito un assegno mensile
standard di 700 Euro.
d. Se la persona è di sesso femminile, gli è corrisposto un assegno di 500 euro mensili. Se la donna
ha dei figli, gli è dato in aggiunta un assegno di 100 euro per figlio, fino a un massimo di 500
euro.
3. Classe # 3 – Reddito annuo compreso superiore a 40.000 euro (escluso)
a. Se la persona è minorenne, l’assegno è di 500 euro mensili.
b. Se una persona ha un’occupazione, gli sono scalati 300 euro forfait di tasse per ciascun mese.
c. A una persona di sesso maschile, maggiorenne e disoccupata, gli è fornito un assegno mensile
standard di 700 Euro diminuito di un importo pari a 200 euro.
d. Se la persona è di sesso femminile, gli è corrisposto sempre e comunque un assegno di 300
euro mensili. Se la donna ha dei figli, gli è dato in aggiunta un assegno di 100 euro per figlio,
fino a un massimo di 500 euro.
Ad una breve analisi, notiamo subito che i requisiti ( a ) e ( b ) – derivati dal requisiti principale - sono
comuni per tutte e tre le classi.
Creiamo ora le tre tabelle di decisione per i tre casi.
Classe # 1 – Reddito annuo < 20.000 euro (limite escluso)
Condizioni
Minorenne T T F F T T F F
Occupata T F T F T F T F
Maschio T T T T F F F F
Azioni
Assegno minorenne (500 euro) X X X X
Assegno standard (700 euro) X
Incremento assegno standard (300 euro) X
Decremento assegno standard (200 euro) Assegno donna e figli (funzione numero figli e reddito) X X X X Tasse scalate (300 euro) X X X X
Tabella 27 – Tabella decisionale Classe di reddito # 1
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 34 di 91
Classe # 2 – Reddito annuo compreso tra 20.000 euro (incluso) e 40.000 euro (incluso)
Condizioni
Minorenne T T F F T T F F
Occupata T F T F T F T F
Maschio T T T T F F F F
Azioni
Assegno minorenne (500 euro) X X X X
Assegno standard (700 euro) X
Incremento assegno standard (300 euro)
Decremento assegno standard (200 euro)
Assegno donna e figli (funzione numero figli e reddito) X X X X
Tasse scalate (300 euro) X X X X
Tabella 28 – Tabella decisionale Classe di reddito # 2
Classe # 3 – Reddito annuo compreso superiore a 40.000 euro (escluso)
Condizioni
Minorenne T T F F T T F F
Occupata T F T F T F T F
Maschio T T T T F F F F
Azioni
Assegno minorenne (500 euro) X X X X
Assegno standard (700 euro) X Incremento assegno standard (300 euro) Decremento assegno standard (200 euro) X
Assegno donna e figli (funzione numero figli e reddito) X X X X
Tasse scalate (300 euro) X X X X
Tabella 29 – Tabella decisionale Classe di reddito # 3
A stesso colore corrisponde stesso requisito. In particolare:
• Requisito (a) : arancione
• Requisito (b): giallo
• Requisito (c): grigio
• Requisito (d): rosa
Guardando le tre tabelle notiamo che:
1. La principale differenza sta nel requisito (c); secondo la classe di reddito, è percepito l’assegno
standard oppure lo stesso assegno incrementato o decrementato.
2. Che l’assegno alla donna con figli, dipende nello stesso modo dal numero di figli per tutte e tre le
classi di reddito, ma l’importo iniziale è diverso. In altri termini:
a. Per le prime due classi di reddito l’assegno alla donna si calcola con la formula: (500 +
numero_figli*100) se 0<= numero_figli <= 5; se numero_figli > 5 ==> 500 + 500 = 1000 Euro.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 35 di 91
b. Per la terza classe di reddito l’assegno alla donna si calcola con la formula: (300 +
numero_figli*100) se 0<= numero_figli <= 5; se numero_figli > 5 ==> 300 + 500 = 800 Euro.
Sono quindi funzioni uguali per le prime due classi di reddito, ma diversa per la terza classe.
3. Notiamo che se la donna è minorenne prende sia i 500 euro per il fatto di essere minorenne, sia i
500 per il fatto di essere donna. Mhhh… sorge il dubbio che ci sia un errore nel requisito. Non è
che, nel requisito iniziale, la frase: “Se la persona è di sesso femminile, gli è corrisposto un assegno
di 500 euro mensili, ridotti a 300 se il reddito annuale supera i 40.000 euro; se la donna ha dei figli,
gli è dato in aggiunta un assegno di 100 euro per figlio, fino ad un massimo di 500 euro” vada
sostituita con la frase: ”Se la persona è di sesso femminile e maggiorenne, gli è corrisposto un
assegno di 500 euro mensili, ridotti a 300 se il reddito annuale supera i 40.000 euro; se la donna ha
dei figli, gli è dato in aggiunta un assegno di 100 euro per figlio, fino ad un massimo di 500 euro”. In
altri termini, probabilmente colui il quale ha specificato il requisito, ha dato “per scontato” che nel
caso del sesso femminile, ci si riferisse alla donna maggiorenne? E se è così, che succede se la
donna minorenne ha dei figli? A lei non gli diamo i 100 euro per figlio?
L’osservazione riportata nel punto (III) non ha lo scopo di fare politica di welfare, ma di dimostrare come sia
possibile – e anche facile – commettere errori durante la definizione dei requisiti, errori che possono essere
scoperti se si esegue un’analisi del requisito con una metodologia ben definita come quella ivi presentata.
Supponiamo allora di aver ridiscusso il requisito con l’utente che l’ha emesso originariamente, il quale ha
ammesso di aver dimenticato di specificare che la donna cui fa riferimento il requisito (d) è maggiorenne.
Le tre tabelle di decisione diventano le seguenti (è stato indicato con bordo rosso le caselle dove sono state
cancellate le X).
Classe # 1 – Reddito annuo < 20.000 euro (limite escluso) – Tabella corretta
Condizioni
A - Minorenne T T F F T T F F
B - Occupata T F T F T F T F
C - Maschio T T T T F F F F
Azioni
F0 - Assegno minorenne (500 euro) X X X X
F1 - Assegno standard (700 euro) X F2 - Incremento assegno standard (300 euro) X F3 - Decremento assegno standard (200 euro)
F4 - Assegno donna e figli (funzione numero figli e reddito) X X
F5 - Tasse scalate (300 euro) X X X X
Tabella 30 – Tabella decisionale Classe di reddito # 1 – tabella corretta
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 36 di 91
Classe # 2 – Reddito annuo compreso tra 20.000 euro (incluso) e 40.000 euro (incluso) – Tabella corretta
Condizioni
A - Minorenne T T F F T T F F
B - Occupata T F T F T F T F
C - Maschio T T T T F F F F
Azioni
F0 - Assegno minorenne (500 euro) X X X X
F1 - Assegno standard (700 euro) X F2 - Incremento assegno standard (300 euro) F3 - Decremento assegno standard (200 euro)
F4 - Assegno donna e figli (funzione numero figli e reddito) X X
F5 - Tasse scalate (300 euro) X X X X
Tabella 31 – Tabella decisionale Classe di reddito # 2 – tabella corretta
Classe # 3 – Reddito annuo compreso superiore a 40.000 euro (escluso) – Tabella corretta
Condizioni
A - Minorenne T T F F T T F F
B - Occupata T F T F T F T F
C - Maschio T T T T F F F F
Azioni
F0 - Assegno minorenne (500 euro) X X X X
F1 - Assegno standard (700 euro) X F2 - Incremento assegno standard (300 euro)
F3 - Decremento assegno standard (200 euro) X
F4 - Assegno donna e figli (funzione numero figli e reddito) X X
F5 - Tasse scalate (300 euro) X X X X
Tabella 32 – Tabella decisionale Classe di reddito # 3 – tabella corretta
Riduzione delle tabelle di decisione
Utilizziamo il software Logic Friday – di cui abbiamo parlato brevemente nella prima parte - per ridurre le
tre tabelle di decisione. Il risultato che otteniamo è il seguente:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 37 di 91
Classe # 1 – Reddito annuo < 20.000 euro (limite escluso)
Figura 14 – Truth Table per classe di reddito # 1
Figura 15 – equazioni minimizzate per classe di reddito # 1
La “tabella minimizzata” (condizioni booleane elementari) è allora la seguente:
F0 = A;
F1 = A' B' C;
F2 = A' B' C;
F3 = 0;
F4 = A' C';
F5 = B;
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 38 di 91
Classe # 2 – Reddito annuo compreso tra 20.000 euro (incluso) e 40.000 euro (incluso)
Figura 16 – Truth Table per classe di reddito # 2
Figura 17 – equazioni minimizzate per classe di reddito # 2
La “tabella minimizzata” (condizioni booleane elementari) è allora la seguente:
F0 = A;
F1 = A' B' C;
F2 = 0;
F3 = 0;
F4 = A' C';
F5 = B;
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 39 di 91
Classe # 3 – Reddito annuo compreso superiore a 40.000 euro (escluso)
Figura 18 – Truth Table per classe di reddito # 3
Figura 19 – equazioni minimizzate per classe di reddito # 3
La “tabella minimizzata” (condizioni booleane elementari) è allora la seguente:
F0 = A;
F1 = A' B' C;
F2 = 0;
F3 = A' B' C;
F4 = A' C';
F5 = B;
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 40 di 91
Conviene a questo punto creare una tabella riassuntiva che mette a confronto i tre risultati ottenuti.
Tenendo conto che:
• A - Minorenne
• B - Occupata
• C - Maschio
E che :
• F0 - Assegno minorenne (500 euro)
• F1 - Assegno standard (700 euro)
• F2 - Incremento assegno standard (300 euro)
• F3 - Decremento assegno standard (200 euro)
• F4 - Assegno donna e figli (funzione numero figli e reddito)
• F5 - Tasse scalate (300 euro)
Abbiamo:
Azioni Condizioni di applicabilità per le classi di reddito
Classe # 1 Classe #2 Classe # 3
F0 - Assegno minorenne (500 euro
Minorenne Minorenne Minorenne
F1 - Assegno standard (700 euro)
Maggiorenne, non occupato, maschio
Maggiorenne, non occupato, maschio
Maggiorenne, non occupato, maschio
F2 - Incremento assegno standard (300 euro)
Maggiorenne, non occupato, maschio
/ /
F3 - Decremento assegno standard (200 euro)
/ / Maggiorenne, non occupato, maschio
F4 - Assegno donna e figli (funzione numero figli e reddito) (*)
Maggiorenne,femmina Maggiorenne,femmina Maggiorenne,femmina
F5 - Tasse scalate (300 euro)
Occupato Occupato Occupato
Tabella 33 – condizioni di applicabilità per le classi di reddito
(*) NOTA
• Per le prime due classi di reddito l’assegno alla donna si calcola con la formula: (500 +
numero_figli*100) se 0<= numero_figli <= 5; se numero_figli > 5 ==> 500 + 500 = 1000 Euro.
• Per la terza classe di reddito l’assegno alla donna si calcola con la formula: (300 +
numero_figli*100) se 0<= numero_figli <= 5; se numero_figli > 5 ==> 300 + 500 = 800 Euro.
Nella tabella, le condizioni riportate sono quelle che devono valere tutte contemporaneamente affinché sia
applicabile l’azione. In altri termini, per la classe 1, affinché si possa applicare l’azione F1 (Assegno
standard di 700 euro) deve valere la condizione (Maggiorenne) AND (Non occupato) AND (Maschio).
A parole, possiamo riformulare il requisito iniziale in questo modo (che è a questo punto più chiaro e
comunque inequivocabile):
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 41 di 91
a) Se la persona è minorenne, viene erogato un assegno di 500 euro/mese.
b) Se la persona è maggiorenne, disoccupato, maschio è erogato l’assegno standard di 700
euro/mese.
c) Se la persona è maggiorenne, disoccupato, maschio e guadagna meno di 20.000 euro/anno (limite
escluso) l’assegno standard è incrementato di 300 euro/mese.
d) Se la persona è maggiorenne, disoccupato, maschio e guadagna più di 40.000 euro/anno (limite
escluso) l’assegno standard è decrementato di 200 euro/mese.
e) Se la persona è maggiorenne e di sesso femminile percepisce un assegno calcolato nel seguente
modo:
a. Se il reddito annuo è minore di 40.000 euro (limite incluso): Import assegno = (500 +
numero_figli*100) se 0<= numero_figli <= 5; se numero_figli > 5 ==> 500 + 500 = 1000 Euro.
b. Se il reddito annuo è superiore di 40.000 euro (limite escluso): Import assegno = (300 +
numero_figli*100) se 0<= numero_figli <= 5; se numero_figli > 5 ==> 300 + 500 = 800 Euro.
f) Se la persona è occupata, le tasse vengono scalate di 300 euro/mese.
Ora, la tabella è – a mio avviso – comunque più chiara del requisito scritto, e – nella pratica – è spesso
sufficiente fermarsi alla tabella, senza riscrivere nuovamente il requisito.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 42 di 91
Capitolo 2 – Automa a stati finiti
AAUUTTOOMMAA AA SSTTAATTII FFIINNIITTII
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 43 di 91
Definizione di automa o macchina a stati finiti
La pagina http://it.wikipedia.org/wiki/Automa_a_stati_finiti di Wikipedia fornisce la seguente definizione di
automa a stati finiti:
Un automa a stati finiti (ASF) è un sistema dinamico, invariante e discreto nell'avanzamento e
nelle interazioni, nel quale gli insiemi dei possibili valori di ingresso, uscita e stato sono insiemi
finiti.
• Dinamico significa che il sistema evolve nel tempo passando da uno stato all'altro in
funzione dei segnali d'ingresso e dello stato precedente.
• Invariante: a parità di condizioni iniziali il comportamento del sistema è sempre lo stesso.
• Discreto: le variabili d'ingresso, di stato, d'uscita, possono assumere solo valori discreti.
Il testo di Paul E. Wood Jr.(Lincoln Laboratory – MIT) dal titolo “Switching Theory” (1968) alla pagina 171,
inizio del capitolo “Sequential Network” al paragrafo 2 fornisce la seguente definizione:
Definition 5-1: A sequential machine M is specified by the 6-tuple M = (X,Z,S,f,g,s), where X is the
set of all input states �̅, and S is the set of all internal states s. If the symbols �̅� , �̅�, and �� denote
the input, output, and internal states at time � (that is �̅� precedes �̅ ��), then s1 is the initial state
and the output function f and the next state function g can be defined by Eqs. (5-1) and (5-2),
respectively:
(5-1) �̅� = �(�̅� ,si)
(5-2) �̅�� = �(�̅� ,si)
Le definizioni sono formalmente perfette, ma ad una prima lettura non sono facili da comprendersi (ma se
li leggete bene perdono molto di quell’aura misteriosa che sembrano avere ad una lettura frettolosa). Per
capire che cosa sia, nella pratica, un automa o macchina a stati finiti (nel seguito ASF) vediamo un caso
pratico e torniamo un po’ indietro, a quando frequentavamo le scuole medie inferiori.
Esempio #4 – Le scuole medie inferiori
E’ ben noto che uno studente, per passare dalla classe prima media alla seconda media, deve aver
frequentato per tutto l’anno la prima media e che i professori lo promuovano nello scrutinio di fine anno
(senza che lo studente debba dare un esame di ammissione). Stessa cosa per il passaggio dalla seconda
media alla terza media. Per il passaggio dalla terza media alle scuole superiori, occorre oltre alla
promozione da parte dei professori, anche il superamento dell’esame finale da parte dell’alunno. Nel caso
in cui i professori non promuovono o lo studente non supera l’esame finale, si rimane nella stessa classe.
Quello descritto è un processo che descrive le modalità di frequentazione delle scuole medie inferiori.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 44 di 91
Possiamo dire che la classe in cui lo studente si trova (prima, seconda o terza media) rappresenta lo stato
dello studente. Il dizionario Sabatini-Coletti fornisce la seguente definizione di stato: “Condizione, modo di
essere o di trovarsi” e tale definizione ben si adatta ai nostri scopi.
Quindi, il passare dalla prima alla seconda classe significa cambiare di stato. Il processo che porta lo
studente dalla prima classe al termine della terza (considerando eventuali bocciature intermedie) si può
rappresentare con il grafico seguente:
Figura 20 – Automa a stati finiti relativo al processo “frequenza scuola media inferiore”
I cerchi rappresentano gli stati (le classi), le frecce con numeri dispari rappresentano le bocciature mentre
quelle con numeri pari le promozioni e relativo passaggio alla classe successiva. Ovviamente uno studente
non può essere contemporaneamente in due classi (non può quindi avere due stati)5.
Possiamo adesso riformulare la definizione di ASF nel seguente modo:
Un automa o macchina a stati finiti è un sistema dinamico descritto da:
a) Una variabile detta stato che può assumere N valori distinti e univoci; in altre parole, la
variabile non può mai assumere due o più valori contemporaneamente.
b) Una serie di condizioni che, secondo una certa logica definita, attivano delle azioni che
fanno transitare il sistema da uno stato all’altro.
Diamo anche la seguente definizione:
Definizione di soluzione un ASF: risolvere un automa agli stati finiti, occorre saper dire – dato uno
stato di partenza – qual è lo stato finale dell’automa. Significa anche saper dire quali sono le azioni
eventuali che sono intraprese con il cambiamento di stato (ovviamente diverse dal cambiamento di
stato stesso).
Nel caso del nostro scolaro che frequenta le scuole medie inferiori:
• La variabile di stato assume valore: 1 (prima classe), 2 (seconda classe) e 3 (terza classe).
• Le condizioni sono: essere promosso (o la duale essere bocciato) e superare l’esame finale
(o non superarlo)
• Le azioni sono di passare da una classe all’altra o di rimanere nella stessa classe (azioni che
fanno cambiare lo stato dello studente).
5 Ebbene si! Ci sono delle scuole di recupero che permettono di frequentare anche più di una classe
contemporaneamente; noi siamo tradizionalisti e ci manteniamo al “caso standard”.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 45 di 91
Una domanda sorge spontanea: poiché parliamo di condizioni e di azioni, è possibile descrivere un
ASF in termini di tabelle decisionali ? Certo che è possibile!
Riduzione di un ASF in tabella decisionale.
Consideriamo la seguente tabella decisionale:
# Colonna: 1 2 3 4 5 6 7
Condizioni
A:Classe=1 T T F F F F F
B:Classe=2 F F T T F F F
C:Classe=3 F F F F T T T
D: Promosso scrutinio T F T F T T F
E: Esame superato d.c. d.c. d.c. d.c. T F d.c.
Azioni
F0: vai in prima 1
F1: vai in seconda 1 1
F2: vai in terza 1 1 1
F3: vai alle superiori 1
Tabella 34 – tabella decisionale per esempio #4
Le condizioni A, B e C derivano dalla variabile di stato (uguale alla classe frequentata) e sono
dipendenti con la solita tabella di vincolo:
# A: S = 1 B: S=2 C: S=3
1 TRUE FALSE FALSE 2 FALSE TRUE FALSE
3 FALSE FALSE TRUE … Le altre combinazioni non sono valide
Tabella 35 – Tabella vincolo condizioni A, B e C
Dalla quale derivano le seguenti (e solite) relazioni di vincolo:
• AB’C’ = A
• A’BC’ = B
• A’B’C = C
La condizione D rappresenta la promozione a fine anno (senza esame diretto da parte dello
studente) mentre la condizione E è l’esame finale di terzo anno dello studente. Le azioni sono auto
esplicative: ad esempio, l’azione F0 indica il passaggio alla prima classe. Notate che abbiamo solo
specificato la classe (lo stato) di arrivo e non quello di partenza; lo stato di partenza è, infatti,
indicato dalle condizioni A, B e C, che – essendo dipendenti – compaiono sempre in una delle
triplette della Tabella 34.
La Tabella 34 si legge nel solito modo; ad esempio, osservando la colonna #1 vediamo che nel caso
in cui lo studente sia nella classe prima – stato = 1 corrispondente alla tripletta (A,B,C) =
(TRUE,FALSE,FALSE) – e sia stato promosso allo scrutinio finale, indipendentemente dall’esito
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 46 di 91
dell’esame (che in prima non esiste), è ammesso alla seconda classe (F1 = 1). Analoghe modalità di
lettura per le altre colonne.
Proviamo ora ad inserire la Tabella 34 in Logic Friday, usando la funzionalità di import (File →
Import Truth Table). La tabella va salvata su un file di testo riscritta nel seguente modo (fare
riferimento all’help in linea per i dettagli):
%Scuole medie – prima versione
A,B,C,D,E,,F0,F1,F2,F3
1,0,0,1,X,,0,1,0,0
1,0,0,0,X,,1,0,0,0
0,1,0,1,X,,0,0,1,0
0,1,0,0,X,,0,1,0,0
0,0,1,1,1,,0,0,0,1
0,0,1,1,0,,0,0,1,0
0,0,1,0,X,,0,0,1,0
Una volta che la tabella è stata minimizzata, otteniamo:
Le azioni minimizzate sono:
• F0 = A B' C' D' ;
• F1 = A' B C' D' + A B' C' D ;
• F2 = A' B C' D + A' B' C D' + A' B' C E';
• F3 = A' B' C D E;
Tenendo conto delle relazioni di vincolo tra le condizioni A, B e C, si ha:
• F0 = A D';
• F1 = B D' + A D ;
• F2 = B D + C D' + C E';
• F3 = C D E;
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 47 di 91
Tenendo conto del significato delle condizioni e delle azioni, abbiamo:
Equazione Descrizione
F0 = A D' Passi in prima se sei in prima e sei stato bocciato.
F1 = B D' + A D Passi in seconda se sei in seconda e sei stato bocciato oppure sei in prima e sei stato promosso.
F2 = B D + C D' + C E' Passi in terza se sei in seconda e sei stato promosso oppure sei in terza e sei stato bocciato oppure sei in terza e non hai superato l'esame finale.
F3 = C D E Passi alle superiori se sei in terza e sei stato promosso e hai superato l'esame finale.
Tabella 36 – descrizione dei risultati ottenuti
Vista quest’ultima descrizione, viene immediato pensare di interpretare le F0 →F3 non tanto come
azioni che fanno passare allo stato finale (la classe) 1,2,3 o 4 (corrispondente alla classe prima,
seconda, terza o superiori), quanto direttamente come gli stati. In altri termini, considerare:
• F0 = S1 = 1 (prima classe);
• F1 = S2 = 2 (seconda classe);
• F2 = S3 = 3 (terza classe);
• F3 = S4 = 4 (superiori);
Ciò significa avere lo stato presente sia nelle condizioni (dove viene interpretato come stato di
partenza o iniziale e rappresentato dalle condizioni dipendenti A, B e C), sia nelle azioni dove non
viene interpretato come azione vera e propria ma come stato di arrivo o finale). Le equazioni per
F0 →F3 possono allora riscriversi come:
• S1 = AD'
• S2 = BD' + AD
• S3 = BD + CD' + CE'
• S4 = CDE
Ma allora, nella parte destra delle equazioni, possiamo considerare le condizioni A, B e C come
stati iniziali, e quindi:
• A = S1
• B = S2
• C = S3
In definitiva, le azioni riscritte in termini dei soli stati e delle condizioni C e D (che non sono stati)
diventano:
• S1 = S1D'
• S2 = S2D' + S1D
• S3 = S2D + S3D' + S3E'
• S4 = S3DE
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 48 di 91
Quest’ultime equazioni legano gli stati di partenza (a destra) con quelli di arrivo (a sinistra) in
funzione anche di altre condizioni (in questo caso C e D, ossia promozione ed esito esame finale) e
rappresentano la “soluzione” dell’ASF.
Facendo riferimento alla definizione data poc’anzi e relativa alla soluzione dell’ASF, nel nostro
esempio non ci sono azioni – differenti dal cambiamento di stato stesso – che sono svolte.
Vedremo queste azioni nel prossimo esempio, un po’ più complesso.
Esempio #4bis – vacanza o studio punitivo?
Tanto però per capire che cosa siano queste altre “azioni”, supponiamo che, nel caso in cui il
nostro studente sia promosso sia premiato con una vacanza estiva, nel caso in cui sia bocciato
rimane a casa a studiare (ergo, non va in vacanza). La Tabella 34 è modificata nella parte delle
azioni, aggiungendo F4 (vai in vacanza):
# Colonna: 1 2 3 4 5 6 7
Condizioni
A:Classe=1 T T F F F F F
B:Classe=2 F F T T F F F
C:Classe=3 F F F F T T T
D: Promosso scrutinio T F T F T T F
E: Esame superato d.c. d.c. d.c. d.c. T F d.c.
Azioni
F0: vai in prima 1
F1: vai in seconda 1 1
F2: vai in terza 1 1 1
F3: vai alle superiori 1
F4: vai in vacanza 1 1 1
Tabella 37 – tabella decisionale esempio 4-bis
Ovviamente lo studente va in vacanza solo se è stato promosso (prima e seconda classe) ed è stato
promosso ed ha superato l’esame finale quando è in terza.
L’azione F4 è differente dalle altre tre F0 → F3; queste, infatti, fanno transitare allo stato (classe)
successiva; la F4 fa qualcosa di diverso. Abbiamo visto poc’anzi che le F0 → F3 coincidono con lo
stato finale del sistema. Da un punto di vista grafico, possiamo rappresentarlo in questo modo:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 49 di 91
Figura 21 – Automa a stati finiti relativo al processo “frequenza scuola media inferiore” (con vacanze)
Il triangolo etichettato con “Vacanza” non è uno stato; possiamo dire che è l’esito dell’azione F4
(indicata in figura) e che le frecce # 7 che rappresentano l’azione F4 partono dalle frecce che
collegano due classi (frecce numerate pari). Possiamo sintetizzare il tutto nella seguente tabella:
# Freccia Azione corrispondente
1 F0: vai in prima (coincide con S1)
2,3 F1: vai in seconda (coincide con S2)
4,5 F2: vai in terza (coincide con S3)
6 F3: vai alle superiori (coincide con S4)
7 F4: vai in vacanza
Tabella 38 – tabella riassuntiva delle azioni
Aggiungendo F4 alla tabella da importare in Logic Friday, abbiamo:
%Scuole medie – seconda versione
A,B,C,D,E,,F0,F1,F2,F3,F4
1,0,0,1,X,,0,1,0,0,1
1,0,0,0,X,,1,0,0,0,0
0,1,0,1,X,,0,0,1,0,1
0,1,0,0,X,,0,1,0,0,0
0,0,1,1,1,,0,0,0,1,1
0,0,1,1,0,,0,0,1,0,0
0,0,1,0,X,,0,0,1,0,0
Il risultato è il seguente:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 50 di 91
Figura 22 – Truth Table ed equazioni minimizzate.
Le azioni minimizzate sono:
• F0 = A B' C' D' ;
• F1 = A' B C' D' + A B' C' D ;
• F2 = A' B C' D + A' B' C D' + A' B' C E';
• F3 = A' B' C D E;
• F4 = A' B' C D E + A B' C' D + A' B C' D ;
Tenendo conto delle relazioni di vincolo tra le condizioni A, B e C, si ha:
• F0 = A D';
• F1 = B D' + A D ;
• F2 = B D + C D' + C E';
• F3 = C D E
• F4 = CDE + AD + BD
Riscritte in funzione degli stati, si ha:
• S1 = S1D'
• S2 = S2D' + S1D
• S3 = S2D + S3D' + S3E'
• S4 = S3DE
• F4 = S3DE + S1D + S2D
Ovviamente F0 → F3 non variano; la F4 si legge: “Vai in vacanza se sei in terza e sei stato promosso
e hai superato l’esame finale oppure se sei in prima e sei stato promosso oppure se sei in seconda e
sei stato promosso”.
Ovviamente la F4 dipende dagli stati, ma non li definisce; è questa la differenza sostanziale tra F4
e F0 → F3.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 51 di 91
Definizione formale di automa agli stati finiti in termini di tabella decisionale.
Un automa o macchina agli stati finiti è un sistema dinamico definito da:
• Una variabile di stato che può assumere N distinti valori in modo univocamente
determinato; assume un solo valore per volta.
• Una serie di condizioni che causano il variare dello stato dell’automa.
• Una serie di azioni (differenti dalle azioni responsabili del cambiamento di stato) che sono
eseguite con il cambiamento di stato6.
Tale sistema è descrivibile attraverso una tabella decisionale composta da:
i. N condizioni dipendenti: A, B, …,K,..,N per le quali valgono le N relazioni di vincolo:
(A=FALSE) AND (B=FALSE) AND (C=FALSE)…AND (K=TRUE) AND … AND (N=FALSE) = K per tutte le
condizioni K comprese tra A ed N.
ii. R condizioni binarie (indipendenti o no), diverse da quelle al punto (i).
iii. N azioni F0 →FN che coincidono con gli N stab dell’automa
iv. Q azioni F(N+1),..FQ diverse da quelle al punto (iii)
Utilizzando il metodo di minimizzazione delle equazioni per le tabelle decisionali, è possibile
esprimere gli N stati finali dell’automa – di cui al punto (iii) – in funzione degli N stati iniziali – di cui
al punto (i) – e delle R condizioni binarie – di cui al punto (ii) – ed è altresì possibile esprimere le Q
azioni - di cui al punto (iv) – anche in questo caso in funzione degli N stati iniziali – di cui la punto
(i) – e delle R condizioni binarie – di cui al punto (ii).
In sintesi: un ASF è utilizzato per modellare un fenomeno dinamico (processo) nel quale una
variabile che descrive il fenomeno (processo) assume maggiore rilevanza rispetto alle altre
variabili. Tale variabile è chiamata stato del sistema e la dinamica del processo è descritta in
termini di variazioni dello stato. Il processo è completamente risolvibile utilizzando il formalismo
della tabella condizionale, nel quale lo stato appare riformulato sia come condizioni booleane
dipendenti, sia come azione.
Come esercizio, il lettore potrà, se vuole, provare a modellare il processo di cambio della marcia di
un autoveicolo dalla prima alla quarta, considerando come condizioni che permettono lo scalare
delle marce, il numero di giri del motore e come azione, l’aumento della velocità del veicolo,
tenendo conto che non è possibile scalare di più di una marcia per volta (se si passa dalla prima
alla quarta è probabile che la macchina si inchiodi in mezzo alla strada).
6 Dire “con il cambiamento di stato” sembra voler dare una dimensione temporale al sistema dinamico. Quello che si vuole significare è che il cambiamento di stato e le azioni occorrono entrambi (e nel senso di AND logico), indipendentemente da quale delle due si verifichi prima su scala temporale. La dinamica, per un ASF, è dettata dal variare dello stato e non dalla variabile temporale (a meno che le due cose non coincidano).
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 52 di 91
Capitolo 3 – Reti di Petri
RREETTII DDII PPEETTRRII
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 53 di 91
Definizioni
Wikipedia alla pagina http://it.wikipedia.org/wiki/Rete_di_Petri fornisce la seguente definizione
della rete di Petri:
“Una rete di Petri (conosciuta anche come rete posto/transizione o rete P/T) è una delle varie
rappresentazioni matematiche di un sistema distribuito discreto. Come un linguaggio di
modellazione, esso descrive la struttura di un sistema distribuito come un grafo bipartito con delle
annotazioni. Ovvero, una rete di Petri ha dei nodi posti, dei nodi transizioni e degli archi diretti
che connettono posti e transizioni .”
Carl Adam Petri (Lipsia, 12 luglio 1926 – 2 luglio 2010), fu un matematico ed informatico tedesco
che inventò tale formalismo nello svolgimento della tesi di dottorato “dal titolo «Kommunikation mit
Automaten» (Comunicazione con gli automi), nella quale introduce la teoria sulle reti appunto dette di Petri,
grazie alle quali si compiono passi in avanti nel campo della computazione parallela e distribuita e nel
definire i moderni studi dei sistemi complessi e la gestione dei workflow” (fonte:
http://it.wikipedia.org/wiki/Carl_Adam_Petri ).
Il volume di James L. Peterson (University of Austin – Texas) dal titolo “Petri Net Theory and
modelling of systems” fornisce al paragrafo 2.1 del secondo capitolo, la seguente:
DEFINITION 2.1: A Petri net structure C, is a four-touple, C = (P,T,I,O). P = {p1, p2, …, pn} is a finite
set of places, n≥0. T = {t1, t2, …, tm} is a finite set of transitions, m ≥0. The set of places and the set
of transitions are disjoint, P ∩ T = Ø. I: T → P∞ is the input function, a mapping from transitions to
bags of places. O: T → P∞ is the output function, a mapping from transitions to bags of places.
Ricordiamo che si definisce “bag” (in inglese borsa, contenitore) un set (insieme) per il quale sono
ammessi elementi multipli. Ad esempio: {1,2,3} è un insieme, mentre {1,2,3,2,1} è un bag in
quanto gli elementi 1 e 2 compaiono più di una volta; un insieme è quindi un caso particolare di
bag.
Per meglio comprendere di cosa stiamo parlando vedremo alcuni esempi, tenendo conto che non
è mia intenzione sviluppare nel dettaglio la teoria delle reti di Petri (cosa per la quale esistono
ottimi libri) ma solo fornire alcune indicazioni generali per permettere al lettore, che non ha mai
sentito parlare di questo strumento matematico, di leggere e interpretare una rete di Petri.
Le reti di Petri possono essere rappresentate graficamente nel modo che segue:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 54 di 91
Figura 23 – Rete di Petri elementare
I cerchietti {p1, p2} sono i posti (in inglese place), t1 è la transizione (in inglese transition) e le
frecce che collegano posti e transizioni rappresentano dei flussi relazionali chiamati archi (in
inglese arc).
In particolare, p1 è un input per la transizione t1, mentre p2 è un output. Una transizione può avere
più input e più output. Ad esempio, nel grafico seguente, un po’ più complesso:
Figura 24 – Rete di Petri un po’ più complessa.
La rappresentazione della rete di Petri in Figura 24 è equivalente alle seguenti equazioni:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 55 di 91
• (p2,p3,p5) = t1(p1)
• p5 = t2(p2,p3,p5)
• (p2,p3) = t3(p4)
• p4 = t4(p2)
Consideriamo la prima equazione: (p2,p3,p5) = t1(p1): tale espressione significa che i posti (p2,p3,p5)
sono degli output della transizione t1 che ha come (unico) input p1. Una stessa transizione può
avere più di un input e più di un output.
Le equazioni di cui sopra possono anche essere riscritte esplicitando, per ogni transizione, gli input
e gli output:
• I(t1) = p1 O(t1) = p2,p3,p5
• I(t2) = p2,p3,p5 O(t2) = p5
• I(t3) = p4 O(t3) = (p2, p3)
• I(t4) = p2 O(t4) = p4
Per capire se un posto pi di una transizione tj è un input o un output è sufficiente osservare la
direzione della freccia da pI a tj: se è entrante nella transizione è un input; se è uscente dalla
transizione, allora è un output.
Dinamicità nelle reti di Petri: i token.
Tutto quanto è stato raccontato sin’ora è sicuramente molto interessante, da un punto di vista
teorico, ma dal lato pratico, a che serve ?
Consideriamo il seguente semplice processo relativo a una visita medica (della durata media di 15
minuti per paziente, ma che può variare). I pazienti si presentano allo studio medico e attendono il
loro turno in sala d’attesa. Il medico, non appena termina una visita – e quindi rimane libero –
chiama un paziente nella sala visite e lo visita. Così via sino a che non è terminato l’orario di visita,
oppure non ci sono più pazienti oppure ancora il medico non è più disponibile.
Il grafico in Figura 25 descrive tale processo facendo uso del formalismo delle reti di Petri.
I pallini neri che vediamo all’interno dei posti p1, p2 e p3 sono i token (che in inglese significa
gettone, marcatore). Tali token servono per fornire una dinamicità alla rete di Petri; nel nostro
esempio, rappresentano:
• In p1 i pazienti presenti in sala d’aspetto (1 token = 1 paziente).
• In p2 il medico libero (pronto per eseguire una nuova visita).
• In p3 il fatto che siamo o non siamo nell’orario di visita (se c’è il token, siamo nell’orario di
visita, altrimenti non lo siamo).
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 56 di 91
Figura 25 – Rete di Petri relativo al processo di visita medica – configurazione iniziale
Le equazioni della rete in Figura 25 riguardano le sole transizioni t1 e t2 e si scrivono:
• (p2,p4) = t1(p1,p2,p3)
• p3 = t2()
Si noti che la transizione t2 non ha input e vedremo tra un attimo che cosa significa.
Per capire come i token aiutino a rendere dinamica la rete di Petri, consideriamo la transizione t1
come un “consumatore/produttore di token” e seguiamo a passo a passo il “movimento” dei
token.
Il medico inizia la visita al paziente; vi è un paziente in meno in sala d’aspetto (un token in meno in
p1) e il medico non è più libero (sta visitando il paziente) e il grafico è allora quello di Figura 26.
Al termine della visita, che dura circa quindici minuti, il paziente che è appena stato visitato si reca
all’uscita mentre il medico è nuovamente libero e pronto per visitare un altro paziente. Il paziente
visitato (token) si trova quindi in p4 mentre il medico ritorna in p2 e il grafico è quello
rappresentato in Figura 27.
Durante i quindici minuti (circa) di visita (configurazione riportata in Figura 26) la transizione t1 è
congelata (in inglese si dice che la rete “is dead”, è morta) poiché non sono verificate tutte le
condizioni affinché la transizione di attivi (il medico non è libero, anche se ci sono pazienti e siamo
in orario di visita).
Per passare dalla configurazione iniziale in Figura 25 a quella finale (termine visita primo paziente)
in Figura 27 la transizione t1 si è attivata (in inglese fired) ed ha spostato un token da p1 a p4. Ha poi
spostato il token da p2 per poi rimettervelo al termine della visita e infine ha consumato il token in
p3; in quest’ultimo caso, il token appena consumato è stato rimpiazzato da un altro token
proveniente dalla t2 (l’orologio), poiché si suppone che siamo ancora in orario di visita.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 57 di 91
Figura 26 – Rete di Petri relativo al processo di visita medica – il medico sta visitando il paziente
Figura 27 – Rete di Petri relativo al processo di visita medica – termine visita al primo paziente
In altri termini, la transizione t2 è attiva se siamo in orario di visita (nel qual caso avremo sempre
un token in p3), non è attiva se siamo fuori dell’orario di visita (nel qual caso una volta che il token
è stato consumato da t1, non è più rimpiazzato da t2) Nell’immagine che segue, sono riportati la
configurazione iniziale, intermedia e finale dei token, al fine “simulare la dinamica” dei token.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 58 di 91
Figura 28 – Rete di Petri relativo al processo di visita medica – configurazione iniziale, intermedia e primo
passo
Le frecce rosse del grafico intermedio in Figura 28 cercano di dare il senso del movimento dei
token. La transizione t2, che non ha input, è attiva o non lo è in dipendenza di una condizione
esterna che non è riportata nella rete di Petri, e costituisce quindi il confine della descrizione della
rete; quello che sta fuori di questo confine non è importante (in questo caso, non interessa com’è
contato il tempo e/o come funziona un orologio), interessa solo l’effetto.
Si sarà notato che i “significati semantici” dei token in p1, p2 e p3 sono differenti:
i. I token in p1 e p2 rappresentano degli elementi fisici (in questo caso addirittura delle
persone, i pazienti, e il medico).
ii. Il token in p1 e p2 può essere interpretato in due modi (equivalenti):
a. Un elemento “fisico” di tempo all’interno del quale è svolta la visita (i quindici
famosi minuti, più o meno).
b. Un “flag” (o condizione) che è ON (condizione verificata), quando c’è il token in p3.
Abbiamo detto in precedenza che la transizione può essere vista come un “consumatore di token“;
in effetti, questo vale sicuramente per tutti i token in p1, p2; per quelli in p3 vale solo se rimaniamo
nell’interpretazione (ii.a); se consideriamo l’interpretazione (i.b) il token rimane sino a quando non
termina l’orario di visita (e quindi non è propriamente “consumato”, anche se possiamo usare
questo termine anche nel caso in cui la transizione consumi zero token).
Tutto questo discorso per dire che l’interpretazione su cosa sono e cosa non sono i token, da un
punto di vista semantico e/o significato fisico, dipende esclusivamente dal problema che si sta
analizzando. Vedremo più avanti altri esempi; ora continuiamo nell’analisi del nostro modellino di
visita medica.
Terminata la visita al primo paziente, siamo nella configurazione riportata in Figura 27; il medico è
libero, e può visitare un nuovo paziente. La cosa si ripete sino a che tutti i pazienti sono stati
visitati, ottenendo le configurazioni riportate nei grafici che seguono:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 59 di 91
Figura 29 – Rete di Petri relativo al processo di visita medica – tutte le configurazioni relative alle visite
La configurazione (A) è quella di partenza (tutti e cinque i pazienti devono essere visitati), la (F) è
quella finale nella quale tutti i pazienti sono stati visitati. Nel mezzo ci sono le configurazioni
intermedie, nelle quali alcuni pazienti sono stati visitati e altri sono in attesa; per esempio, nella
configurazione (C) tre pazienti sono in attesa mentre che due sono stati visitati e sono in uscita.
Abbiamo tre token nel posto p1 e due token nel posto p4. Tra la (A) e la (B) vi è la configurazione
riportata in Figura 26, che rappresenta il dottore che sta visitando il primo paziente. Tra la (B) e la
(C), tra la (C) e la (D), e così via sino alla fine vi sono configurazioni analoghe a quella di Figura 26
(non riportate), nelle quali varia il numero dei token in p1 (diminuiscono) ed in p4 (aumentano).
Arrivati nella configurazione (F) la rete è congelata; in pratica, se non ci sono più pazienti, anche se
siamo nell’orario di visita e il medico è disponibile, stiamo fermi.
La configurazione (F) non è però l’unica nella quale la rete di Petri relativa al processo di visita
medica è congelata; la rete è congelata quando almeno una delle seguenti condizioni è verificata:
1. Non ci sono pazienti (zero token in p1)
2. Il medico non è disponibile (zero token in p2)
3. Siamo fuori dell’orario di visita (zero token in p3)
E’ ovvio che quando più di una delle condizioni 1 →3 è verificata, la rete è a maggior ragione
congelata. Possiamo riassumere il tutto nella seguente tabella:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 60 di 91
# Colonna: 1 2 3 4 5 6 7 8
Condizioni
Pazienti >=1 T T F F T T F F
Medico disponibile T F T F T F T F
In orario di visita T T T T F F F F
Condizioni Rete (Attiva/Congelata) A C C C C C C C
Tabella 39 – Tabella riassuntive della condizione della rete di Petri
L’unico caso in cui la rete di Petri in analisi è attiva (indicata con A) è quando tutte le condizioni
sono a TRUE. Quando almeno una condizione è FALSE la rete è congelata (indicata con C). Nella
figura sotto, sono rappresentate graficamente le sette configurazioni 2 →8 nelle quali la rete è
congelata.
Figura 30 – Rete di Petri relativo al processo di visita medica – tutte le configurazioni congelate
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 61 di 91
I numeri tra parentesi si riferiscono al’identificativo della colonna delle combinazioni riportate in
Tabella 39.
Il lettore avrà notato che il numero di token nei grafici della Figura 29 è sempre uguale ed in questo
caso pari a sette. Sarebbe completamente errato pensare che in una rete di Petri il numero di
token si conservi! In questo caso particolare, è vero che in numero di token rimane sempre uguale,
ma non è vero per il caso generale, applicabile a qualsiasi rete di Petri. Ma, anche nel nostro
esempio di processo di visita medica, se guardiamo ai grafici di Figura 30, vediamo che il numero di
token varia; già questo basterebbe come controprova per dire che – nel caso generale – non vale
la legge di conservazione del numero di token.
Vediamo ora un secondo esempio che getta nuova luce sulle proprietà delle reti di Petri.
Esempio # 5 – Cucire le … stringhe!
Consideriamo la seguente semplice macchina di Petri:
Figura 31 – Rete di Petri che si riferisce a una transizione che unisce due stringhe.
Nel posto p1 abbiamo un certo numero di stringhe alfanumeriche in input, ad esempio: ltpVKbzr5s,
HPpvNL3epB, E2l0K2nqa8, 1GIYhArdQ4.
La transizione t1 non fa altro che prendere due stringhe e le unisce; ad esempio, prendendo le
prime due stringhe riportate nella riga precedente, abbiamo: t1(ltpVKbzr5s, HPpvNL3epB) =
ltpVKbzr5sHPpvNL3epB.
La stringa prodotta è quindi spostata in p2, che quindi contiene le stringhe concatenate.
Nel nostro esempio abbiamo considerato stringhe di 10 caratteri, ma potete usare stringhe di
lunghezza variabile, solo numeriche, etc.. Non ha importanza ai fini del nostro esempio.
Indicando le stringhe con token, ed eliminando le stringhe dalle etichette dei posti, otteniamo il
grafico equivalente a Figura 31 ma più “sobrio e gestibile”:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 62 di 91
Figura 32 – Rete di Petri che si riferisce a una transizione che unisce due stringhe.
L’equazioni della rete è una sola, avendo una sola transizione, ed è:
• p2 = t1(p1)
Facciamo notare che il primo arco, quello che unisce p1 con t1 contiene il numero 2 come
etichetta. Cosa significa ? Significa che attraverso quest’ arco possono passare solo e soltanto 2
token per volta. Questo significa che:
• Se in p1 c’è un solo token, la transizione non scatta; la rete è congelata.
• Se in p1 ci sono due token, la transizione scatta una volta, consuma due token in p1 e
produce un token in p2 e la rete si congela.
• Se in p1 ci sono tre token, la transizione scatta una volta, consuma due token in p1 e
produce un token in p2; rimane un token in p1 e la rete si congela.
• Se in p2 ci sono quattro token, la transizione scatta una prima volta, consuma due token in
p1 e produce un token in p2, scatta una seconda volta, consuma altri due token in p1 e
produce un altro token in p2; resta zero token in p1 e la rete si congela.
Abbiamo capito il meccanismo; un solo token non è sufficiente a far scattare la transizione t1.
Se abbiamo un numero pari 2N di token in p1, la transizione t1 può scattare 2N/2 = N volte,
svuotando p1 e inserendo in p2 N token.
Se abbiamo un numero dispari (2N+1) di token in p1, la transizione t1 scatta sempre 2N/2 = N
volte, ma al termine rimane un solo token in p1 e N token in p2.
Nel grafico che segue mostriamo le varie configurazioni nei casi in cui nella configurazione iniziale
ci sia un numero pari (sei) o dispari (sette) di token in p1.
Quanto sopra mostra che una rete di Petri può avere degli archi, che collegano posti e transizioni
con un peso diverso da uno. Il peso rappresenta il numero esatto di token che devono
necessariamente passare attraverso l’arco e, di conseguenza, da un’indicazione di quale deve
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 63 di 91
essere il numero minimo di token che devono essere presenti nel posto da cui parte l’arco. Si pensi
all’arco come un tubo; se il tubo ha peso uno (non indicato) può passare un solo token ogni volta
che scatta la transizione; se il peso è – ad esempio – due possono passare due token ogni
qualvolta la transizione scatta. Questo significa che nel posto da cui esce l’arco devono essere
rispettivamente presenti almeno uno e due token.
Figura 33 – Rete di Petri che si riferisce a una transizione che unisce due stringhe – caso pari (6 token in p1)
Figura 34 – Rete di Petri che si riferisce a una transizione che unisce due stringhe – caso dipari (7 token in p1)
In alternativa il numero sull’arco può essere visto come molteplicità del posto di input rispetto alla
transizione di cui è input. In questo caso diciamo che p1 ha molteplicità 2 rispetto alla transizione
t1. Uno stesso posto, nel caso in cui sia input per differenti transizioni , può avere molteplicità
diversa per ciascuna transizione.
Le configurazioni nelle quali la rete di Petri del cucitore di stringhe è congelata sono due: la prima
è quella in cui in p1 vi sono zero token e la seconda è quella in cui in p1 vi è un token. In tutti gli
altri casi, la transizione t1 scatta almeno una volta (quando in p1 vi sono tre token); e questo
indipendentemente da quanti siano i token che sono presenti in p2.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 64 di 91
Nel grafico di Figura 35 abbiamo indicato le due configurazioni che congelano la rete di Petri,
inserendo anche un certo numero di token nel posto p2, per evidenziare quanto detto poc’anzi.
Figura 35 – Rete di Petri che si riferisce a una transizione che unisce due stringhe – configurazioni congelate.
Valore semantico e definizioni formali
Veniamo ora ad alcune considerazioni riguardanti la differenza tra il valore semantico di un
generico “oggetto” e la sua definizione formale; in questo caso gli oggetti che ci interessano sono i
token, i posti e le transizioni che abbiamo visto essere tutti elementi di una rete di Petri.
Negli esempi di cui sopra, siamo stati in grado – data una configurazione di token all’interno di una
rete di Petri – di dedurre le configurazioni successive poiché eravamo a conoscenza di che cosa i
token rappresentassero. Nel primo esempio, i token in p1 rappresentano dei pazienti in attesa di
visita, quello in p2 il medico libero, quello in p3 un generico periodo temporale nel quale svolgere
la visita e quello in p4 il paziente in uscita. Nel secondo esempio, i token in p1 rappresentano delle
stringhe e i token in p2 rappresentano delle stringhe derivate concatenando quelle contenute in
p1. Conoscendo poi il processo della visita medica e di concatenazione delle stringhe, diventa
possibile determinare – data una configurazione di token – quella successiva. Così facendo
abbiamo utilizzato il valore semantico (= significato fisico) associato ai token e i due processi sono
stati descritti utilizzando un formalismo matematico (ma prettamente grafico) chiamato rete di
Petri.
Il formalismo matematico diventa però più utile quando – anziché considerare il valore semantico
degli elementi – si forniscono delle definizioni di tali elementi e delle regole per operare su di essi.
In altre parole, diamo una definizione formale di rete di Petri e degli elementi che la compongono
e delle regole per operare su tali elementi. Così facendo possiamo operare sulla rete a prescindere
dal significato semantico e definire le successive configurazioni della rete a partire da una data.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 65 di 91
Poi, se abbiamo la necessità di farlo, possiamo interpretare il risultato ottenuto da un punto di
vista semantico.
Definizione (di rete di Petri): Una rete di Petri è composta di quattro parti:
• Un insieme di posti PPPP = {p1, p2, …, pn} con n>=0 che possono contenere un certo numero di
token (da zero a infinito). I token sono rappresentati da pallini neri ● nella
rappresentazione grafica della rete di Petri.
• Un insieme di transizioni TTTT = {t1, t2, …, tk} con k >=0
• Una funzione di input IIII
• Una funzione di output OOOO
L’insieme dei posti di input e delle transizioni sono disgiunti, i.e. P P P P ∩ T = ØT = ØT = ØT = Ø. La funzione di input e
quella di output mettono in relazione le transizioni con i posti, nel seguente modo: la funzione di
input I : T → P∞ mappa la transizione tj ad una insieme di posti di input {pa, pb, ..,pr} e si indica con
IIII (tj); la funzione di output O: T → P∞ mappa la transizione tj ad un insieme di posti di output {ps,
pt, ..,pz}, alcuni dei quali possono anche coincidere con i posti di input.
Dalla definizione data deriva il seguente:
Corollario I:
• Un posto pj è un posto di input per la transizione tj se pi ∈ I I I I (tj).
• Un posto pj è un posto di output per la transizione tj se pi ∈ O O O O (tj).
• Un posto pi può essere un posto di input multiplo di molteplicità K per la stessa transizione
ti, e scriviamo pi ∈ I I I I K(ti).
• Un posto pi può essere un posto di output multiplo di molteplicità R per la stessa
transizione ti, e scriviamo pi ∈ O O O O R(ti).
Un posto pi può contemporaneamente essere un posto di input (semplice o multiplo, con
molteplicità differenti) per differenti transizioni ed essere un posto di output (semplice o
multiplo, con molteplicità differenti) per altre transizioni . Può anche essere
contemporaneamente input ed output (semplice o multiplo) per la stessa transizione.
La molteplicità del posto di input viene graficamente rappresentato dal peso dell’arco che connette
il posto con la transizione, come visto nel paragrafo “Esempio # 5 – Cucire le … stringhe!”.
Il grafico sotto mostra il posto p1 con molteplicità uno (che non viene segnalata in quanto si ritiene
che sia il caso standard), mentre il posto p2 ha molteplicità quattro (numerino a ridosso dell’arco
che connette p2 con t1).
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 66 di 91
Figura 36 – Il posto di input p1 ha molteplicità 1 (non segnata) e p2 ha molteplicità 4 (segnata).
Vedremo tra un po’ altri esempi.
Definizione (di configurazione): la configurazione di una rete di Petri con posti PPPP = {p1, p2, …, pn} è
definita da un vettore con n elementi μ = {m1,m2,…,mn}, con mj (j=1,2,…,n) numeri interi positivi,
zero incluso. Il vettore μdefinisce, per ciascun posto pj, il numero di token presenti nel posto pj.
Il concetto di token deve essere considerato come un concetto elementare, non ulteriormente
definibile.
La regola che segue è fondamentale nella determinazione della sequenza delle configurazioni,
nota quella di partenza.
Regola di attivazione di una transizione (transition firing rule):
Una transizione si attiva se e solo se, in ciascun dei suoi posti di input, sono presenti un numero di
token pari almeno alla molteplicità del posto di input rispetto alla transizione considerata. Una
transizione che si è attivata genera nei posti di output un numero di token pari alla molteplicità del
posto di output.
Corollario II: Se un posto di input di una transizione ha zero token, la transizione non può attivarsi.
Definizione (di transizione congelata): nel caso in cui una transizione non possa attivarsi, si dice
che la transizione è congelata.
Corollario III: Se tutte le transizioni di una rete di Petri sono congelate, allora la rete di Petri è
congelata e la configurazione μ è statica.
Definizione (di configurazione stazionaria): nel caso in cui – in una rete di Petri – una
configurazione μsia tale che la successiva attivazione di tutte le transizioni abilitate porti la rete
nella stessa configurazione μ,si dice che la configurazione μ è stazionaria.
In pratica, se abbiamo una configurazione tale per cui tutte le transizioni sono congelate, la
configurazione è statica (nulla si muove); nel caso in cui alcune transizioni – per quella
configurazione – sono attive, ma la configurazione che ne consegue dopo la loro attivazione è la
stessa di quella di partenza, la configurazione è stazionaria (c’è del movimento di token, ma è
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 67 di 91
sempre lo stesso). Ancora detto in altro modo: se la configurazione è statica la rete di Petri è
congelata e viceversa; non così se la configurazione è stazionaria, in cui alcune – al limite tutte – le
transizioni sono abilitate.
Nella tabella che segue mostriamo un po’ di casi che servono a chiarire le definizioni date e che –
in qualche modo – abbiamo già visto negli esempi precedenti.
# Rappresentazione Grafica Descrizione
1
I posti di input p1 e p2 hanno molteplicità 1 (frecce di connessione senza numero) ed entrambe hanno un token. La t1 è attiva e quando scatta elimina i token da p1 e p2 e inserisce un token in p3. Dopo il primo giro la t1 è congelata (non ci sono più token in p1 e p2). La configurazione finale è quindi statica.
2
Il posto di input p1 ha molteplicità quattro, ma contiene solo tre token. Anche se p2 ha il numero di token corretto (pari a uno), la transizione t1 non è attiva. La configurazione è quindi statica.
3
Il posto p1 è sia di input che di output per la transizione t1. La t1 è attiva e quando scatta, porta via tre token da p1 (input di molteplicità tre) e inserisce un token sempre in p1 (output di molteplicità uno). A questo punto è congelata, poiché in p1 rimangono solo due token (e ce ne vanno almeno tre perché t1 scatti). La configurazione finale è quindi statica.
4
Il posto p1 è di input sia per t1 che per t2 e contiene due token. Considerando che p1 è di molteplicità uno sia per t1 che per t2 (ovvero, che ciascuna transizione consuma un token), entrambe sono attive. Il risultato è che t2 aggiunge tre token in p2 (output di molteplicità tre per t2) mentre t1 aggiunge un token in p2 (output di molteplicità uno per t1), per un totale di quattro token in p2. Il posto p1 rimane vuoto, le transizioni sono congelate e la configurazione finale è statica.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 68 di 91
5
l posto p1 è di input sia per t1 che per t2 e contiene quattro token. Considerando che p1 è di molteplicità tre per t1 e molteplicità cinque per t2, può essere attiva solo t1 (ci sono quattro token, uno in più di quanto serve per attivare la t1) . Il risultato è che t1 aggiunge un token in p2 (output di molteplicità uno per t2) mentre t2 è ferma. Il posto p1 rimane un solo token, insufficiente per far scattare t1 o t2 (o entrambi) e le transizioni sono congelate. La configurazione finale è quindi statica.
6
La configurazione μ = (2) è stazionaria; entrambi le transizioni t1 e t2 sono attive. La t1 consuma 1 token da p1 e la t2 consuma 1 token da p1 e ne crea due sempre in p1. Alla fine la configurazione è la stessa e le transizioni sono sempre abilitate.
Tabella 40 – Reti di Petri - esempi di configurazione
Sino ad ora non abbiamo detto nulla riguardo quando le transizioni scattano, intendendo con
questo stabilire l’ordine con cui le transizioni si attivano. Consideriamo ad esempio il #4 della
tabella precedente. Il fatto che scatti prima t1 e poi t2 o viceversa o, ancora, entrambe
contemporaneamente, nulla cambia sulla configurazione finale. In casi come questi possiamo
convenire di farle scattare contemporaneamente (ma, ripeto, è una convenzione). Consideriamo
invece l’esempio seguente:
Figura 37 – Reti di Petri non decidibile
Il posto p1 è un input di molteplicità uno sia per t1 che per t2 ed in p1 vi è un solo token. Non
possono scattare entrambi e se scatta prima la t1 abbiamo la seguente configurazione:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 69 di 91
Figura 38 – Reti di Petri non decidibile – prima possibilità (scatta t1)
Se scatta prima la t2, la configurazione è diversa:
Figura 39 – Reti di Petri non decidibile – seconda possibilità (scatta t2)
In questi casi, non vi è possibilità di decidere tra le due configurazioni finali e occorre veramente
rifarsi al valore semantico dei token o decidere “d’ufficio” quali tra le due transizioni fare scattare
e quindi quale tra le due configurazioni finali considerare.
Tenendo conto di tutto quanto detto sino ad ora, definiamo esattamente quello che è il problema
fondamentale da risolvere per una generica rete di Petri.
“Data una rete di Petri con posti PPPP = {p1, p2, …, pn} con n>=0, transizioni TTTT = {t1, t2, …, tk} con k>=0 ed
una configurazione μ0 = {m1,m2,…,mn}, con mj (j=1,2,…,n) numeri interi positivi, zero incluso, trovare
tutte le successive configurazioni μr = {m1,r,m2,r,…,mn,r} per r=1,2,… che si presentano al termine
dell’attivazione di tutte transizioni TTTT ((((7)))), fermandosi qualora si presenti una configurazione
stazionaria o statica, se esistono”.
7 Si deve intendere che, ogni volta, tutte le transizioni sono attivate; una transizione congelata può considerarsi “attivata” anche se non produce nessuna modifica nella configurazione. Quindi, al termine del primo giro, tutte le transizioni sono state attivate una volta, al termine del secondo giro tutte le transizioni sono state attivate due volte… e così via sono a non raggiungere una configurazione (se esiste) in cui tutte le transizioni sono congelate, la rete è congelata e la configurazione è statica. Oppure si arriva ad una o più configurazioni che si ripetono periodicamente all’infinito e quindi stazionarie (e in questo caso è sufficiente fermarsi quando si siano definite le/la configurazioni periodiche).
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 70 di 91
In termini più formali, possiamo scrivere: μr=TTTT(μr-1);la configurazione μrsi ottiene a partire dalla
configurazione μr-1applicando ad essa l’insieme delle transizioni TTTT. E’ ovvio che le transizioni che,
nella configurazione μr-1sono congelate, non vengono attivate8 (si seguono le regole di attivazione
di una transizione).
Descrizione operativa di una rete di Petri.
Le definizioni di cui al paragrafo precedente, pur essendo rigorosamente corrette, sono poco utili
per la definizione di un metodo operativo per il calcolo delle configurazioni di una rete di Petri,
data una configurazione iniziale. Forniamo ora una definizione operativa utile allo scopo.
Una rete di Petri è definita da una matrice R detta “matrice della rete” e da un vettore di
configurazione μμμμ.La matrice è la seguente:
p1 p2 p3 … pn
t1 t1,1 t1,2 t1,3 … t1,n
t2 t2,1 t2,2 t2,3 … t2,n
t3 t3,1 t3,3 t3,3 … t3,n
… …
tm tm,1 tm,2 tm,3 … tm,n Tabella 41 – Tabella della Rete di Petri
Il vettore di configurazione è il seguente:
μ = {m1,m2,…,mn}, con mj (j=1,2,…,n) numeri interi positivi, zero incluso
Le colonne della tabella R rappresentano i posti della rete di Petri, mentre le righe rappresentano
le transizioni. Il coefficiente tij all’incrocio della riga e della colonna rappresenta la molteplicità del
posto pi rispetto alla transizione tj. Se il valore ti,j è negativo, il posto pj è di input rispetto alla
transizione ti. Se il valore ti,j è positivo, il posto pj è di output rispetto alla transizione ti; nel caso il
valore sia zero o non sia indicato, vuol dire che posto pj e transizione ti non sono tra di loro
connessi.
Il significato del vettore di configurazione è ormai noto: l’elemento mj del vettore rappresenta il
numero di token presenti nel posto pj della rete di Petri.
Ad esempio, nel caso della rete riportata nella Figura 40, la tabella R e il vettore di configurazione μ
è il seguente:
p1 p2 p3 p4 p5
t1 -3 -2 +1
t2 -1 -4 +1 +5 μ = {5,6,1,0,0},
Tabella 42 – Matrice R e configurazione per la rete di Petri in Figura 40
8 Si può dire che l’attivazione non produce cambiamenti nella configurazione finale.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 71 di 91
Figura 40 – Reti di Petri da analizzare.
Ne caso in cui una stessa posizione p sia input e output per una stessa transizione t, è sufficiente
segnare nella matrice entrambi i valori, come coppia in parentesi. Ad esempio per la rete nella riga
#6 della Tabella 40 la matrice ed il vettore di configurazione è il seguente:
p1
t1 -1
t2 (-1,2)
μ = {2}
Tabella 43 – Matrice R e configurazione per la rete di Petri #6 della Tabella 40.
A questo punto, definita la modalità operativa di rappresentazione di una rete di Petri, che quindi
è definita da una matrice ed un vettore, possiamo affrontare il problema del calcolo delle
configurazioni a partire da una configurazione data. Prima però analizzeremo due problemini
puramente matematici, che starebbero benissimo tra i quiz della “Settimana Enigmistica” da
risolvere sotto l’ombrellone, ma che sono strettamente correlati con la soluzione del problema
fondamentale per una rete di Petri.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 72 di 91
Combinazioni parziali distinte di N numeri interi.
Consideriamo K numeri interi {n1,n2,..., nk} e chiediamoci come fare per creare le combinazioni di tutti i K
numeri presi: uno a uno, due a due, tre a tre, …, kappa a kappa. In tali combinazioni lo stesso numero non
può apparire due volte e l’ordine della combinazione non è importante, ma occorre considerarlo una volta
sola; ad esempio la coppia (n1,n2) coincide con (n2,n1) e quindi basta considerarne una sola. Chiameremo
tali combinazioni come “combinazioni parziali distinte”.
Ad esempio, consideriamo i quattro numeri A = {1,2,3,4}.
• Le combinazioni dei numeri A presi uno a uno coincidono con i numeri stessi. Chiamiamo C1 =
{1,2,3,4}.
• Le combinazioni dei numeri A presi due a due sono le seguenti coppie: C2 = {(1,2), (1,3), (1,4), (2,3),
(2,4), (3,4)}.
• Le combinazioni dei numeri A presi tre a tre sono le seguenti terzine: C3 = {(1,2,3), (1,2,4), (2,3,4),
(3,4,1)}
• Le combinazioni dei numeri A presi quattro a quattro è la seguente e unica quaterna: C4 = {(1,2,3,4)}
Si nota che le combinazioni di K numeri “presi uno a uno” coincidono con i numeri stessi, mentre le
combinazioni dei numeri “presi K a K” è sempre una sola e consiste nella k-pla composta da tutti i numeri.
Per trovare la regola generale, consideriamo la seguente espressione: (a1∙n1,a2∙n2,...,ak∙nk) dove ai sono dei
numeri che moltiplicano ni ma che possono solo valere 0 od 1. Allora, tutte le possibili combinazioni si
trovano facendo variare ai su tutte le possibili combinazioni (i=1,2,…,k) con la regola che se ai=0, l’elemento
non si scrive. In pratica, l’espressione: (1∙1,0∙2,1∙3,0∙4) coincide con la coppia (1,3). Se ne deduce anche che
tutte le combinazioni parziali distinte sono 2k. Per praticità possiamo considerare la matrice delle
combinazioni, un po’ come facevamo per le tabelle decisionali. Ad esempio, nel caso dell’esempio dei
numeri A, l’espressione da considerare è la seguente: (a1∙1,a2∙2, a3∙3,a4∙4) e la matrice con tutte le
combinazioni dei ai (i=1,2,3,4) è la seguente:
# → 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
1 1
1 1 1
1 1
1 1
2
1
1
1 1
1 1 1
1
3 1 1 1 1 1 1 1 1
4 1 1 1 1 1 1 1 1
Num. ↑ C1 C2 C3 C4
Tabella 44 – Tabella delle combinazioni dei coefficienti ai.
Ciascun colore indica le combinazioni di elementi presi a numero fisso:
• C1: elementi presi uno ad uno (giallo)
• C2: elementi presi due a due (verde)
• C3: elementi presi tre a tre (azzurro)
• C4: elementi presi quattro a quattro (bianco)
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 73 di 91
Notiamo che la colonna 1 coincide con “nessuna combinazione” che nel nostro caso non ci interessa.
Quindi possiamo – in generale – dire che il numero di combinazioni parziali distinte che ci interessano di k
numeri è 2k-1.
Scorrendo la colonna si trova la combinazione seguendo la regola prima accennata. Se nella casella
compare il numero 1, consideriamo il numero nella prima colonna a sinistra, altrimenti non lo
consideriamo. Ad esempio, la colonna 6 diventa la coppia (1,2), mentre la colonna 13 diventa la tripletta
(1,2,4).
Si faccia attenzione a com’è stata costruita la tabella delle combinazioni:
• Le combinazioni C1 hanno tutti 1 sulla diagonale.
• Le combinazioni C2 si ottengono fissando il primo 1 sulla prima riga e il secondo 1 a scalare di un
posto sulla colonna sino ad arrivare all’ultima riga. Al che si ripete l’operazione fissando il primo
uno sulla seconda riga e così via.
• Le combinazioni C3 si ottengono fissando la coppia di 1 sulle prime due righe e procedendo come
per C2. Nella colonna # 15 , non ci sono più abbastanza righe per scrivere tutti e tre i numeri 1, e
allora si ricicla alla prima riga (e poi ci si ferma).
• Le combinazioni C4 è l’unica ad avere tutti 1 su tutte le righe e ve ne è una sola.
Utilizzando la procedura descritta è possibile, dati K numeri, creare tutte le combinazioni parziali distinte.
Vasi, tubi e palline...
Il nostro secondo giochetto è il seguente. Supponiamo di avere un’anfora nella quale sono contenute un
certo numero di palline. L’anfora, nella parte inferiore, è collegata a un certo numero di tubi con portate
differenti. Per “portata” s’intende il numero di palline che possono passare alla volta nel tubo; in
particolare, se un tubo ha portata = 4 si deve intendere che solo e soltanto quattro palline alla volta
possono passare; non ne possono passare di più (cosa che è intuitiva) ma non ne possono passare neanche
di meno (cosa che è contro-intuitiva).
Figura 41 – Anfora con palline e tubi – condizione iniziale.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 74 di 91
Nel nostro disegno di Figura 41, l’anfora contiene 9 palline e ci sono tre tubi con portate rispettivamente di
2, 1 e 4 palline. Il sistema ha un congegno, azionato da un bottone, che ogni volta che è premuto fa passare
tante palline quante ne possono portare i tubi, in relazione anche al numero di palline presenti nel
contenitore. Vediamo subito un esempio, basandoci sull’anfora di Figura 41.
Ad un primo azionamento del congegno, possono passare 7 palline, di cui 2 nel tubo di portata pari a 2, 1
nel tubo di portata pari a 1 e quattro nel tubo di portata pari a 4. Rimangono nell’anfora 3 palline, come
visualizzato in Figura 42.
Figura 42 – Anfora con palline e tubi – dopo il primo azionamento.
Al secondo azionamento, abbiamo due possibilità:
1. Le due palline passano entrambi nel tubo con portata 2. Rimangono nell’anfora zero palline
2. Una sola pallina passa nel tubo con portata uno. Rimane una pallina.
Se occorre (1), non c’è possibilità di proseguire, poiché tutte le palline sono terminate. Se accade (2), si
potrà fare scattare ancora una volta il meccanismo per fare cadere la pallina rimanente dal tubo di portata
1, dopodiché si ferma tutto.
La domanda generale, adesso che si è capito il meccanismo del gioco, è la seguente: data un’anfora con un
certo numero di palline e di tubi di varie portate, quante sono le possibili combinazioni di palline che
possono cadere in un azionamento, saturando il maggior numero di tubi possibile?
Abbiamo visto nell’esempio che, se il numero delle palline nell’anfora è maggiore o uguale alla somma delle
portate dei tubi, in un azionamento cadono un numero di palline pari alla somma delle portate dei tubi
(primo azionamento del nostro esempio). Se il numero delle palline nell’anfora è strettamente minore della
somma delle portate dei tubi, occorre considerare non solo le singole portate dei singoli tubi, ma anche
tutte le possibili combinazioni delle portate dei tubi presi a due a due, a tre a tre, etc. In questo caso le
combinazioni sono le somme delle portate e, in definitiva, ci ritroviamo a che fare con le combinazioni
distinte di K numeri, dove i numeri – in questo caso - rappresentano le portate dei tubi.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 75 di 91
Se la differenza tra il numero di palline nell’anfora e queste portate combinate è un numero di palline tale
da non poter ulteriormente fluire attraverso i tubi rimanenti, allora abbiamo trovato la combinazione
voluta.
Meglio, come al solito, chiarire le cose con un esempio. Consideriamo la nostra solita anfora con sei palline.
Sei è minore della somma della portata dei tubi, che è pari a sette.
Figura 43 – Anfora con sei palline.
Le combinazioni distinte di {1,2,4} sono : {1,2,4,(1,2),(1,4),(2,4),(1,2,4)}. Consideriamo la seguente tabella:
Tubi utilizzati 1 2 4 (1,2) (1,4) (2,4) (1,2,4)
Palline rimaste 6-1=5 6-2=4 6-4=2 6-(1+2)=3 6-(1+4)=1 6-(2+4)=0 6-(1+2+4)=-1
1 X V V X X
2 V X V X X 4 V V X V X X
Tabella 45 – Tabella delle combinazioni
La tabella va letta come segue.
Consideriamo la colonna in cui “Tubi utilizzati” = 1. Se utilizziamo solo un tubo, ci rimangono 5 palline. Ma
le cinque palline possono ancora essere in parte “assorbite” dal tubo da 4 oppure in parte assorbite dal
tubo da 2. Mettiamo una X sulla riga del tubo 1 (per dire che è il tubo occupato) ed una V vicino al tubo da 2
e al tubo da 4 (per dire che almeno uno dei due potrebbe essere utilizzato). Quindi la combinazione con il
solo tubo da 1 non massimizza la saturazione dei tubi.
Per la colonna in cui “Tubi utilizzati” = (1,4), utilizziamo sia il tubo con portata 1 che quello con portata 4 e
portiamo via in totale 5 palline. La pallina rimanente non può scorrere nel tubo rimasto libero (che per
potersi attivare devono essere presenti almeno due palline). Quindi, la combinazione satura il maggior
numero possibile di tubi. Lo stesso dicasi con la combinazione (2,4).
La combinazione (1,2,4) è da escludere perché per essere attivata, ha bisogno di almeno 7 palline. Ma
abbiamo già visto che se il numero delle palline nell’anfora è maggiore o uguale alla somma delle portate,
tutti i tubi sono saturati ed in un azionamento vengono portate via un numero di palline uguali alla somma
delle portate dei tubi.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 76 di 91
Quindi, a livello pratico, le colonne della Tabella 45 nelle quali compaiono solo le X sono le combinazioni
che saturano il maggior numero di tubi e sono la soluzione al problema generale che ci eravamo posti. La
regola può essere espressa così:
1 - “Se il numero di palline nell’anfora è maggiore o uguale alla somma della portata dei tubi, tutti i tubi
sono saturati ed il numero di palline nell’anfora dopo una attivazione è pari alla differenza tra il numero di
palline presenti inizialmente nell’anfora e la somma della portata dei tubi”.
2 - “Se il numero di palline nell’anfora è strettamente minore della somma della portata dei tubi, date tutte
le possibili combinazioni distinte delle portate dei tubi, le combinazioni per quali il numero di palline rimaste
nell’anfora è strettamente minore del valore della portata di tutte le altre combinazioni sono quelle che
saturano il maggior numero di tubi possibile”.
Alle regole sopra riportate, ci riferiremo nel seguito con il nome di “regole di saturazione”.
Nel caso particolare in cui un’anfora con P palline abbia un solo tubo di una certa portata Q, si hanno due
casi:
1. Se P≥Q allora passano Q palline e rimangono P-Q palline nell’anfora.
2. Se P<Q allora nessuna pallina passa e rimangono P palline nell’anfora.
Figura 44 – Anfora con un solo tubo.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 77 di 91
Algoritmo di soluzione del problema fondamentale per una rete di Petri
Consideriamo la seguente rete di Petri:
p1 p2 p3 p4 p5
t1 -2 -1 +1
t2 -2 +1
t3 -1 -1 +4 +1 μ0 = {3,2,5,0,0}
Tabella 46 – Rete di Petri per l’esempio #1
Le posizioni p1, p2, p3, p4 e p5 corrispondono alle nostre anfore, nelle quali le palline sono sostituite da
token. I numeri negativi ti,j all’interno della matrice, in corrispondenza dell’intersezione tra la riga della
transizione e il posto corrispondono alla portata dei tubi collegati sul fondo dell’anfora. Il valore μ0,i
corrisponde al numero di token presenti in pi, ossia al numero di palline presenti nell’anfora. In
pratica, la rappresentazione ”anfora equivalente” della nostra matrice R è la seguente:
Figura 45 – Rappresentazione dei posti in termini di “anfore equivalenti”.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 78 di 91
La rappresentazione “anfora equivalente” non tiene conto dei valori positivi di output, ma nemmeno ci
interessa che lo faccia. Descriviamo passo per passo l’algoritmo di calcolo della configurazione.
Passo # 1 – Aggiunta delle combinazioni distinte a ti,j
Consideriamo la seguente tabella:
p1 p2 p3 p4 p5
t1 -2 -1 +1
t2 -2 +1
t3 -1 -1 +4 +1
t1+ t2
t1+ t3 -2
t2+ t3 -3
t1+ t2 + t3
μ0 3 2 5 0 0 Tabella 47 – Tabella di calcolo configurazione – passo # 1a
Abbiamo aggiunto alla colonna delle transizioni (la prima a sinistra) tutte le combinazioni distinte di ti,j
(i=1,2,3 e j=1,2,3,4,5) e abbiamo calcolato la somma ove pertinente farlo. Per p1, avendo un solo valore
negativo (un tubo), non ha senso calcolare le combinazioni t1+ t2, t1+ t3, …, t1+ t2+t3. Per p2, che ha due
valori negativi (due tubi) in corrispondenza delle transizioni t1 e t3 ha senso calcolare solo t1+ t3 (in
giallo); non ha senso calcolare t1+ t2+ t3 perché non c’è nessun numero negativo all’incrocio tra t2 e
p2 (in altri termini, p2 non è un input di t2 ovvero il “tubo” t2 non c’è). Stesso ragionamento per p3.
Per p4 e p5 non abbiamo valori negativi, quindi non c’è nulla da calcolare.
A ben vedere potevamo anche non scrivere le righe corrispondenti a t1+ t2 e a t1+ t2+ t3, poiché non
abbiamo dei valori. Eliminiamo tali righe, ottenendo la tabella semplificata che segue.
p1 p2 p3 p4 p5
t1 -2 -1 +1
t2 -2 +1
t3 -1 -1 +4 +1
t1+ t3 -2
t2+ t3 -3
μ0 3 2 5 0 0 Tabella 48 – Tabella di calcolo configurazione – passo # 1b
Passo # 2 – Riduzione dei valori nelle colonne con più valori negativi
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 79 di 91
Consideriamo per ora solo le colonne con più di un valore negativo (con almeno due, o più valori negativi)
ed applichiamo le regole di saturazione descritte nel paragrafo Vasi, tubi e palline... Visto che le uniche due
colonne con più di un valore sono quelle corrispondenti alle posizioni p2 e p3, abbiamo:
Posizione p2: Configurazione iniziale μ0,2=2
Transizioni t1(-1) t3(-1) t1+ t3(-2)
Configurazione finale 2-1=1 2-1=1 2-2=0
t1(-1) X X X
t3(-1) V V X
In p2 vi sono 2 token; la transizione t1 ne porta via uno e la t2 ne porta via un altro. Siano nel caso in cui μ0,2
=t1,2+t3,2e, dalla tabella sopra, si vede che l’unica colonna con sole X è corrispondente a t1+ t3.
Posizione p3: Configurazione iniziale μ0,3=5
Transizioni t2(-2) t3(-1) t2+ t3(-3)
Configurazione finale 5-2=3 5-1=4 5-3=2
t2(-2) X V X
t3(-1) V X X
In p3 vi sono 5 token; la transizione t2 ne porta via due e la t3 ne porta via un altro. Siano nel caso in cui
μ0,3≥t2,3+t3,3e, dalla tabella sopra, si vede che l’unica colonna con sole X è corrispondente a
t2+t3.
In entrambi i casi abbiamo trovato una sola combinazione possibile: (t1+t3) per p2 e (t2+t3) per p3. Tale
combinazione è l’unica di cui dobbiamo tenere conto, e possiamo riscrivere la Tabella 48 come segue:
p1 p2 p3 p4 p5
t1 -2 -1 +1
t2 -2 +1
t3 -1 -1 +4 +1
t1+ t3 -2
t2+ t3 -3
μ0 3 2 5 0 0 Tabella 49 – Tabella di calcolo configurazione – passo # 2
Abbiamo segnato in colore verde i solo valori che devono essere considerati, nei passi successivi, nelle
colonne p2 e p3.
Passo # 3 – Calcolo della configurazione finale.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 80 di 91
Nella Tabella 49 abbiamo, in ogni colonna, un solo valore negativo (consideriamo solo i valori nelle celle
verdi, per le colonne con più di un valore, ossia p2 e p3). Possiamo a questo sommare algebricamente i
valori in colonna, quelli nelle righe delle transizioni con quelli nella riga della configurazione μ0 ed
ottenere la nuova configurazione μ1=(1,0,3,5,1).
p1 p2 p3 p4 p5
t1 -2 -1 +1
t2 -2 +1
t3 -1 -1 +4 +1
t1+ t3 -2
t2+ t3 -3
μ0 3 2 5 0 0
μ1 3-2=1 2-2=0 5-3+1=3 0+1+4=5 0+1=1 Tabella 50 – Tabella di calcolo configurazione – passo # 3
Notiamo che tutti i valori ottenuti sono positivi (o al più nulli) e sono quindi accettabili. Non sarebbe infatti
accettabile avere una configurazione con un numero “negativo” di token. Vedremo nei successivi esempi
come bisogna procedere nel caso in cui si ottengano dei valori negativi.
Calcolo delle successive configurazioni.
Configurazione μμμμ2222
Consideriamo ora la stessa rete di Petri nella configurazione μ1=(1,0,3,5,1) e calcoliamo la successiva
configurazione μ2.La matrice di configurazione è la seguente:
p1 p2 p3 p4 p5
t1 -2 -1 +1
t2 -2 +1
t3 -1 -1 +4 +1
t1+ t3 -2
t2+ t3 -3
μ1 1 0 3 5 1
Tabella 51 – Tabella di calcolo configurazione μ2. – passo # 1
Come al solito, le uniche due colonne con più di un valore sono quelle corrispondenti alle posizioni p2 e p3,
abbiamo:
Posizione p2: Configurazione iniziale μ1,2=0
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 81 di 91
Transizioni t1(-1) t3(-1) t1+ t3(-2)
Configurazione finale 0-1=-1 0-1=-1 0-2=-2
t1(-1) / / /
t3(-1) / / /
In p2 vi sono 0 token; la transizione t1 e la t2 non ne possono portare via nessuno e la differenza è un
valore negativo.
Posizione p3: Configurazione iniziale μ1,3=3
Transizioni t2(-2) t3(-1) t2+ t3(-3)
Configurazione finale 3-2=1 3-1=2 3-3=0
t2(-2) X V X
t3(-1) V X X
In p3 vi sono 3 token; la transizione t2 ne porta via due e la t3 ne porta via un altro. Siano nel caso in cui
μ0,3=t2,3+t3,3e, dalla tabella sopra, si vede che l’unica colonna con sole X è quella corrispondente
a t2+t3.
Per p2 non esistono quindi combinazioni valide e visto che le transizioni t1 e t3 non possono lavorare,
vuol dire che sono congelate; contrassegniamo la casella relativa nella tabella con colore rosso. La matrice
in Tabella 51 diventa:
p1 p2 p3 p4 p5
t1 -2 -1 +1
t2 -2 +1
t3 -1 -1 +4 +1
t1+ t3 -2
t2+ t3 -3
μ1 1 0 3 5 1
μ2 1-2=-1 0 3-3+1=0 5+1+4=10 1+1=2
Tabella 52 – Tabella di calcolo configurazione μ2. – passo # 2a
Il colore rosso in una cella vuol dire che le non sono soddisfatte le condizioni affinché la corrispondente
transizione possa scattare. Se la transizione non può scattare, vuol anche dire che non può produrre output
ed il rosso della singola cella va quindi estesa a tutta la riga corrispondente. In pratica, la Tabella 52 si deve
riscrivere come segue:
p1 p2 p3 p4 p5
t1 -2 -1 +1
t2 -2 +1
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 82 di 91
t3 -1 -1 +4 +1
t1+ t3 -2
t2+ t3 -3
μ1 1 0 3 5 1
μ2 1 0 3-3+1=0 5+1+4=10 1+1=2
Tabella 53 – Tabella di calcolo configurazione μ2. – passo # 2b
Ora, se la t1 e t3 sono congelate, non hanno senso le combinazioni in cui compaiono le transizioni t1 e t3.
Quindi , le combinazioni t1+t3 e t2+t3 non hanno senso e le possiamo mettere in rosso. Quindi, la cella verde
diventa rossa e nella colonna del p3 rimane solo più il valore -2 della transizione t2.
La tabella diventa, in definitiva:
p1 p2 p3 p4 p5
t1 -2 -1 +1
t2 -2 +1
t3 -1 -1 +4 +1
t1+ t3 -2
t2+ t3 -3
μ1 1 0 3 5 1
μ2 1 0 3-2=1 5+1=6 1
Tabella 54 – Tabella di calcolo configurazione μ2. – passo # 2c
Ci siamo limitati a colorare di rosso la riga solo dove esistono valori, per non appesantire troppo. In pratica,
la transizione t1 e t3 sono congelate. L’unica ancora “viva” è la transizione t2.
Facciamo a questo punto la somma algebrica dei valori in colonna, quelli nelle righe delle transizioni con
quelli nella riga della configurazione μ1,senza considerare i valori nelle celle rosse.Si ottiene la nuova
configurazione μ2=(1,0,1,6,1).
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 83 di 91
Configurazione μμμμ3333
Consideriamo ora la stessa rete di Petri nella configurazione μ2=(1,0,1,6,1) e calcoliamo la successiva
configurazione μ3.La matrice di configurazione è la seguente:
p1 p2 p3 p4 p5
t1 -2 -1 +1
t2 -2 +1
t3 -1 -1 +4 +1
t1+ t3 -2
t2+ t3 -3
μ2 1 0 1 6 1
Tabella 55 – Tabella di calcolo configurazione μ3. – passo # 1
Le uniche due colonne con più di un valore sono quelle corrispondenti alle posizioni p2 e p3, abbiamo:
Posizione p2: Configurazione iniziale μ2,2=0
Transizioni t1(-1) t3(-1) t1+ t3(-2)
Configurazione finale 0-1=-1 0-1=-1 0-2=-2
t1(-1) / / /
t3(-1) / / /
In p2 vi sono 0 token; la transizione t1 e la t2 non ne possono portare via nessuno e la differenza è un
valore negativo. Esattamente come visto prima
Posizione p3: Configurazione iniziale μ2,3=1
Transizioni t2(-2) t3(-1) t2+ t3(-3)
Configurazione finale 1-2=-1 1-1=0 1-3=-2
t2(-2) / /
t3(-1) / X /
In p3 vi è un token; la transizione t2 ne può porta via come minimo due e la t3 ne porta via solo uno. Dalla
tabella sopra, si vede che l’unica colonna con sole X è quella corrispondente a t3. Le altre hanno
valori negativi e quindi corrispondono a celle rosse.
La matrice diventa:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 84 di 91
p1 p2 p3 p4 p5
t1 -2 -1 +1
t2 -2 +1
t3 -1 -1 +4 +1
t1+ t3 -2
t2+ t3 -3
μ2 1 0 1 6 1
μ3 1 0 1 6 1
Tabella 56 – Tabella di calcolo configurazione μ3. – passo # 2
Notiamo che, anche se nella riduzione della colonna p3 abbiamo visto che la transizione t3 poteva essere
attiva; essendo pero t3 congelata dall’equivalente calcolo per p2, in definitiva è congelata. Avendo tutta la
tabella “rossa” la configurazione μ3 = μ2, ossia la μ2 è una configurazione statica e terminiamo il
calcolo delle successive configurazioni della rete di Petri.
Un esempio più complesso
Consideriamo la seguente rete di Petri in forma matriciale:
p1 p2
t1 -2 +1
t2 -3 +1
t3 -1 +2
t1+ t2 -5
t1+ t3 -3
t2+ t3 -4
t1+t2+ t3 -6
μ0 1 0 Tabella 57 – Tabella di calcolo configurazione – un altro esempio – passo #1
Il posto p2 è di input per tutte e tre le transizione e p2 è un output per tutte e tre le transizioni con
molteplicità diverse. Applicando la regola di saturazione a p1, che ha più valori negativi, otteniamo:
Transizioni t1(-2) t2(-3) t3(-1) t1+ t2(-5) t1+ t3(-3) t2+ t3(-4) t1+t2+ t3(-6) Configurazione finale 1-2=-1 1-3=-2 1-1=0 1-5=-4 1-3=-2 1-4=-3 1-6=-5
t1(-2) / / / / / /
t2(-3) / / / / / /
t3(-1) / / X / / / /
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 85 di 91
Come al solito, i valori negativi della configurazione finale sono esclusi. L’unica transizione attiva è la t3
dove abbiamo solamente X (una in questo caso). Le transizioni t1 e t2 sono disabilitate e la Tabella 57
diventa:
p1 p2
t1 -2 +1
t2 -3 +1
t3 -1 +2
t1+ t2 -5
t1+ t3 -3
t2+ t3 -4
t1+t2+ t3 -6
μ0 1 0 Tabella 58 – Tabella di calcolo configurazione – un altro esempio – passo #2
A questo punto, la somma algebrica sulle colonne fornisce come al solito la configurazione finale:
p1 p2
t1 -2 +1
t2 -3 +1
t3 -1 +2
t1+ t2 -5
t1+ t3 -3
t2+ t3 -4
t1+t2+ t3 -6
μ0 1 0
Μ1 1-1= 0+2=2 Tabella 59 – Tabella di calcolo configurazione– un altro esempio – configurazione finale
La configurazione finale μ1=(0,2), che è anche – come è facile verificare visto lo zero al primo
elemento della configurazione, una configurazione statica.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 86 di 91
Altro esempio: numero token maggiore della somma delle molteplicità del posto.
Consideriamo la stessa rete di Petri in forma matriciale, ma con diversa configurazione iniziale:
p1 p2
t1 -2 +1
t2 -3 +1
t3 -1 +2
t1+ t2 -5
t1+ t3 -3
t2+ t3 -4
t1+t2+ t3 -6
μ0 10 0 Tabella 60 – Tabella di calcolo configurazione – token>somma molteplicità – passo #1
Il posto p2 è di input per tutte e tre le transizione e p2 è un output per tutte e tre le transizioni con
molteplicità diverse. Applicando la regola di saturazione a p1, che ha più valori negativi, otteniamo:
Transizioni t1(-2) t2(-3) t3(-1) t1+ t2(-5) t1+ t3(-3) t2+ t3(-4) t1+t2+ t3(-6) Configurazione finale 10-2=8 10-3=7 10-1=9 10-5=5 10-3=7 10-4=6 10-6=4
t1(-2) X V V X X V X
t2(-3) V X V X V X X
t3(-1) V V X V X X X
Dalla tabella si può vedere come l’unica colonna in cui compaiono solo X sia quella relativa a t1+t2+ t3;
tutte le transizioni sono quindi coinvolte e il calcolo della successiva configurazione diventa a
questo punto banale:
p1 p2
t1 -2 +1
t2 -3 +1
t3 -1 +2
t1+ t2 -5
t1+ t3 -3
t2+ t3 -4
t1+t2+ t3 -6
μ0 10 0
μ1 10-6=4 0+1+1+2=4 Tabella 61 – Tabella di calcolo configurazione – token>somma molteplicità – passo #2
La nuova configurazione è quindi μ1= (4,4). Ritroviamo esattamente quello che potevamo immediatamente
dedurre sapendo che quando il numero di token è maggiore o uguale alla somma delle molteplicità del
posto, il numero di token rimanenti è pari alla differenza tra i token presenti e la somma delle portate.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 87 di 91
Ultimo esempio: più configurazioni finali
Consideriamo la stessa rete di Petri in forma matriciale, ma con diversa configurazione iniziale μ0=(3,0):
p1 p2
t1 -2 +1
t2 -3 +1
t3 -1 +2
t1+ t2 -5
t1+ t3 -3
t2+ t3 -4
t1+t2+ t3 -6
μ0 3 0 Tabella 62 – Tabella di calcolo configurazione – più configurazioni finali – passo #1
Applicando la regola di saturazione a p1, che ha più valori negativi, otteniamo:
Transizioni t1(-2) t2(-3) t3(-1) t1+ t2(-5) t1+ t3(-3) t2+ t3(-4) t1+t2+ t3(-6) Configurazione finale 3-2=1 3-3=0 3-1=2 3-5=-2 3-3=0 3-4=-1 3-6=-3
t1(-2) X V / X / /
t2(-3) X / / /
t3(-1) V X / X / /
In questo caso abbiamo due colonne in cui compaiono solo X: quella relativa alla transizione t2 e quella
relativa alla transizione t1+t3. In questo caso la rete è indecidibile, poiché non si può dire a priori dove i
token passino, se da t2 oppure da t1+t3. In questo caso particolare, il numero finale di token in p2 è uguale,
poiché – da qualunque strada passino – sempre tre token sono sottratti da p2. Ci possono però essere dei
casi in cui il numero dei token rimanenti è differente. E’ ovvio a questo punto poi che, se la t2 è abilitata,
siano disabilitate la t1 e t3 e viceversa.
Se supponiamo abilitata t2 abbiamo:
p1 p2
t1 -2 +1
t2 -3 +1
t3 -1 +2
t1+ t2 -5
t1+ t3 -3
t2+ t3 -4
t1+t2+ t3 -6
μ0 3 0
μ1 3-3=0 0+1=1 Tabella 63 – Tabella di calcolo configurazione – più configurazioni finali – passo #2a
Se supponiamo abilitate la t1 e t3, abbiamo:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 88 di 91
p1 p2
t1 -2 +1
t2 -3 +1
t3 -1 +2
t1+ t2 -5
t1+ t3 -3
t2+ t3 -4
t1+t2+ t3 -6
μ0 3 0
μ1 3-3=0 0+1+2=3 Tabella 64 – Tabella di calcolo configurazione – più configurazioni finali – passo #2b
Vediamo quindi che – a secondo di quale transizione/i scatta prima – la configurazione finale è differente.
Se scatta prima la t2 abbiamo μ1=(0,1) mentre se scattano prima la t1 e t3 otteniamo μ1=(0,3).
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 89 di 91
Reti di Petri binarie
Consideriamo la seguente reti di Petri:
Figura 46 – Rete di Petri binaria.
supponiamo che:
1. I posti possano contenere zero oppure uno token
2. Tutti gli archi abbiano peso pari ad uno; ovvero, la molteplicità dei posti sia uno
Una rete siffatta la chiamiamo rete di Petri binaria, ed il motivo del nome dovrebbe essere ovvio. Se i posti
possono contenere 0 o1 token, allora tutte le possibili combinazioni della rete sono ottenute considerando
tutte le possibili combinazioni dei posti componenti la rete, contenenti zero o uno. Se la rete ha N posti, è
immediato calcolare che il numero di combinazioni è 2N
Nel nostro esempio, essendo N=3 abbiamo 8 combinazioni possibili, che scriviamo nella tabella che segue.
Posti
p1 1 1 0 0 1 1 0 0
p2 1 0 1 0 1 0 1 0 p3 1 1 1 1 0 0 0 0
Tabella 65 – Tabella delle combinazioni per rete di Petri binaria
Quelle riportate in Tabella 65 sono tutte le possibili configurazioni della rete. In qualsiasi modo possano
operare le transizioni, al partire da una data configurazione dovrò ottenere una nuova configurazione
(eventualmente identica a quella di partenza) che sicuramente compare tra quelle riportate in Tabella 65.
Le regole per generare le configurazioni sono quelle che abbiamo ampiamente visto nei paragrafi
precedenti, con alcune precisazioni:
1. Se il posto possiede un token, aggiungendo un token ci troviamo sempre con un token: (1+1=1).
2. Se il posto possiede zero token, aggiungendo un token ci troviamo con un token: (0+1=1).
3. Una transazione scatta se tutti i suoi posti di input possiedono un token. I token nelle postazioni di
input sono rimossi e sono aggiunti un token per ogni postazione di output.
4. Nel caso in cui uno stesso posto è di input a due o più transizioni e contiene un token, questo fa
scattare sempre tutte le transizioni (regola di risoluzione delle incertezze)
Consideriamo ora la seguente tabella:
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 90 di 91
# colonna 1 2 3 4 5 6 7 8
Configurazione
iniziale (n)
p1 1 1 0 0 1 1 0 0
p2 1 0 1 0 1 0 1 0 p3 1 1 1 1 0 0 0 0
Configurazione
finale (n+1)
p1 0 1 0 0 0 1 0 0
p2 0 0 0 0 0 0 0 0
p3 1 1 1 1 1 0 1 0
Tabella 66 – Tabella decisionale per rete di Petri binaria
Quest’ultima tabella definisce, dato uno stato μk della rete (configurazione iniziale) quello che è lo stato
successivo μk+1 della stessa. Il lettore può controllare che sono state applicate le regole 1 → 4. In
particolare, facciamo notare che nel caso in cui p1=1 e p2=1 , essendo p2 di input sia a t1 che a t2, entrambe
sono scattate ed hanno portato ciascuna un token in p3. Visto però che per la regola (1) abbiamo 1+1=1, in
p3 ci ritroviamo con un token.
La Tabella 66 può essere vista come una tabella decisionale, del tipo quelle che rappresentano una
macchina agli stati finiti, in cui abbiamo però tre stati (corrispondenti ai posti p1, p2 e p3). Possiamo quindi
semplificarla utilizzando Logic Friday. Non eseguiamo tutti i passaggi (che il lettore potrà fare da se) e
forniamo il risultato minimizzato.
p1(n+1) = p1(n)p2’(n)
p2(n+1) = 0
p3(n+1) = p2(n) + p3(n)
Ricordiamo che la configurazione (n+1) è quella che si ottiene dalla configurazione (n) dopo che le
transizioni sono state azionate (o sono state ferme se non c’erano i token nel posto di input). Ad esempio,
dalla Tabella 66 vediamo che le configurazioni iniziali delle colonne #2, 4, 6 ed 8 sono statiche visto che
sono uguali alle configurazioni finali.
Vediamo come interpretare il risultato:
• p1(n+1) ha un token se p1(n) ha un token AND p2(n) non ha un token. Se difatti p2(n) avesse un
token la transizione t1 e t2 sarebbero attive e porterebbero via i token da p1.
• p2(n+1) non ha mai token, qualunque sia la configurazione iniziale. Se non ha un token allo stato
(n), rimane senza allo stato (n+1) e se ne ha uno allo stato (n), allo stato (n+1) lo perde.
• p3(n+1) ha un token allo stato (n+1) se lo aveva allo stato (n) OR se p2(n) ha un token. Se p3 ha un
token allo stato (n) gli rimane, indipendentemente se ne viene aggiunto uno o no allo stato (n+1) e
se non lo ha, gli viene aggiunto solo se p2 ha un token allo stato (n). Difatti, se p2 ha un token allo
stato (n), allora sia la transizione t1 che t2 portano un token a p3.
Le reti di Petri binarie sono spesso più che sufficienti per modellare processi anche abbastanza complessi o,
per lo meno, permettono di definire le caratteristiche peculiari di tali processi senza entrare nel dettaglio di
configurazioni complicate in cui intervengono più token per posto.
Pur avendo lo svantaggio che occorre considerare tutte le possibili configurazioni, si ha il pregio di ottenere
una serie di equazioni booleane che definiscono lo stato successivo a partire da quello noto iniziale, cosa
che semplifica la comprensione della dinamica della rete e di una sua eventuale implementazione software.
Berta Danilo - http://www.bertadanilo.name/
Tecniche di analisi dei requisiti e modelli software. Pagina 91 di 91
Per finire, ricordiamo che la regola # 4 (regola di soluzione delle incertezze) può anche essere
“abbandonata” e tutto il discorso vale comunque. In quest’ultimo caso, occorrerà definire più scenari, validi
per ciascuna attivazione possibile delle transizioni.
Nota conclusiva
Il presente lavoro è da considerarsi “in itinere”; l’intenzione è di inserire altri argomenti ed esempi, ma non
ho definito alcun piano di lavoro. Per qualunque errore e/o segnalazione di migliorie e/o commenti potete
scrivermi direttamente all’e-mail: [email protected] oppure usare il form dei contatti che trovate
sul mio sito internet http://www.bertadanilo.name .
Quest' opera è distribuita con licenza Creative Commons Attribuzione - Non commerciale 3.0 Italia.