Generatore di calcoli Lambda

Non so dove altro porre questa domanda, spero che sia un buon posto.

Sono solo curioso di sapere se è possibile creare un generatore di calcolo lambda; essenzialmente, un ciclo che, a tempo infinito, produrrà ogni possibile funzione di calcolo lambda. (come sotto forma di una stringa).

Poiché il calcolo lambda è così semplice, avendo solo pochi elementi nella sua notazione, ho pensato che sarebbe stato possibile (anche se non molto utile) produrre tutte le possibili combinazioni di quegli elementi della notazione, a partire dalle combinazioni più semplici, e quindi produrre ogni possibile lambda funzione di calcolo.

Certo, non so quasi nulla del calcolo lambda, quindi non ho idea se questo sia davvero possibile.

È? Se è così, è abbastanza semplice come l'ho immaginato, o è tecnicamente possibile, ma così difficile da essere effettivamente impossibile?

PS. Non sto parlando di funzioni beta-ridotte, sto solo parlando di ogni notazione valida di ogni funzione di calcolo lambda.

Certo, questo è un esercizio di codifica standard.

Prima di tutto, qualsiasi funzione calcolabile biiettiva, chiamata funzione di associazione. Una scelta standard è$p : \mathbb N^2 \to \mathbb N$

Si può dimostrare che questa è una biiezione, quindi dato qualsiasi naturale , possiamo calcolare tale che .n , m p ( n , m ) = $k$$n,m$$p(n,m)=k$

Per enumerare i termini lambda, correggi qualsiasi enumerazione per i nomi delle variabili: .$x_0,x_1,x_2,\ldots$

Quindi, per ogni numero naturale , stampa , definito in modo ricorsivo come segue:l a m b d a ( i $i$$lambda(i)$

• se è pari, lascia e restituisce la variabilej = i / 2 x $i$$j=i/2$$x_j$
• se è dispari, lasciaj = ( i - 1 ) /$i$$j=(i-1)/2$
  • se è pari, lascia e trova tale che ; calcolare ; domanda dik = 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)$
  • se è dispari, lascia e trova tale che ; calcolare ; ritorno astrazionek = ( j - 1 ) / 2 n , m p ( n , m ) = k M = l a m b d a ( m ) ( λ x n . M $j$$k=(j-1)/2$$n,m$$p(n,m)=k$$M=lambda(m)$$(\lambda x_n.\ M)$

Questo programma è giustificato dalla seguente biiezione "algebrica" ​​che coinvolge l'insieme di tutti i termini lambda :$\Lambda$

che viene letto come "i termini lambda, sintatticamente, sono l'unione disgiunta di 1) variabili (rappresentate come naturali), 2) applicazioni (create da due termini lambda) e 3) astrazione (una coppia variabile / naturale + termine lambda )".

Detto questo, applichiamo ricorsivamente biiezioni calcolabili ( ) e (lo standard pari / dispari) per ottenere l'algoritmo sopra. p N + N ≃$\mathbb N^2 \simeq \mathbb N$$p$$\mathbb N + \mathbb N \simeq \mathbb N$

Questa procedura è generale e funzionerà su quasi tutti i linguaggi generati attraverso una grammatica senza contesto, che fornirà un isomorfismo simile a quello sopra.

Sì. Prendi qualcosa che enumera tutte le possibili stringhe ASCII. Per ogni output, controlla se è una sintassi di calcolo lambda valida che definisce una funzione; in caso contrario, saltalo. (Questo controllo può essere eseguito.) Che elenca tutte le funzioni di calcolo lambda.

Come è stato menzionato, si tratta solo di enumerare i termini da un linguaggio privo di contesto, quindi assolutamente fattibile. Ma c'è più matematica interessante dietro di essa, andando nel campo della combinatoria analitica.

L'articolo Conteggio e generazione dei termini nel calcolo lambda binario contiene un trattamento del problema di enumerazione e molto altro. Per semplificare le cose, usano qualcosa chiamato il binario lambda calulus , che è solo una codifica dei termini lambda usando gli indici di De Bruijn , quindi non devi nominare le variabili.

Tale documento contiene anche un codice Haskell concreto che implementa il loro algoritmo di generazione. È sicuramente efficacemente possibile.

Mi è capitato di aver scritto un'implementazione del loro approccio a Julia.

Sicuro. Possiamo generarli direttamente secondo la definizione dei termini lambda.

In Haskell, definiamo prima il tipo di dati,

data LC a  =  Var  a                -- Constructor <type> <type> ...
           |  App (LC a) (LC a)     --
           |  Lam  a     (LC a)     --  ... alternatives ...

instance Show a => Show (LC a)      -- `LC a` is in Show if `a` is in Show, and
  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 ++ ")"

e poi con l'uso di una fiera (er) join,

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 [] xs             -- fairer join
      where 
      go [] []  =  []
      go a  b   =  reverse (concatMap (take 1) a) ++ go 
                       (take 1 b ++ [t | (_:t) <- a]) (drop 1 b)

li enumeriamo semplicemente, come ad es

> 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))]

Guarda, il famoso termine è lì dentro non molto lontano dalla cima!$\Omega = (\lambda x . xx)( \lambda x . xx )$

fjoinè equivalente a Omega Monade s' diagonal.

Ho trovato uno strumento online in grado di generare stringhe di esempio da un'espressione regolare: https://www.browserling.com/tools/text-from-regex . Puoi generare molti termini lambda di esempio inserendo qualcosa del genere:

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

Naturalmente per ottenere termini con livelli arbitrari di annidamento, dovrai utilizzare una grammatica senza contesto, che è uno strumento più descrittivo per definire una lingua che un'espressione regolare. Non ho trovato uno strumento esistente per generare frasi in linguaggio di esempio basate su una definizione grammaticale senza contesto, ma non c'è motivo per cui non si possa costruire.