Question

我被困在下一步。如果有人可以帮助我，那就太棒了：

2 = λfx.f(f x)
3 = λfx.f(f(f x))
ADD = λm n f x. m f (n f x)

我的步骤是：

   (λm n f x. m f (n f x)) (λf x.f(f(f x))) (λf x.f(f x))
-> ((λn f x. (λf x.f(f(f x))) f (n f x))) (λf x.f(f x))
-> ((λf x. (λf' x'.f'(f'(f' x'))) f ((λf" x".f"(f" x")) f x)

括号是否合适？我真的对替换和括号感到困惑。是否有一种正式的，更容易解决此类问题的技术？

Answer 1

尝试Alligator Eggs!

这是我的步骤，我是在Alligator Eggs的帮助下得出的：

ADD 2 3
-> (λm n f x. m f (n f x)) (λf x.f(f(f x))) (λf x.f(f x))
->   (λn f x. (λf x.f(f(f x))) f (n f x))   (λf x.f(f x))
->     (λf x. (λf x.f(f(f x))) f ((λf x.f(f x)) f x)) 
->     (λf x.   (λx.f(f(f x)))   ((λf x.f(f x)) f x)) 
->     (λf x.       f(f(f(λf x.f(f x)) f x)))))
->     (λf x.       f(f(f  (λx.f(f x)) x)))))
->     (λf x.       f(f(f     (f(f x))  )))))

Answer 2

我的建议，来自我自己有限但最近的经历：

一次一个事物：执行alpha转换，beta降低或eta转换。请注意，在页面边缘，您正在处理您到达下一行所采取的步骤。如果这些话对你来说并不熟悉，那么他们会做什么 - 只需看看Wikipedia。

这些减少步骤的快速摘要：

Alpha只是意味着一致地更改上下文中变量的名称：

λfx. f (f x) => λgx. g (g x)

Beta只是意味着将lambda应用于一个参数

(λf x. f x) b => λx. b x

Eta只是简单地解开＆＃39;一个不必要的包装函数，它不会改变它的含义。

λx.f x => f

然后

使用 lot 的alpha转换来更改变量的名称以使事情更清晰。所有这些f，它总是令人困惑。您已经完成了与第二行"相似的内容
假装你是一台电脑！当你评估一个表达时，不要跳过或跳过一步。做下一件事（只做一件事）。只有当你自信地慢慢移动时才能更快地移动。
考虑命名一些表达式，并在需要评估它们时只用它们替换它们的lambda表达式。我经常注意到页面边缘的替换为by def，因为它不是真正的缩减步骤。类似的东西：
```
add two three 
(λm n f x. m f (n f x)) two three | by def
```

遵循上述规则，这是我的工作范例：

two   = λfx. f (f x)
three = λfx. f (f (f x))
add   = λmnfx. m f (n f x)

0  | add two three 
1  | (λm n f x. m f (n f x)) two three           | by def
2  | (λn f x. two f (n f x)) three               | beta
3  | (λf x. two f (three f x))                   | beta
4  | (λf x. two f ((λfx. f (f (f x))) f x))      | by def
5  | (λf x. two f ((λgy. g (g (g y))) f x))      | alpha
6  | (λf x. two f ((λy. f (f (f y))) x))         | beta
7  | (λf x. two f (f (f (f x))))                 | beta
8  | (λf x. (λfx. f (f x)) f (f (f (f x))))      | by def
9  | (λf x. (λgy. g (g y)) f (f (f (f x))))      | alpha
10 | (λf x. (λy. f (f y)) (f (f (f x))))         | beta
11 | (λf x. (λy. f (f (f (f (f x))))))           | beta

Answer 3

是否有正式的，更容易解决此类问题的技术？

对于lambda术语来说，编写reducer和prettyprinter要比手动减少更容易。但PLT Redex可以帮助你减少开支;尝试定义正常订单减少的规则，然后你要做的就是担心prettyprinting the results with no redundant parentheses。

你也可能会学到很多东西。

教堂数字的补充

3 个答案: