Gerador de cálculo Lambda

Não sei mais aonde fazer essa pergunta, espero que este seja um bom lugar.

Estou curioso para saber se é possível fazer um gerador de cálculo lambda; essencialmente, um loop que, com tempo infinito, produzirá todas as funções possíveis de cálculo lambda. (como na forma de uma string).

Como o cálculo lambda é muito simples, tendo apenas alguns elementos em sua notação, pensei que seria possível (embora não muito útil) produzir todas as combinações possíveis desses elementos de notação, começando pelas combinações mais simples, e assim produzir todos os lambda possíveis função de cálculo.

Claro, eu não sei quase nada sobre cálculo lambda, então não tenho idéia se isso é realmente possível.

É isso? Em caso afirmativo, é bem simples como eu o imaginava, ou é tecnicamente possível, mas tão difícil que é efetivamente impossível?

PS. Não estou falando de funções com redução beta, mas apenas de todas as notações válidas de todas as funções de cálculo lambda.

Claro, este é um exercício de codificação padrão.

Antes de tudo, deixe qualquer função computável bijetiva, chamada função de emparelhamento. Uma escolha padrão é$p : \mathbb N^2 \to \mathbb N$

Pode-se provar que isso é uma bijeção, portanto, dado qualquer natural , podemos calcular n , m de modo que p ( n , m ) = k .$k$$n,m$$p(n,m)=k$

Para enumerar termos lambda, corrija qualquer enumeração para nomes de variáveis: .$x_0,x_1,x_2,\ldots$

Então, para cada número natural , imprima l a m b d a ( i ) , definido recursivamente da seguinte maneira:$i$$lambda(i)$

• se for par, deixe j = i / 2 e retorne a variável x $i$$j=i/2$$x_j$
• se é ímpar, seja j = ( i - 1 ) /$i$$j=(i-1)/2$
  • se for par, deixe k = j / 2 e encontre n , m de modo que p ( n , m ) = k ; calcular N = l a m b d a ( n ) , M = l a m b d a ( m ) ; aplicação de devolução ( N M $j$$k=j/2$$n,m$$p(n,m)=k$$N=lambda(n), M=lambda(m)$$(NM)$
  • se for ímpar, seja k = ( j - 1 ) / 2 e encontre n , m tal que p ( n , m ) = k ; calcular M = l a m b d a ( m ) ; abstração de retorno ( λ x n . M $j$$k=(j-1)/2$$n,m$$p(n,m)=k$$M=lambda(m)$$(\lambda x_n.\ M)$

Este programa é justificado pela seguinte bijeção "algébrica" ​​envolvendo o conjunto de todos os termos lambda :$\Lambda$

que é lido como "os termos lambda, sintaticamente, são a união disjunta de 1) variáveis ​​(representadas como naturais), 2) aplicações (feitas por dois termos lambda) e 3) abstração (um par variável / natural + termo lambda ) ".

Dado isso, aplicamos recursivamente as bijeções computáveis ( p ) e N + N ≃ N (o padrão par / ímpar) para obter o algoritmo acima.$\mathbb N^2 \simeq \mathbb N$$p$$\mathbb N + \mathbb N \simeq \mathbb N$

Este procedimento é geral e funcionará em quase qualquer linguagem gerada por meio de uma gramática livre de contexto, que fornecerá um isomorfismo semelhante ao descrito acima.

Sim. Pegue algo que enumere todas as seqüências ASCII possíveis. Para cada saída, verifique se é uma sintaxe válida de cálculo lambda que define uma função; Caso contrário, pule. (Essa verificação pode ser feita.) Isso enumera todas as funções de cálculo lambda.

Como foi mencionado, isso é apenas enumerando termos de uma linguagem livre de contexto, tão definitivamente factível. Mas há uma matemática mais interessante por trás disso, entrando no campo da combinatória analítica.

O artigo Contando e gerando termos no cálculo lambda binário contém um tratamento do problema de enumeração e muito mais. Para simplificar, eles usam algo chamado binário lambda calulus , que é apenas uma codificação de termos lambda usando índices De Bruijn , para que você não precise nomear variáveis.

Esse documento também contém código Haskell concreto implementando seu algoritmo de geração. É definitivamente efetivamente possível.

Por acaso, escrevi uma implementação de sua abordagem em Julia.

Certo. Podemos gerá-los diretamente de acordo com a definição de termos lambda.

Em Haskell, definimos o tipo de dados primeiro,

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 depois com o uso de uma feira (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)

apenas as enumeramos, como por exemplo

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

Olha, o famoso $\Omega = (\lambda x . xx)( \lambda x . xx )$ termo está lá não tão longe do topo!

fjoiné equivalente ao Omega monad 's diagonal.

Encontrei uma ferramenta on-line que pode gerar seqüências de amostra a partir de uma expressão regular: https://www.browserling.com/tools/text-from-regex . Você pode gerar muitos termos lambda de amostra inserindo algo como isto:

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

Obviamente, para obter termos com níveis arbitrários de aninhamento, você precisará usar uma gramática livre de contexto, que é uma ferramenta mais descritiva para definir um idioma do que uma expressão regular. Eu não encontrei uma ferramenta existente para gerar frases de exemplo de linguagem com base em uma definição gramatical livre de contexto, mas não há razão para que uma não possa ser criada.