Lambda演算Beta还原的具体步骤以及原因

Question

From a book I'm recently reading:

First:

𝜆𝑧.(𝜆𝑚.𝜆𝑛.𝑚)(𝑧)((𝜆𝑝.𝑝)𝑧) The outermost lambda binding 𝑧 is, at this point, irreducible because it has no argument to apply to. What remains is to go inside the terms one layer at a time until we find something reducible.

Next:

𝜆𝑧.(𝜆𝑛.𝑧)((𝜆𝑝.𝑝)𝑧) We can apply the lambda binding 𝑚 to the argument 𝑧. We keep searching for terms we can apply. The next thing we can apply is the lambda binding 𝑛 to the lambda term ((𝜆𝑝.𝑝)𝑧) .

I don't get it. In the first section, it says 𝜆𝑧 has no argument to apply to, that I can probably understand, but then at the Next section I think the z can be bound to ((𝜆𝑝.𝑝)𝑧) because as you can see, 𝜆𝑧.(𝜆𝑛.𝑧) , the body of 𝜆𝑧 clearly has a z argument which can be bound. But the book just ignored the head 𝜆𝑧 and directly bound n to ((𝜆𝑝.𝑝)𝑧) . I mean 𝜆𝑛.𝑧 doesn't have an n argument, why does it get to be bound?

Can somebody explain to me about this?

Answer 1

Using normal order evaluation, you can get the answer in two beta reductions

// beta reduction 1
λz.(λn.)()((λp.p)z) →β (λn.m) [m := z]
λz.(λm.λn.)(z)((λp.p)z)

// beta reduction 2
λz.(z)()       →β z      [n := ((λp.p)z)]
λz.(λn.z)((λp.p)z)

// result
λz.z

The second reduction might seem tricky because n is bound to ((λp.p)z) but the expression is just z , so n is thrown away.

---

Using applicative order evaluation, it takes one extra step

// beta reduction 1
λz.(λm.λn.m)(z)(()) →β p      [p := z]
λz.(λm.λn.m)(z)((λp.)z)

// beta reduction 2
λz.(λn.)()(z)       →β (λn.m) [m := z]
λz.(λm.λn.)(z)(z)

// beta reduction 3
λz.(z)()             →β z      [n := z]
λz.(λn.z)(z)

// result
λz.z

---

In this scenario, whether we use normal order evaluation or applicative order evaluation, the result is the same. Differing evaluation strategies sometimes evaluate to different results.

An important note, the reduction steps we've done above will not take place until λz is applied (depending on the implementation). In the example code you have provided, λz is never applied, therefore simplifying λz 's term is just for exercise, in this case.

All we've done is demonstrate lambda equivalence (under two different evaluation strategies)

λz.(λm.λn.m)(z)((λp.p)z) <=> λz.z

Answer 2

Lambda notation is a bit weird to parse. IMO Haskell syntax is clearer:

\z -> (\m -> \n -> m) z ((\p -> p) z)

or, even more explicit

\z -> (
        (
           ( \m -> (\n -> m) )
           z
        )
        ( (\p -> p) z )
      )

The first reduction step is

\z -> (
        (
           (\n -> z)
        )
        ( (\p -> p) z )
      )

or

\z -> (
        (\n -> z)
        ( (\p -> p) z )
      )

then you can indeed bind ((\\p -> p) z) – not to z but to n ! (Which isn't actually used at all though.)

\z -> (
        (z)
      )

or simply \\z -> z . So, we still have that z lambda, which as the book said is irredicible. We just don't have anything else!

---

...I'm not sure if that was actually your question. If it was rather: why must we not first see if we can reduce ((\\p -> p) z) , then the answer is, I think, lambda calculus as such doesn't define this at all (it just defines what transformation you can apply, not in which order you should do it. ^{Actually I'm not sure about this, correct me if I'm wrong} ). In a strict language like Scheme, you would indeed first reduce ((\\p -> p) z) ; Haskell wouldn't do that since there's no need. Either way, it doesn't really matter, because the result is discarded anyway.

   ( \z -> (\n -> z) ((\p -> p) z) )
≡  ( \z -> (\n -> z) z )
≡  ( \z -> (\n -> z) foo )
≡  ( \z -> z )

Answer 3

The key is that n is never used in the abstraction. n is still bound to ((λp.p)z) , but it is immediately discarded.

λz.(λm.λn.m)(z)((λp.p)z) = λz.(λn.z)((λp.p)z)  Replacing m with z
                         = λz.z                Replacing n with ((λp.p)z)