22 luglio 2022
Rispondi prima di leggere la spiegazione. I termini sottolineati offrono un aiuto rapido.
- 1
Dire se VALIDITY è riducibile a
- 2
Se scoprissimo che , sapremmo dire se esistono funzioni one-way?
- 3
Se è riducibile a e è riducibile a , allora è riducibile a
- 4
È falso che ?
- 5
Supponiamo che . Dire se
- 6
Dire se
- 7
Dire se
Programmare una MdT che, data la stringa binaria , effettua la somma binaria tra e e rigetta nel caso di stringhe di lunghezza diversa o di overflow
| # | Stato | Legge₁ | Legge₂ | Nuovo stato | Scrive₁ | Mossa₁ | Scrive₂ | Mossa₂ | Commento | ||
|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 |
Prossima transizione (riga 1): δ(s, ▷, ▷) = (s, ▷, →, ▷, →) · supera l'inizio dei due nastri
La macchina deve sommare i numeri binari dell'input x;y, che devono avere la stessa lunghezza, e il risultato deve stare nello stesso numero di bit: è valido, mentre causa overflow. Con 2 nastri, copia sul secondo nastro e porta entrambe le testine sulle ultime cifre di e . Poi somma da destra verso sinistra scrivendo il risultato sul secondo nastro, e usa per «nessun riporto» e per «riporto 1».
Le testine devono raggiungere insieme ; sul primo nastro e sul secondo. Se le lunghezze sono diverse o resta un riporto, rifiuta; altrimenti termina in con la somma sul secondo nastro.
Con cifre e riporto , scrivi e porta 1 se . Per esempio : scrivi 0 e porta 1.
| Stato | letto₁ | letto₂ | nuovo stato | scritto₁, mossa₁ | scritto₂, mossa₂ | note |
|---|---|---|---|---|---|---|
| copia | ||||||
| copiato: la testina 2 aspetta qui | ||||||
| scorre | ||||||
| fine di : entrambe sull'ultima cifra | ||||||
| : scrive 0, riporto 1 | ||||||
| : il riporto si esaurisce | ||||||
| : scrive 1, riporto 1 | ||||||
| stessa lunghezza, nessun riporto: è sul 2° nastro | ||||||
| — | — | overflow | ||||
| o | — | — | più lungo | |||
| o | — | — | più lungo |
In tutti gli altri casi (per esempio se manca ";" o compare un simbolo diverso da 0 e 1) rigetta. La macchina è verificata con un simulatore su tutte le coppie fino a 5 bit ciascuno.
Traccia passo passo su 01;10 (1 + 2 = 3)
stato nastro 1 (x;y) nastro 2
s [▷] 0 1 ; 1 0 [▷]
s ▷ [0] 1 ; 1 0 ▷ [⊔] copio x
s ▷ 0 [1] ; 1 0 ▷ 0 [⊔] copio x
s ▷ 0 1 [;] 1 0 ▷ 0 1 [⊔] fine di x
m ▷ 0 1 ; [1] 0 ▷ 0 1 [⊔] scorro y, la testina 2 aspetta
m ▷ 0 1 ; 1 [0] ▷ 0 1 [⊔]
m ▷ 0 1 ; 1 0 [⊔] ▷ 0 1 [⊔] fine di y
c0 ▷ 0 1 ; 1 [0] ▷ 0 [1] ⊔ 0 + 1 = 1: scrivo 1
c0 ▷ 0 1 ; [1] 0 ▷ [0] 1 ⊔ 1 + 0 = 1: scrivo 1
c0 ▷ 0 1 [;] 1 0 [▷] 1 1 ⊔ arrivano insieme, nessun riporto
h sul nastro 2 resta 11
Traccia con overflow su 11;01 (3 + 1 = 4, che non sta in 2 cifre)
stato nastro 1 (x;y) nastro 2
... (copia di x e scorrimento di y come sopra)
c0 ▷ 1 1 ; 0 [1] ▷ 1 [1] ⊔ 1 + 1 = 10: scrivo 0, riporto 1
c1 ▷ 1 1 ; [0] 1 ▷ [1] 0 ⊔ 0 + 1 + 1 = 10: scrivo 0, riporto 1
c1 ▷ 1 1 [;] 0 1 [▷] 0 0 ⊔ arrivano insieme, ma con riporto
no overflow
La tabella nel file della soluzione non funziona
Ha tre errori. La prima riga, , porta subito nello stato del riporto invece di restare in , quindi la macchina rigetta tutto. Con il riporto, dovrebbe togliere il riporto (tornare allo stato senza riporto) e dovrebbe scrivere 1, non 0. Alla fine la testina 1 legge ";" e non , quindi le righe finali con non scattano mai. Inoltre una macchina che calcola una funzione termina in , non in yes.
Eseguila passo per passo
Prossima transizione: δ(s, ▷, ▷) = (s, ▷, →, ▷, →)
Mostra il codice della soluzione
s ▷ ▷ -> s ▷ R ▷ R s b ⊔ -> s b R b R # copia x s ; ⊔ -> m ; R ⊔ S # x copiato: la testina 2 aspetta qui m b ⊔ -> m b R ⊔ S # scorre y m ⊔ ⊔ -> c0 ⊔ L ⊔ L # fine di y: entrambe sull'ultima cifra c0 0 0 -> c0 0 L 0 L # 0 + 0 = 0 c0 0 1 -> c0 0 L 1 L # 0 + 1 = 1 c0 1 0 -> c0 1 L 1 L # 1 + 0 = 1 c0 1 1 -> c1 1 L 0 L # 1 + 1 = 10: scrive 0, riporto 1 c1 0 0 -> c0 0 L 1 L # 0 + 0 + 1 = 1: il riporto si esaurisce c1 0 1 -> c1 0 L 0 L # 0 + 1 + 1 = 10 c1 1 0 -> c1 1 L 0 L # 1 + 0 + 1 = 10 c1 1 1 -> c1 1 L 1 L # 1 + 1 + 1 = 11: scrive 1, riporto 1 c0 ; ▷ -> h ; S ▷ R # stessa lunghezza, nessun riporto: x + y è sul 2° nastro c1 ; ▷ -> no ; S ▷ S # overflow c0 ; b -> no ; S b S # x più lungo c1 ; b -> no ; S b S c0 b ▷ -> no b S ▷ S # y più lungo c1 b ▷ -> no b S ▷ S