Генератор лямбда-исчисления

Я не знаю, где еще задать этот вопрос, я надеюсь, что это хорошее место.

Мне просто любопытно узнать, возможно ли создать генератор лямбда-исчисления; по сути, цикл, который при заданном бесконечном времени будет производить все возможные функции лямбда-исчисления. (как в виде строки).

Так как лямбда-исчисление очень простое, имея в своем обозначении всего несколько элементов, я подумал, что можно (хотя и не очень полезно) создать все возможные комбинации этих элементов обозначений, начиная с простейших комбинаций, и тем самым получить все возможные лямбда-выражения. исчисление функции.

Конечно, я почти ничего не знаю о лямбда-исчислении, поэтому понятия не имею, возможно ли это на самом деле.

Это? Если так, это довольно просто, как я предполагал, или это технически возможно, но настолько сложно, что это фактически невозможно?

PS. Я не говорю о функциях с бета-сокращением, я просто говорю о каждой действительной записи каждой функции лямбда-исчисления.

Конечно, это стандартное упражнение по кодированию.

Прежде всего, пусть любая биективная вычислимая функция, называемая парной функцией. Стандартный выбор$p : \mathbb N^2 \to \mathbb N$

Можно доказать, что это биекция, поэтому при любом натуральном мы можем вычислить n , m так , чтобы p ( n , m ) = k .$k$$n,m$$p(n,m)=k$

Чтобы перечислить лямбда-термины, исправьте любое перечисление для имен переменных: .$x_0,x_1,x_2,\ldots$

Затем для каждого натурального числа выведите l a m b d a ( i ) , рекурсивно определенное следующим образом:$i$$lambda(i)$

• если четный, пусть j = i / 2 и возвращает переменную x $i$$j=i/2$$x_j$
• если нечетный, пусть j = ( i - 1 ) /$i$$j=(i-1)/2$
  • если четно, пусть k = 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)$
  • если нечетно, пусть k = ( 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)$

Эта программа обоснована следующей «алгебраической» биекцией, включающей множество всех лямбда-членов :$\Lambda$

который читается как «лямбда-термины, синтаксически - это непересекающееся объединение 1) переменных (представленных как натуральные), 2) приложений (составленных из двух лямбда-терминов) и 3) абстракции (парная переменная / натуральная + лямбда-член )».

Учитывая это, мы рекурсивно применяем вычислимые биекции ( p ) и N + N ≃ N (стандартная четная / нечетная) для получения алгоритма, описанного выше.$\mathbb N^2 \simeq \mathbb N$$p$$\mathbb N + \mathbb N \simeq \mathbb N$

Эта процедура является общей и будет работать практически на любом языке, сгенерированном с помощью контекстно-свободной грамматики, которая обеспечит изоморфизм, аналогичный приведенному выше.

Да. Возьмите что-то, что перечисляет все возможные строки ASCII. Для каждого вывода проверьте, является ли он допустимым синтаксисом лямбда-исчисления, который определяет функцию; если нет, пропустите это. (Эту проверку можно сделать.) Перечисляет все функции лямбда-исчисления.

Как уже упоминалось, это просто перечисление терминов из языка без контекста, так что это определенно выполнимо. Но за этим стоит более интересная математика, уходящая в область анлитической комбинаторики.

В статье Подсчет и генерация членов в двоичном лямбда-исчислении содержится обработка проблемы перечисления и многое другое. Чтобы упростить задачу , они используют нечто, называемое двоичным лямбда-каллусом , которое представляет собой просто кодировку лямбда-терминов с использованием индексов Де Брюина , поэтому вам не нужно называть переменные.

Эта статья также содержит конкретный код на Haskell, реализующий алгоритм их генерации. Это определенно эффективно возможно.

Я случайно написал реализацию их подхода в Юлии.

Конечно. Мы можем напрямую генерировать их в соответствии с определением лямбда-терминов.

В Haskell мы сначала определяем тип данных,

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 ++ ")"

а затем с использованием ярмарки (эр) 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)

мы просто перечисляем их, например,

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

Посмотрите, знаменитый член $\Omega = (\lambda x . xx)( \lambda x . xx )$ находится не так далеко от вершины!

fjoinэквивалентно Omega монады «s diagonal.

В Интернете я наткнулся на один инструмент, который может генерировать образцы строк из регулярного выражения: https://www.browserling.com/tools/text-from-regex . Вы можете сгенерировать много примеров лямбда-терминов, введя что-то вроде этого:

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

Конечно, чтобы получить термины с произвольными уровнями вложенности, вам нужно будет использовать контекстно-свободную грамматику, которая является более описательным инструментом для определения языка, чем регулярное выражение. Я не сталкивался с существующим инструментом для генерирования типовых предложений на основе определения грамматики без контекста, но нет причин, по которым его нельзя было бы построить.