L'iterazione può sostituire la ricorsione?

Ho visto tutto lo stack Overflow, ad esempio qui , qui , qui , qui , qui e alcuni altri che non mi interessa menzionare, che "qualsiasi programma che utilizza la ricorsione può essere convertito in un programma usando solo l'iterazione".

C'era anche un thread molto votato con una risposta molto votata che diceva sì, è possibile.

Ora non sto dicendo che si sbagliano. È solo che quella risposta contrasta la mia scarsa conoscenza e comprensione sull'informatica.

Credo che ogni funzione iterativa possa essere espressa come ricorsione, e Wikipedia ha una dichiarazione in tal senso. Tuttavia, dubito che il contrario sia vero. Per uno, dubito che le funzioni ricorsive non primitive possano essere espresse in modo iterativo.

Dubito anche che le iperoperazioni possano essere espresse in modo iterativo.

Nella sua risposta (che non capisco a proposito) alla mia domanda @YuvalFIlmus ha affermato che non è possibile convertire alcuna sequenza di operazioni matematiche in una sequenza di aggiunte.

Se la risposta di YF è davvero corretta (immagino che lo sia, ma il suo ragionamento era al di sopra della mia testa), ciò non significa che non tutte le ricorsioni possono essere convertite in iterazioni? Perché se fosse possibile convertire ogni ricorsione in iterazione, sarei in grado di esprimere tutte le operazioni come una sequenza di aggiunte.

La mia domanda è questa:

Ogni ricorsione può essere convertita in iterazione e perché?

Per favore, dai una risposta a un brillante liceale o capirà un corso di laurea del primo anno. Grazie.

PS Non so che cosa sia ricorsivo primitivo (so della funzione Ackermann, e che non è ricorsivo primitivo, ma è ancora calcolabile. Tutte le mie conoscenze su di esso provengono dalla pagina Wikipedia sulla funzione Ackermann.)

PPS: se la risposta è sì, potresti ad esempio scrivere una versione iterativa di una funzione non primitiva-ricorsiva. Ad esempio Ackermann nella risposta. Mi aiuterà a capire.

È possibile sostituire la ricorsione con iterazione più memoria illimitata .

Se hai solo iterazioni (diciamo, mentre loop) e una quantità finita di memoria, allora tutto ciò che hai è un automa finito. Con una quantità finita di memoria, il calcolo ha un numero finito di passaggi possibili, quindi è possibile simularli tutti con un automa finito.

La memoria illimitata modifica l'affare. Questa memoria illimitata può assumere molte forme che risultano avere un potere espressivo equivalente. Ad esempio, una macchina Turing lo rende semplice: c'è un singolo nastro e il computer può solo spostarsi avanti o indietro sul nastro di un passo alla volta, ma è abbastanza per fare tutto ciò che è possibile fare con le funzioni ricorsive.

Una macchina Turing può essere vista come un modello idealizzato di un computer (macchina a stati finiti) con un po 'di spazio in più che cresce su richiesta. Si noti che è fondamentale che non solo non ci sia un limite finito sul nastro, ma anche dato l'input, non è possibile prevedere in modo affidabile la quantità di nastro necessaria. Se potessi prevedere (cioè calcolare) la quantità di nastro necessaria dall'input, potresti decidere se il calcolo si fermerebbe calcolando la dimensione massima del nastro e quindi trattando l'intero sistema, incluso il nastro ormai finito, come una macchina a stati finiti .

Un altro modo per simulare una macchina Turing con i computer è il seguente. Simula la macchina Turing con un programma per computer che memorizza l'inizio del nastro in memoria. Se il calcolo raggiunge la fine della parte del nastro che si adatta alla memoria, sostituire il computer con un computer più grande ed eseguire nuovamente il calcolo.

Supponiamo ora di voler simulare un calcolo ricorsivo con un computer. Le tecniche per eseguire funzioni ricorsive sono ben note: ogni chiamata di funzione ha un pezzo di memoria, chiamato frame di stack . Fondamentalmente, le funzioni ricorsive possono propagare le informazioni attraverso più chiamate passando variabili. In termini di implementazione su un computer, ciò significa che una chiamata di funzione potrebbe accedere al frame dello stack di una chiamata (grand-) ^* parent.

Un computer è un processore - una macchina a stati finiti (con un numero enorme di stati, ma qui stiamo facendo la teoria dei calcoli, quindi tutto ciò che conta è che è finito) - accoppiato con una memoria finita. Il microprocessore esegue un loop gigante mentre: "mentre l'alimentazione è accesa, leggere un'istruzione dalla memoria ed eseguirla". (I processori reali sono molto più complessi di così, ma non influiscono su ciò che possono calcolare, solo quanto velocemente e comodamente lo fanno.) Un computer può eseguire funzioni ricorsive con questo ciclo while per fornire iterazione, oltre al meccanismo per accedere alla memoria, inclusa la possibilità di aumentare le dimensioni della memoria a piacimento.

Se si limita la ricorsione alla ricorsione primitiva, è possibile limitare l'iterazione all'iterazione limitata . Cioè, invece di utilizzare i cicli while con un tempo di esecuzione imprevedibile, è possibile utilizzare per i cicli in cui il numero di iterazioni è noto all'inizio del ciclo¹. Il numero di iterazioni potrebbe non essere noto all'inizio del programma: può essere stato calcolato da cicli precedenti.

Non ho nemmeno intenzione di delineare una prova qui, ma esiste una relazione intuitiva tra il passaggio dalla ricorsione primitiva alla ricorsione completa e il passaggio da cicli a cicli continui: in entrambi i casi, implica non sapere in anticipo quando Stop. Con la ricorsione completa, questo viene fatto con l'operatore di minimizzazione, dove si continua fino a quando non si trova un parametro che soddisfa la condizione. Con i cicli while, questo viene fatto continuando fino a quando la condizione del loop è soddisfatta.

¹ I _{loop in linguaggi di tipo C possono eseguire iterazioni illimitate proprio come , è solo una questione di convenzione limitarli a iterazioni limitate. Quando le persone parlano di "per loop" nella teoria del calcolo, ciò significa solo loop che contano da 1 a n (o equivalenti). forwhile$n$}

Ogni ricorsione può essere convertita in iterazione, come testimonia la tua CPU, che esegue programmi arbitrari usando un'iterazione infinita fetch-execute. Questa è una forma del teorema di Böhm-Jacopini . Inoltre, molti modelli di calcolo completi di Turing non presentano alcuna ricorsione, ad esempio macchine di Turing e macchine contatore .

Le funzioni ricorsive primitive corrispondono ai programmi che utilizzano l' iterazione limitata , ovvero è necessario specificare il numero di iterazioni in cui un ciclo viene eseguito in anticipo. L'iterazione limitata non può simulare la ricorsione in generale, poiché la funzione di Ackermann non è ricorsiva primitiva. Ma l'iterazione illimitata può simulare qualsiasi funzione parzialmente calcolabile.

$a(n,m)$

$s$

$\DeclareMathOperator{\push}{push}\push(s, x)$$x$$\DeclareMathOperator{\pop}{pop} x ← \pop(s)$$\DeclareMathOperator{\empty}{empty}\empty(s)$

$\texttt{Ackermann}(n_0, m_0):$ $\def\ifop#1{\texttt{if(}#1\texttt{):}}$ $\def\elseif#1{\texttt{else if(}#1\texttt{):}}$ $\def\elsop{\texttt{else:}}$

• $s = \emptyset$
• $\push(s,n_0)$
• $\push(s,m_0)$
• $\texttt{while(true):}$
  • $m ← \pop(s)$
  • $\ifop{\empty(s)}$
    • $\texttt{return }m$
  • $n ← \pop(s)$
  • $\ifop{n = 0}$
    • $\push(s, m+1)$
  • $\elseif{m=0}$
    • $\push(s, n-1)$
    • $\push(s, 1)$
  • $\elsop$
    • $\push(s, n-1)$
    • $\push(s, n)$
    • $\push(s, m-1)$

L'ho implementato in Ceylon, puoi eseguirlo nel WebIDE , se lo desideri. (Emette lo stack all'inizio di ogni iterazione del loop.)

Naturalmente, questo ha appena spostato lo stack di chiamate implicite dalla ricorsione in uno stack esplicito con i parametri e i valori di ritorno.

Ci sono già alcune grandi risposte (con le quali non posso nemmeno sperare di competere), ma vorrei presentare questa semplice spiegazione.

La ricorsione è solo la manipolazione dello stack di runtime. La ricorsione aggiunge un nuovo frame di stack (per la nuova invocazione della funzione ricorsiva) e il ritorno rimuove un frame di stack (per l'innovazione appena completata della funzione ricorsiva). La ricorsione causerà l'aggiunta / la rimozione di un numero di frame di stack, fino a quando alla fine non si chiudono tutti (si spera!) E il risultato viene restituito al chiamante.

Ora, cosa succederebbe se creassi il tuo stack, sostituissi le chiamate di funzioni ricorsive con lo push nello stack, sostituissi il ritorno da funzioni ricorsive con il pop-up dello stack e avessi un ciclo while che funzionava fino a quando lo stack era vuoto?

Per quanto ne so, e nella mia esperienza, puoi implementare qualsiasi ricorsione come iterazione. Come accennato in precedenza, la ricorsione utilizza lo stack, che è concettualmente illimitato, ma praticamente limitato (hai mai ricevuto un messaggio di overflow dello stack?). Nei miei primi giorni di programmazione (nel terzo trimestre dell'ultimo secolo dell'ultimo millennio) stavo usando linguaggi non ricorsivi implementando algoritmi ricorsivi e non ho avuto problemi. Non sono sicuro di come si dimostrerebbe, però.