-calculus, gibt es eine Kodierung für oder während?

7

Im $\lambda$ -calculus, wir können Arithmetik, Zahlen, Boolesche Werte codieren und sogar Fakultäten von Zahlen berechnen, wie hier gezeigt .

Gibt es eine Kodierung von "für" oder "während"?

lambda-calculus computation-models

— alim
quelle

6

λ-Kalkül ist vollständig, also können Sie das Gleiche für eine for- oder while-Schleife tun. Ich würde sie nicht als Kodierungen bezeichnen , da sie nur Funktionen sind, wie alles in λ-Kalkül

— Euge

11

Sicher! Lassen Sie mich anhand eines Beispiels zeigen, wie FOR codiert wird.

Angenommen, wir möchten ein einfaches faktorielles FOR-Programm übersetzen

x := 1
for i := 1 to N do
   x := x * i

Wir schreiben es um als

x := 1
i := 1
repeat N times
   x := x*i
   i := i+1

dann setzen wir alle Variablen, die wir verwenden, in ein Tupel (hier genügt ein Paar)

(x,i) := (1,1)
repeat N times
   (x,i) := (x*i, i+1)

Dies wendet die Funktion effektiv an $\lambda\langle x,i \rangle. \langle x*i , i+1 \rangle$ zum ersten Paar $\langle 1,1 \rangle$ zum $N$ mal.

Schon seit $N$ kann als Kirchenzahl dargestellt werden, bekommen wir

N (λ ⟨ x, i ⟩ . ⟨ x * i, i + 1 ⟩) ⟨ 1, 1 ⟩

$N (\lambda\langle x,i \rangle. \langle x*i , i+1 \rangle) \langle 1,1 \rangle$

Die obige Syntax verwendet einige Dinge, die über den einfachen Lambda-Kalkül hinausgehen. Zahlen und Arithmetik können mit Kirchenzahlen präzisiert werden. Paare haben auch eine eigene Kirchencodierung:

⟨ x, y ⟩ \equiv λ k . k x y λ ⟨ x, y ⟩ . M \equiv λ z . M {z T / x, z F / y}

$\langle x,y \rangle \equiv \lambda k.kxy \qquad \lambda \langle x,y \rangle . M \equiv \lambda z. M\{zT/x, zF/y\}$ wo

z

$z$ ist eine neue Variable,

T = λ a b . a

$T = \lambda ab.a$ und

F = λ a b . b

$F = \lambda ab.b$ .

Wenn Sie mehr als zwei Variablen haben, können Sie die obige Codierung auf Tupel verallgemeinern oder Tupel einfach als verschachtelte Paare darstellen.

WÄHREND die Rekursion am besten behandelt wird: statt

while p(x,i) do
   (x,i) := f(x,i)

Wo pein Prädikat und feine (Teil-) Funktion ist, können wir so etwas verwenden

def recFun(x,i):
   if p(x,i):
      return recFun(f(x,i))
   else:
      return (x,i)

In der Lambda-Rechnung wird die Rekursion unter Verwendung eines Festpunktkombinators , z. B. der Kirche, erhalten $Y$ oder Turings $\Theta$ . Wir bekommen so etwas wie

Y (λ r . λ ⟨ x, i ⟩ . i f p x i t h e n r (f ⟨ x, i ⟩) e l s e ⟨ x, i ⟩)

$Y (\lambda r . \lambda \langle x,i \rangle . {\sf if}\ p x i\ {\sf then }\ r(f \langle x,i \rangle)\ {\sf else}\ \langle x,i \rangle)$

wo ${\sf if}\ b\ {\sf then }\ t\ {\sf else}\ e \equiv b t e$ vorausgesetzt, Boolesche Werte sind kirchenkodiert.

Beachten Sie auch, dass WHILE (streng) leistungsfähiger als FOR ist. Jedes FOR kann als WHILE codiert werden, sodass diese Codierungstechnik auch für FOR verwendet werden kann.

— Chi
quelle

9

Es gibt Codierungen von Schleifen, aber sie funktionieren nicht genau wie die Schleifen, die Sie gewohnt sind, da der Lambda-Kalkül keine zwingende Sprache ist. Der Lambda-Kalkül hat keine Nebenwirkungen (es ist eine rein funktionale Sprache), daher wäre das genaue Äquivalent einer Schleife nutzlos.

Expliziter Zustand

Ein imperatives Programm kann in eine rein funktionale Sprache übersetzt werden, indem der gesamte Status explizit als Variable im Programm weitergegeben wird. Ich werde die Python-Syntax für den imperativen Pseudocode verwenden. Es sollte größtenteils transparent sein, mit der Angabe, (a, b) = f(…)dass der Aufruf der Funktion fein Paar zurückgibt aund bder ersten bzw. zweiten Komponente des Paares zugewiesen wird. Betrachten Sie eine Schleife

while test_condition():
    do_stuff()

Lassen Sie uns den Zustand explizit machen.

state = initial_state
(state, cond) = test_condition(state)
while cond:
    (state, cond) = test_condition(do_stuff(state))

Wir können dies in einen rekursiven Aufruf übersetzen. def loop(state):definiert eine aufgerufene Funktion loop.

def loop(state):
    (state, cond) = test_condition(state)
    if cond: return loop(do_stuff(state))
    else: return state
state = loop(initial_state)

Hierbei werden nur die folgenden Konzepte verwendet, die alle im Lambda-Kalkül leicht ausgedrückt werden können:

Funktionsaufrufe: natives Konzept
Lokale Variablenzuweisungen ohne Neuzuweisung: Übergeben Sie den Wert an eine Hilfsfunktion
Paare: Kirchenpaare
Boolesche Werte: Kirchenboolesche Werte
Rekursion: Festpunktkombinatoren

Und so können wir eine whileFunktion für eine Bedingung definieren $C$ ( test_condition) und ein Körper $B$ ( do_stuff):

w h i l e := λ C . λ B . f i x (λ f . λ s . (λ p . BODY (f i r s t p) (s e c o n d p)) (C s)) where BODY = λ s^{'} . λ c . i f c (f (B s^{'})) s^{'}

$\mathsf{while} := \lambda C. \lambda B. \mathsf{fix} (\lambda f. \lambda s. (\lambda p. \text{BODY} (\mathsf{first}\, p) (\mathsf{second}\, p)) (C \, s)) \\ \text{where BODY} = \lambda s'. \lambda c. \mathsf{if} \, c \, (f \, (B \, s')) \, s'$

For-Schleifen variieren je nach Programmiersprache, sind jedoch immer ein Sonderfall von while-Schleifen, sodass sie auf die gleiche Weise codiert werden können. Wenn die Ausgangssprache die Ausdruckskraft von for-Schleifen einschränkt, kann es zu einfacheren Codierungen kommen. Zum Beispiel „Wiederholen $n$ times ”ist einfach Funktionszusammensetzung $n$ Zeiten, in denen die Funktion die Zustandstransformation ist, die den Körper der Schleife bildet, und wenn $n$ ist eine kirchliche Ziffer, die einfach zutrifft $n$ selbst auf die Schleifenkörperfunktion.

Hinzufügen eines Status zur Sprache

Ein alternativer Ansatz für den Zustand besteht darin, den Lambda-Kalkül mit Grundelementen zur Zustandsmanipulation zu erweitern. Wenn Sie dies tun, wird die Reihenfolge der Bewertung wichtig. In diesem Fall kann eine while-Schleife direkt mit Rekursion ausgedrückt werden.

{w h i l e}_{imperative} := λ C . λ B . f i x (λ f . i f C (B; f) ())

$\mathsf{while}_{\text{imperative}} := \lambda C. \lambda B. \mathsf{fix} (\lambda f. \mathsf{if} \, C \, (B; f) \, ())$

— Gilles 'SO - hör auf böse zu sein'
quelle