Lambda-Kalkülgenerator

Ich weiß nicht, wo ich diese Frage sonst stellen soll, ich hoffe, das ist ein guter Ort.

Ich bin nur neugierig zu wissen, ob es möglich ist, einen Lambda-Kalkülgenerator herzustellen. Im Wesentlichen eine Schleife, die bei unendlicher Zeit jede mögliche Lambda-Kalkülfunktion erzeugt. (wie in Form einer Zeichenfolge).

Da der Lambda-Kalkül so einfach ist und nur wenige Elemente in seiner Notation enthält, dachte ich, dass es möglich (wenn auch nicht sehr nützlich) sein könnte, alle möglichen Kombinationen dieser Notationselemente zu erzeugen, beginnend mit den einfachsten Kombinationen, und dadurch jedes mögliche Lambda zu erzeugen Kalkülfunktion.

Natürlich weiß ich fast nichts über Lambda-Kalkül, daher habe ich keine Ahnung, ob dies wirklich möglich ist.

Ist es? Wenn ja, ist es ziemlich einfach, wie ich es mir vorgestellt habe, oder ist es technisch möglich, aber so schwierig, dass es praktisch unmöglich ist?

PS. Ich spreche nicht von Beta-reduzierten Funktionen, ich spreche nur von jeder gültigen Notation jeder Lambda-Kalkülfunktion.

Sicher, dies ist eine Standardcodierungsübung.

Zunächst sei eine bijektiv berechenbare Funktion, die als Paarungsfunktion bezeichnet wird. Eine Standardauswahl ist$p : \mathbb N^2 \to \mathbb N$

Man kann beweisen, dass dies eine Bijektion ist, also können wir bei jedem natürlichen so berechnen dass .n , $k$$n,m$$p(n,m)=k$

Um Lambda-Begriffe aufzulisten, korrigieren Sie die Aufzählung der Variablennamen: .$x_0,x_1,x_2,\ldots$

Dann wird für jede natürliche Zahl , Drucken , definiert rekursiv wie folgt:l a m b d a ( i $i$$lambda(i)$

• Wenn ist, sei und gebe die Variablej = i / 2 x $i$$j=i/2$$x_j$
• wenn ungerade ist, seij = ( i - 1 ) /$i$$j=(i-1)/2$
  • wenn ist, sei und finde so, dass ; berechne ; Rückantragk = j / 2 n , m p ( n , m ) = k N = l a m b d a ( n ) , M = l a m b d a ( m ) ( N M $j$$k=j/2$$n,m$$p(n,m)=k$$N=lambda(n), M=lambda(m)$$(NM)$
  • wenn ungerade ist, sei und finde so, dass ; berechne ; Abstraktion zurückgeben$j$$k=(j-1)/2$$n,m$$p(n,m)=k$$M=lambda(m)$$(\lambda x_n.\ M)$

Dieses Programm wird durch die folgende "algebraische" Bijektion gerechtfertigt, die die Menge aller Lambda-Terme :$\Lambda$

Dies wird gelesen als "die Lambda-Terme sind syntaktisch die disjunkte Vereinigung von 1) Variablen (dargestellt als natürlich), 2) Anwendungen (gemacht durch zwei Lambda-Terme) und 3) Abstraktion (ein Paar Variable / natürlich + Lambda-Term ) ".

Angesichts dessen wenden wir rekursiv berechenbare Bijektionen ( ) und (die Standard-Gerade / Ungerade) an, um den obigen Algorithmus zu erhalten.$\mathbb N^2 \simeq \mathbb N$$p$$\mathbb N + \mathbb N \simeq \mathbb N$

Diese Prozedur ist allgemein und funktioniert mit fast jeder Sprache, die durch eine kontextfreie Grammatik erzeugt wird, die einen ähnlichen Isomorphismus wie die oben beschriebene liefert.

Ja. Nehmen Sie etwas, das alle möglichen ASCII-Zeichenfolgen auflistet. Überprüfen Sie für jede Ausgabe, ob es sich um eine gültige Lambda-Kalkülsyntax handelt, die eine Funktion definiert. Wenn nicht, überspringen Sie es. (Diese Überprüfung kann durchgeführt werden.) Damit werden alle Lambda-Kalkülfunktionen aufgelistet.

Wie bereits erwähnt, werden hier nur Begriffe aus einer kontextfreien Sprache aufgezählt, die definitiv machbar sind. Dahinter steckt jedoch eine interessantere Mathematik, die sich mit der anlytischen Kombinatorik befasst.

Das Papier Zählen und Generieren von Begriffen in der binären Lambda-Rechnung enthält eine Behandlung des Aufzählungsproblems und vieles mehr. Zur Vereinfachung verwenden sie den so genannten binären Lambda-Calulus , bei dem es sich lediglich um eine Codierung von Lambda-Begriffen mit De Bruijn-Indizes handelt , sodass Sie keine Variablen benennen müssen.

Dieses Papier enthält auch konkreten Haskell-Code, der den Generierungsalgorithmus implementiert. Es ist definitiv effektiv möglich.

Ich habe zufällig eine Implementierung ihres Ansatzes in Julia geschrieben.

Sicher. Wir können sie direkt gemäß der Definition von Lambda-Begriffen erzeugen.

In Haskell definieren wir zuerst den Typ,

data LC a = Var a | App (LC a) (LC a) | Lam a (LC a)

instance Show a => Show (LC a) where
    show (Var i)   = [c | c <- show i, c /= '\'']
    show (App m n) = "(" ++ show m ++ " " ++ show n ++ ")"
    show (Lam v b) = "(^" ++ show (Var v) ++ "." ++ show b ++ ")"

und dann mit

lambda :: [a] -> [LC a]
lambda vars = terms 
  where
  terms = fjoin [ map Var vars ,
                  fjoin [[App t s | t <- terms] | s <- terms] ,
                  fjoin [[Lam v s | v <- vars ] | s <- terms] ]

  fjoin :: [[a]] -> [a]
  fjoin xs = go (take 1 xs) (drop 1 xs)      -- fair join
      where 
      go [] [] = []
      go a  b  = reverse (concatMap (take 1) a) ++ go 
                     (take 1 b ++ [t | (_:t) <- a]) (drop 1 b)

wir zählen sie nur auf, wie z

> take 20 $ lambda "xyz"
[x,y,(x x),z,(y x),(^x.x),(x y),(^y.x),((x x) x),(^x.y),(y y),(^z.x),(x (x x)),
 (^y.y),(z x),(^x.(x x)),((x x) y),(^z.y),(y (x x)),(^y.(x x))]

> take 5 $ drop 960 $ lambda "xyz"
[(((x x) y) (z x)),(^y.(^x.((x x) (x x)))),((^x.(x x)) (^x.(x x))),(^x.((^z.x) y
)),((z x) ((x x) y))]

Schauen Sie, der berühmte Begriff ist dort nicht weit von oben!$\Omega = (\lambda x . xx)( \lambda x . xx )$

fjoinentspricht Omega Monade ‚s diagonal.

Ich bin online auf ein Tool gestoßen, das Beispielzeichenfolgen aus einem regulären Ausdruck generieren kann: https://www.browserling.com/tools/text-from-regex . Sie können viele Beispiel-Lambda-Begriffe generieren, indem Sie Folgendes eingeben:

(\( (lambda \w\. )* \w+ \))* 

Um Begriffe mit beliebigen Verschachtelungsebenen zu erhalten, müssen Sie natürlich eine kontextfreie Grammatik verwenden, die ein aussagekräftigeres Werkzeug zum Definieren einer Sprache darstellt als ein regulärer Ausdruck. Ich bin nicht auf ein vorhandenes Tool zum Generieren von Beispielsprachensätzen gestoßen, das auf einer kontextfreien Grammatikdefinition basiert, aber es gibt keinen Grund, warum man keine erstellen könnte.