Come mappare i nastri di una Turing Machine “k-tape” nel singolo nastro di una Turing Machine “1-tape”

Sto leggendo Sipser e trovo difficile capire quale sia il processo in modo tale che se mi dai k macchine Turing con k nastri, posso sputare una macchina Turing equivalente con un solo nastro. Un esempio sarebbe carino. In realtà, un esempio elaborato che mostra come passare da TM che ha nastri a uno che ha 1 nastro è quello che sto davvero cercando. Finora non sono riuscito a trovarne uno. Inoltre non sto cercando prove. $k$

turing-machines simulation

— user678392
fonte

Cosa intendi con "una macchina equivalente"? Qual è l'input e qual è l'output? (Forse intendevi una macchina di Turing con nastri?)

k

$k$

— Yuval Filmus,

Sì. Un tornio con k nastri.

— user678392

Una risposta spudoratamente copiata da me stesso :

Una Turing Machine multi-nastro è per lo più uguale a una macchina single-tape, tranne per il fatto che abbiamo una funzione di transizione estesa dove è il numero di nastri. Quindi in ogni stato, la funzione di transizione legge il contenuto di ogni nastro, si sposta in un nuovo stato, (forse) scrive qualcosa su ogni nastro e sposta ogni testa - proprio come una normale TM, tranne ora che abbiamo più cose da leggere, scrivere e muoviti. $Q\times\Gamma^{k}\rightarrow Q\times\Gamma^{k}\times\{L,R\}^{k}$ $k$

Come suggerisce la tua domanda, tale macchina può essere simulata da una TM a nastro singolo . Ancora meglio, può essere fatto solo con un rallentamento quadratico (quindi per le classi polinomialmente chiuse, è sufficiente parlare di macchine a nastro singolo).

La prova di ciò è in qualche modo coinvolta e facilmente disponibile con una semplice ricerca sul Web, quindi traccerò semplicemente la mappatura dei tasti su un singolo nastro. $k$

L'idea di base è piuttosto semplice; aggiungiamo semplicemente alcuni nuovi simboli e teniamo traccia di ogni nastro e ci dirigiamo uno dopo l'altro. Ad ogni passo del calcolo possiamo aver visitato solo una quantità finita di qualsiasi nastro, quindi abbiamo solo bisogno di archiviare queste informazioni su ogni nastro. Quindi per ogni aggiungiamo un nuovo simbolo a che indicherà dove si trova la testa (per ogni nastro) in qualsiasi punto del calcolo. Introduciamo anche un carattere separatore in che indicherà l'inizio e la fine dei nastri "virtuali". Dato input $\gamma \in \Gamma$ $\underline{\gamma}$ $\Gamma$ $\#$ $\Gamma$ $\omega = \omega_{1}\ldots\omega_{n}$ (possiamo supporre che anche sulla macchina multi-nastro tutto l'input sia sul primo nastro - dimostrando perché è un buon esercizio) sulla macchina multi-nastro, la nostra macchina a nastro singolo avrà input

\underset{k sections, one per tape}{\underset{⏟}{# \underline{ω_{1}} \dots ω_{n} # \underline{⊔} # \underline{⊔} # \dots # \underline{⊔} #}} ⊔ ⊔ ⊔ ⊔ ⊔ ⊔ \dots

$\underbrace{\#\underline{\omega_{1}}\ldots\omega_{n}\#\underline{\sqcup}\#\underline{\sqcup}\#\ldots\#\underline{\sqcup}\#}_{k \text{ sections, one per tape}}\sqcup\sqcup\sqcup\sqcup\sqcup\sqcup\ldots$

Quindi utilizziamo lo stato della macchina a nastro singolo per codificare lo stato in cui si trova la macchina a nastro multiplo e quali sono le testine. La funzione di transizione della macchina a nastro singolo è una simulazione multistadio della funzione di transizione a nastro multiplo, in cui eseguiamo le diverse azioni del nastro in modo appropriato, spostando il singolo nastro su ciascuna sezione a turno. Le uniche rughe rimaste stanno spostando tutto quando esauriamo lo spazio in una sezione (ma una tale macchina secondaria è un semplice esercizio) - non riduciamo mai le dimensioni di ogni sezione. $k$

Un semplice (si spera) semplice esempio:

Supponiamo di avere una TM a 3 nastri, in cui l'alfabeto di input è solo , l'alfabeto di nastro è e l'input è . Lo stato iniziale del nastro della macchina è simile a: " " indica dove si trova la testina di lettura / scrittura su ogni nastro. $\Sigma=\{0,1\}$ $\Gamma=\{0,1,\sqcup\}$ $\omega=10101$

\begin{array}{lc} Tape 1: & \underset{\land}{1} 0101 ⊔ ⊔ ⊔ \dots \\ Tape 2: & \underset{\land}{⊔} ⊔ ⊔ ⊔ ⊔ ⊔ \dots \\ Tape 3: & \underset{\land}{⊔} ⊔ ⊔ ⊔ ⊔ ⊔ \dots \end{array}

$\begin{array}{lc} \text{Tape 1:} & \underset{\wedge}{1}0101\sqcup\sqcup\sqcup\ldots\\ \text{Tape 2:} & \underset{\wedge}{\sqcup}\sqcup\sqcup\sqcup\sqcup\sqcup\ldots\\ \text{Tape 3:} & \underset{\wedge}{\sqcup}\sqcup\sqcup\sqcup\sqcup\sqcup\ldots\\ \end{array}$

\land

$\wedge$

Per costruire la macchina a nastro singolo combinata, è necessario aggiungere nuovi simboli all'alfabeto del nastro:

Abbiamo bisogno di un simbolo che indichi l'inizio e la fine dei nastri simulati
Per ogni simbolo in abbiamo anche bisogno di una versione che indichi che la testina simulata si trova su quel carattere sul nastro simulato. $\Gamma$

Quindi, per la macchina a nastro singolo, il nostro nuovo alfabeto per nastro è . Lo stato iniziale del nastro è: Notare la differenza tra la testa della macchina (il ) e le teste simulate dei 3 nastri simulati (i caratteri sottolineati). Ovviamente il nastro si estende all'infinito a destra come al solito. Ho anche tradito leggermente spostando la testina sul primo carattere della prima stringa; rigorosamente dovrebbe iniziare sulla cella più a sinistra, ma questo è un banale tecnicismo. $\Gamma' =\{0,1,\sqcup,\underline{0},\underline{1},\underline{\sqcup},\#\}$

# \underset{\land}{\underline{1}} 0101 # \underline{⊔} # \underline{⊔} # ⊔ ⊔ ⊔ \dots

$\#\underset{\wedge}{\underline{1}}0101\#\underline{\sqcup}\#\underline{\sqcup}\#\sqcup\sqcup\sqcup\ldots$

\land

$\wedge$

Quindi abbiamo tre sezioni contrassegnate (tra i segni ), che corrisponderanno ai 3 nastri della macchina originale. $\#$

Ora inventiamo un'azione per la macchina. Diciamo che la macchina originale legge dal primo nastro, se vede un , scrive un sul secondo nastro, se vede uno scrive un sul terzo nastro. Ad ogni lettura o scrittura, la testa si sposta verso destra. $1$ $1$ $0$ $1$

Quindi, dopo il primo "passo" (che forse richiede diversi stati e transizioni nella macchina reale), i nastri dovrebbero avere un sul secondo nastro e la prima e la seconda testina si saranno spostate a destra di un passo: $1$

\begin{array}{lc} Tape 1: & 1 \underset{\land}{0} 101 ⊔ ⊔ ⊔ \dots \\ Tape 2: & 1 \underset{\land}{⊔} ⊔ ⊔ ⊔ ⊔ \dots \\ Tape 3: & \underset{\land}{⊔} ⊔ ⊔ ⊔ ⊔ ⊔ \dots \end{array}

$\begin{array}{lc} \text{Tape 1:} & 1\underset{\wedge}{0}101\sqcup\sqcup\sqcup\ldots\\ \text{Tape 2:} & 1\underset{\wedge}{\sqcup}\sqcup\sqcup\sqcup\sqcup\ldots\\ \text{Tape 3:} & \underset{\wedge}{\sqcup}\sqcup\sqcup\sqcup\sqcup\sqcup\ldots\\ \end{array}$

Al secondo giro, il primo nastro legge uno , quindi invece scriviamo sul terzo nastro: $0$

\begin{array}{lc} Tape 1: & 10 \underset{\land}{1} 01 ⊔ ⊔ ⊔ \dots \\ Tape 2: & 1 \underset{\land}{⊔} ⊔ ⊔ ⊔ ⊔ \dots \\ Tape 3: & 1 \underset{\land}{⊔} ⊔ ⊔ ⊔ ⊔ \dots \end{array}

$\begin{array}{lc} \text{Tape 1:} & 10\underset{\wedge}{1}01\sqcup\sqcup\sqcup\ldots\\ \text{Tape 2:} & 1\underset{\wedge}{\sqcup}\sqcup\sqcup\sqcup\sqcup\ldots\\ \text{Tape 3:} & 1\underset{\wedge}{\sqcup}\sqcup\sqcup\sqcup\sqcup\ldots\\ \end{array}$

La macchina a nastro singolo simula questo spostando la sottolineatura (usando la versione alternativa dei caratteri in e scrivendo sul nastro simulato appropriato. Quindi, dopo il primo passo, il nastro combinato appare come: $\Gamma'$

# 1 \underset{\land}{\underline{0}} 101 # 1 \underline{⊔} # \underline{⊔} # ⊔ ⊔ ⊔ \dots

$\#1\underset{\wedge}{\underline{0}}101\#1\underline{\sqcup}\#\underline{\sqcup}\#\sqcup\sqcup\sqcup\ldots$

Dopo il secondo passo:

# 10 \underset{\land}{\underline{1}} 01 # 1 \underline{⊔} # 1 \underline{⊔} # ⊔ ⊔ ⊔ \dots

$\#10\underset{\wedge}{\underline{1}}01\#1\underline{\sqcup}\#1\underline{\sqcup}\#\sqcup\sqcup\sqcup\ldots$

Ovviamente questa è una visione di alto livello del processo: non ho tentato di spiegare come costruire gli stati o come ogni nastro simulato si allunga (per questo, hai bisogno di una piccola routine che controlli se ti sei imbattuto nel estremità del nastro simulato, quindi sposta tutto a destra di un passo e si stringe in un nuovo spazio vuoto, ovvero aggiunge celle a nastro simulate solo quando sono necessarie).

— Luke Mathieson
fonte

In alternativa, utilizzare " tracce " separate per scrivere i nastri separati uno accanto all'altro nello stesso spazio. Ciò comporta tuttavia l'introduzione di un nuovo alfabeto.

— Hendrik Jan

@ user678392 Passare attraverso la costruzione in dettaglio e scrivere tutto qui richiederebbe almeno un paio d'ore. Se non hai nemmeno intenzione di spiegare anche quale parte non capisci, perché qualcuno dovrebbe mettere così tanto lavoro per tuo conto? E se qualcuno lo facesse? Dirai semplicemente "Non lo capisco. Qualcun altro lo fa"?

— David Richerby,

@ user678392 Grazie. E, solo per chiarire, è l'inglese con cui hai difficoltà (cioè è probabile che la riformulazione ti aiuti) o hai bisogno di maggiori dettagli nella spiegazione?

— David Richerby,

@ user678392, ho aggiunto un esempio della vista di alto livello dei primi passi della conversione e dell'output pratico sui nastri. Ho evitato di discutere su come costruire il nuovo insieme di stati, dato che è molto complesso e non otterrai una spiegazione migliore di ciò che è in Sipser o simile - è intrinsecamente complicato e matematico.

— Luke Mathieson,

@RomaKarageorgievich Sembra che alcune delle prove più chiare siano scomparse negli ultimi 5 anni (non fidarti di Internet: D). Il più chiaro che ho trovato è qui (avviso, file .doc!). La prova di "Introduzione alle lingue e alla teoria della computazione" di Martin è abbastanza buona, se si ha accesso a quel libro (p. 244 nel 4 ° ed.). La prova di "Introduzione alla teoria della computazione" di Sipser è sufficiente (p. 177 nella 3a edizione).

— Luke Mathieson,