lambda function 理论详解 & Python 实例解析 ｜Higher-order function｜英文

$\lambda$-Calculus

Real Question in Python

In order to solve the problem in Python as below, you need to grasp the theory behind this.

Currently, if you can’t solve the problem or figure out what the answer part is saying, no worries, just proceed to see the theory part first starting from 1.1 $\lambda$-Terms until the end. Then back to this part for the real question in Python.

# Question Part > what's the output value?

def foo(y):
  	return lambda x: x(x(y))

def bar(x):
  	return lambda y: x(y)

print((bar)(bar)(foo)(2)(lambda x: x + 1))

# Solution 1

# Step 1: Use alpha-conversion to rename the variables in case of naming conflicts.
def foo(i):
  	return lambda k: k(k(i))

# Step 2: Use beta-reduction to slove (bar)(bar). It means calling the function 'bar' and passing it with the argument 'bar'.
(lambda y: bar(y))(foo)(2)(lambda x: x + 1))

# Step 3: Use beta-reduction to solve (lambda y: bar(y))(foo). It means calling the function 'lambda y: bar(y)'' and passing it with the argument 'foo'.
bar(foo)(2)(lambda x: x + 1))

# Step 3: Use beta-reduction to solve bar(foo). It means calling the function 'bar' and passing it with the argument 'foo'.
(lambda y: foo(y))(2)(lambda x: x + 1))

# Step 4: Use beta-reduction to solve (lambda y: foo(y))(2). It means calling the function 'lambda y: foo(y)'' and passing it with the argument '2'.
foo(2)(lambda x: x + 1)

# Step 5: Use beta-reduction to solve foo(2). It means calling the function 'foo' and passing it with the argument '2'.
(lambda x: x(x(2)))(lambda x: x + 1)

# Step 6: Use alpha-conversion to rename the variables in case of naming conflicts.
(lambda x: x(x(2)))(lambda z: z + 1)

# Step 7: Use beta-reduction to solve (lambda x: x(x(2)))(lambda z: z + 1). It means calling the function 'lambda x: x(x(2))' and passing it with the argument 'lambda z: z + 1'.
(lambda z: z + 1)((lambda z: z + 1)(2))

# Step 8: Use the confluence of beta-reduction to solve ((lambda z: z + 1)(2)) firstly. It means calling the function 'lambda z: z + 1)' and passing it with the argument '2'.
# Note that in Python, the function is left-associate. However, we can apply the math technique to get the same result too. Inside Python, it doesn't work like this.
(lambda z: z + 1)(3)

# Step 9: Use beta-reduction to solve (lambda z: z + 1)(3). It means calling the function 'lambda z: z + 1' and passing it with the argument '3'.
4

# Solution 2

# Step 1: Use alpha-conversion to rename the variables in case of naming conflicts.
def bar(w):
  	return lambda z: w(z)
  
# the codes above it's equivalent to the codes below
# it 'bar' is always supplied a function (with 1 argument) as the argument
# bar(f)(g) -> (lmabda z: f(z))(g) -> f(g)
# when calling the function 'bar' and passing it the function 'f', the result is 'f' itself

# Step 2: Convert the original function above into the one below
def bar(w):
  	return w

Theory under the hood:
$$\lambda z.((\lambda b.M)z){▹}_{\beta }\lambda z.(M[b:=z]){▹}_{\alpha }\lambda b.(M[b:=z][z:=b])=\lambda b.M$$
Therefore,
$$(\lambda w.\lambda z.wz)(\lambda b.M){=}_{\beta }\lambda b.M$$

1.1 $\lambda$-Terms

• var -> variables
• abstraction -> $\lambda$ expression
• application -> execution

$$\begin{gathered} e:=var|atom|abstraction|application \\ abstraction:=\lambda var.e \\ application:=(e_1{e}_2) \end{gathered}$$

1.2 $\lambda$ Expression in Python

Examples

• $\lambda x.x+1\to lambdax:x+1$
• $\lambda x.\lambda y.xy\to lambdax:lambday:x(y)$
• $(\lambda x.2x)y\to (lambdax:2\ast x)(y)$

1.3 Free Variables

A variable x in a term e is bound if it is in the scope of a $\lambda x$ in e. Otherwise, it’s free.

Let $FV(e)$ be the free variables of e.
f = λ x . λ y . x y z F V ( f ) = { z } f = \lambda x. \lambda y.xyz \\ FV(f)=\{z\} f=λx.λy.xyzFV(f)={z}

1.4 SUBSTITUIONS

Let $e_1[x:=e_2]$ be the substitution of all free occurences of x in $e_1$ with $e_2$, changing the names of bound variables to avoid clashes.

（1）$x[x:=e]\equiv e$

（2）$(e_1{e}_2)[x:=e_3]\equiv (e_1[x:=e_3])(e_2[x:=e_3])$

（3）$(\lambda x.e_1)[x:=e_2]\equiv \lambda x.e_1$

• e.g. $(\lambda x.x+1)[x:=y]\equiv \lambda x.x+1$
• Why? x is not a free variable.

（4）$(\lambda y.e_1)[x:=e_2]\equiv \lambda y.e_{1}ifx\notin FV(e_1)$

• e.g. $(\lambda y.\lambda x.x+y)[x:=z]\equiv (\lambda y.\lambda x.x+y)$
• Why? x is not a free variable.

（5）$(\lambda y.e_1)[x:=e_2]\equiv \lambda y.(e_1[x:=e_2])ifx\in FV(e_1),y\notin FV(e_2)$

• e.g. $(\lambda y.x+y)[x:=z]\equiv \lambda y.z+y$

（6）$(\lambda y.e_1)[x:=e_2]\equiv \lambda z.((e_1[z:=y])[x:=e_2])ifx\in FV(e_1),y\in FV(e_2)$

• e.g. $(\lambda y.x+y)[x:=y]\equiv \lambda z.(x+z)[x:=y]\equiv \lambda z.(y+z)$
• why? It causes a naming conflict in this example. Intuitively, $\lambda y.y+y$ is impossible because $y$ is a parameter of lambda function, while $x$ may be a global variable. Hence, firstly we need to alternate $y$ with other distinct varibales, like $z$ here [$\alpha$-conversion]. In fact, It doesn’t change the meaning of this lambda function.

1.5 $\alpha$-conversion and congruence

$\alpha$-conversion: Change the name of the bound variable without causing name conflicts.
$$\lambda y.x+y{▹}_{\alpha }\lambda z.x+z$$
Both terms are $\alpha$-congruence if one term can be $\alpha$-converted into anther term in a finite steps.
$$\lambda y.x+y{\equiv }_{\alpha }\lambda z.x+z$$
Examples in Python:

def f(x): return x + 1
def f(y): return y + 1
f = lambda z: z + 1
f = lambda i: i + 1

1.6 $\beta$-reduction and equivalence

It tells how computation happens in $\lambda$-calculus. The idea behind $\lambda$-calculus is a series of functions. We keep calling functions and passing arguments in it until we get the result. The process of calling a function and passing arguments to it is called $\beta$-reduction.
$$(\lambda x.e)y{▹}_{\beta }e[x:=y]$$
Call the function $\lambda x.e$ and pass it $y$. The result is the return value of the function that you substitute the parameter $x$ with the argument $y$.

In other words, when you call the function, the result is $e$ where you substitue all the free ocurrences of $x$ with $y$.

When one term can be obtained from the other following a finite series of $\beta$-reduction, they are $\beta$-equivalent.
$$(\lambda x.x)y{=}_{\beta }y$$
Why? Because when conducting $\beta$-reduction, $(\lambda x.x)y=x[x:=y]$. $x$ is a free variable, so it can be substitued by $y$.

Examples in Python:

>>> f = lambda x: x
>>> y = 12
>>> f(y)
12

(1) The relationship between $\beta$-reduction and $\alpha$-conversion?

In $\beta$-reductioin, $e[x:=y]$ is substitution. When substituting a variable, substitution should advoid naming conflicts. The way to advoid is through $\alpha$-conversion. Naming conflicts is caused through substituting free varibales, like $(\lambda y.x+y)[x:=y]$.

On the contrast, when conducting $\beta$-reduction, we call the function and pass it the arguments. The result is the return expression of the function substituing all the parameters (bound variables once, but free variable now after $\beta$-reduction) with the arguments.

(2) Use $\beta$-reduction to evaluate pure functions in Python

To be clarified, it is not exactly Python works but we can apply the thought on the analysis.

Example 1:

In Python:

def f(x):
  	return x + 1
f = lambda x: x + 1

In $\lambda$-calculus:
$$f=\lambda x.x+1$$
Through $\beta$-reduction:
$$f(2){▹}_{\beta }(x+1)[x:=2]=2+1{▹}_{\beta }3$$
Example 2:

In Python:

g = lambda x: lambda y: x + y

In $\lambda$-calculus:
$$g=\lambda x.\lambda y.(x+y)$$
Through $\beta$-reduction:
$$g(1)(2){▹}_{\beta }(lambday:x+y)[x:=1](2){▹}_{\beta }(lambday:1+y)(2){▹}_{\beta }(1+y)[y:=2]{▹}_{\beta }1+2{▹}_{\beta }3$$

(3) Church-Rosser Theorem

It is regarding to the confluence of $\beta$-reduction (${▹}_{\beta }$).

The idea: If $P{▹}_{\beta }M$ and $P{▹}_{\beta }N$, there exists some $T$ where $M{▹}_{\beta }T$ and $N{▹}_{\beta }T$.

* $P$ is some $\lambda$ terms.

Example 1:
$$(\lambda x.(\lambda y.y)x)(1)$$
Path 1 - Reducing $(\lambda y.y)x$ :
$$(\lambda x.(\lambda y.y)x)(1){▹}_{\beta }(\lambda x.x)(1)){▹}_{\beta }1$$
Path 2 - Reducing $(\lambda x.(\lambda y.y)x)(1)$:
$$(\lambda x.(\lambda y.y)x)(1){▹}_{\beta }(\lambda y.y)(1){▹}_{\beta }1$$
It indicates that the order of calling which function first doesn’t matter.

Example 2 - Confluence in Python:

Path 1 - Reducing $(\lambda y.y)x$ :

* Note that in Python, the statements inside a function are not executed until the functioin is called. Here, we apply the math techniques - confluence to get the same result by executing the inner statements first.
$$(lambdax:(lambday:y)(x))(1){▹}_{\beta }(lambdax:x)(1)){▹}_{\beta }1$$
Path 2 - Reducing $(\lambda x.(\lambda y.y)x)(1)$:
$$(lambdax:(lambday:y)(x))(1){▹}_{\beta }(lambday:y)(1){▹}_{\beta }1$$

Reference：
Youtube: Lecture 9: Higher-Order Functions - Yong Qi Foo