什么是枚舉lambda術語的算法？

Question

什么算法將按照長度的順序枚舉lambda演算的表達式？ 例如， (λx.x), (λx.(xx)), (λx.(λy.x))等等？

Answer 1

作為長度，我將在（無類型）lambda表達式的BNF中選擇T -expansions（“depth”）的數量：

V ::= x | y
T ::= V    | 
      λV.T |
      (T T)

在python中，你可以按照上面給定變量的生成規則定義一個生成器，給定的深度如下：

def lBNF(vars, depth):
  if depth == 1:
    for var in vars:
      yield var
  elif depth > 1:
    for var in vars:
      for lTerm in lBNF(vars,depth-1):
        yield 'l%s.%s' % (var,lTerm)
    for i in range(1,depth):
      for lTerm1 in lBNF(vars,i):
        for lTerm2 in lBNF(vars,depth-i):
          yield '(%s %s)' % (lTerm1,lTerm2)

現在，您可以枚舉/達到給定深度的lambda術語：

vars = ['x','y']
for i in range(1,5):
  for lTerm in lBNF(vars,i):
    print lTerm

Answer 2

請參閱https://arxiv.org/abs/1210.2610 ，第5頁。以下是一些示例代碼：

from itertools import chain, count
from functools import lru_cache

@lru_cache(maxsize=None)
def terms(size, level=0):
    if size == 0:
        return tuple(range(level))
    else:
        abstractions = (
            ('abs', term)
            for term in terms(size - 1, level + 1)
        )
        applications = (
            ('app', term1, term2)
            for i in range(size)
            for term1 in terms(i, level)
            for term2 in terms(size - 1 - i, level)
        )
        return tuple(chain(abstractions, applications))

def string(term):
    if isinstance(term, tuple):
        if term[0] == 'abs':
            return '(λ {})'.format(string(term[1]))
        elif term[0] == 'app':
            return '({} {})'.format(string(term[1]), string(term[2]))
    else:
        return term

for size in count():
    print('{} terms of size {}'.format(len(terms(size)), size))
    for term in terms(size):
        pass # input(string(term))

這輸出

0 terms of size 0
1 terms of size 1
3 terms of size 2
14 terms of size 3
82 terms of size 4
579 terms of size 5
4741 terms of size 6
43977 terms of size 7
454283 terms of size 8

等等（即這個序列 ）。