SPECIFICA LOOSE DELLE MAPPE FINITE v. 1.1

1. SPECIFICA LOOSE DELLE MAPPE FINITE v. 1.1 Gianna Reggio reggio@disi.unige.it

2. Applicazione/esempio grande • Madre di tutti gli esercizi/esempi • la più usata specifica nelle applicazioni vere • dare la specifica della struttura dati mappe finite, per semplicità da stringhe di caratteri in naturali • si richiedono operazioni per rappresentare tutti i dati (caratteri, stringhe, naturali, mappe) costruttori • operazioni sulle mappe: • mappa vuota (nessuna associazione) • aggiungere/eliminare/modificare una associazione • trovare il numero associato ad una stringa • dominio/codominio di una mappa • controllare se una mappa è vuota/è iniettiva

3. Come procedere • scomporre modularmente il compito in • specificare i naturali • specificare le stringhe di caratteri • specificare la mappe basiche (cioè solo i costruttori e l’operazione per ritrovare il numero associato ad una stringa) “operazioni necessarie per costruire i termini per rappresentare tutti i valori di interesse” • specificare una ad una le ulteriori operazioni e predicati

4. Linguaggio di specifica • Utilizzeremo un semplicissimo linguaggio di specifica per presentare le varie specifiche • Esercizio 24.5: individuare I vari costrutti di tale linguaggio, mano a mano che li utilizzeremo, precisandone sintassi e semantica.

5. Naturali spec NAT = Sorts nat Opns 0: nat succ: nat -> nat Axioms Def(0) Def(succ(x)) • Consideriamo solo i modelli term-generated di NAT spec NATg = generated { NAT } • Esercizio 25: aggiungere a NAT le 5 operazioni (somma, sottrazione, moltiplicazione, divisione intera e resto della divisione intera). • Esercizio 26: aggiungere il predicato ≤.

6. Aggiunta di < spec NAT1 = extend NAT Preds _<_: nat x nat Axioms x < succ(x) x < y  x < succ(y) • Esercizio 27: • 0 < succ(x) è valida in Mod(NAT1) ? • 0 < succ(x) è valida in generated { NAT1 } ?

7. Stringhe di caratteri spec STRING = Sorts char, string Opns L: string -- stringa vuota _::_: char x string -> string -- aggiunta elemento in testa ’A’, … ,’Z’: char -- le 26 lettere -- permettono di rappresentare tutte le stringhe Axioms -- tutte le operazioni sono totali Def(L) Def(c::s) Def(’A’) … Def(’Z’)

8. Esercizi • Esercizio 28:Si consideri spec STRING1 = extend STRING Axioms c = ‘A’  …  ‘Z’ s = L ( c:char.  s’:string. s = c:s’) è vero che i modelli di STRING1 e quelli di generated {STRING} sono gli stessi ? • Soluzione. No, infatti l’algebra DOPPIA definita come segue charDOPPIA = { A, …., Z } stringDOPPIA = { *, + } ‘A’DOPPIA = A ... ‘B’DOPPIA = B LDOPPIA = * _::_DOPPIA(c,s) = s è un modello di STRING1 ma non è term-generated. Verificare per esercizio quanto affermato sopra.

9. Esercizi • Esercizio 29:Ogni modello di generated {STRING} rappresenta ottimamente la struttura dati delle stringhe ? • Soluzione. No, infatti un’algebra banale (cioè dove ogni carrier contiene esattamente un singolo elemento, e dove le operazioni sono totali e definite nel modo ovvio) è un modello di tale specifica, e non rappresenta per niente le stringhe.

10. Stringhe di caratteri 2 spec STRING2 = extend STRING Axioms ‘A’≠‘B’ … ‘A’≠‘Z’ … ‘W’≠‘Z’ L≠ c:s c1≠c2 s1≠s2 c1:s1 ≠ c2:s2 • Esercizio 30:Ogni modello di generated {STRING2} rappresenta ottimamente la struttura dati delle stringhe ?

11. Mappe basiche (1) spec MAP = extend NAT, STRING2 Sorts map Opns []: map -- mappa che non contiene alcuna associazione _[_/_]: map x nat x string -> map -- aggiunta associazione o modifica associazione _[_]: map x string -> nat -- ritorna il naturale associato ad una stringa -- se esiste Axioms -- [] e _[_/_] sono totali Def([]) Def(m[n/s]) [] ≠ m[n/s] (m1 ≠ m2 n1 ≠ n2 s1 ≠ s2)  m1[n1/s1] ≠ m2[n2/s2] è accettabile ??? NO! Nelle mappe non conta l’ordine tra le associazioni, una nuova associazione può rimpiazzare una vecchia

12. Mappe basiche (2) • è possibile dare assiomi che richiedano tutte le possibili identificazioni sugli elementi rappresentati da [] e _[_/_] • Esercizio 31:Dare tali assiomi. • oppure è possibile definire prima l’operazione _[_] e poi richiedere che due mappe sono uguali ses associano gli stessi naturali alle stesse stringhe

13. Mappe basiche (3) -- continuazione degli assiomi di MAP -- definizione di _[_] Def([][s]) m[n/s][s] = n s ≠ s’  m[n/s][s’] = m[s’] -- identificazioni sulle mappe ( s:string . m[s] = m’[s])  m = m’

14. Predicati sulle mappe spec MAP2 = generated{ extend MAP Preds isEmpty: map injective: map pv: map -- i pari sono associati a stringhe che iniziano con --una vocale boh: map Axioms isEmpty([]) ( s: string. Def(m[s]))   isEmpty(m) injective(m)   $ s1,s2: string. (s1 ≠ s2  m[s1] = m[s2]) boh(m)  (($ s:string . m[s] > 0)  ($ s:string . m[s] = 0) ) } • Esercizio 30,2:Dare gli assiomi che definiscono pv. • Esercizio 30,21:Dare degli assiomi che definiscono pv. • Esercizio 30,22:Che cosa definisce il predicato boh ?

15. Insiemi di naturali spec SET-NAT = extend NAT Sorts set-nat Opns -- costruttori {}: set-nat {_}: nat -> set-nat -- singleton __: set-nat x set-nat -> set-nat card: set-nat -> nat Preds isIn: nat x set-nat Axioms -- tutte le operazioni sono totali -- U è comm, assoc, idempotente e {} è la sua identità -- costruttori -- due insiemi sono uguali ses hanno gli stessi elementi -- la cardinalità di un insieme è il numero dei suoi -- elementi • Esercizio 30,3:Dare tutti gli assiomi suggeriti dai commenti riportati sopra.

16. Mappe con dominio e codominio spec MAP3 = generated{ extend MAP2, SET-NAT, SET-STRING Opns dom: map -> set-string cod: map -> set-nat Axioms dom([]) = {} dom(m[n/s]) = dom(m) U {s} -- codominio } • Esercizio 30,4:Completare tale specifica.

17. Naturali con tecnica iniziale spec NAT = init{ Sorts nat Opns 0: nat succ: nat -> nat Axioms Def(0) Def(succ(x)) }