## Saturday, May 15, 2021

### β-conversion

If you have an expression that is an application, and the operator of the application is a lambda expression, then you can β-reduce the application by substituting the arguments of the application for the bound variables of the lambda within the body of the lambda.

```(defun beta (expression if-reduced if-not-reduced)
(if (application? expression)
(let ((operator (application-operator expression))
(operands (application-operands expression)))
(if (lambda? operator)
(let ((bound-variables (lambda-bound-variables operator))
(body (lambda-body operator)))
(if (same-length? bound-variables operands)
(funcall if-reduced
(xsubst body
(table/extend* (table/empty)
bound-variables
operands)))
(funcall if-not-reduced)))
(funcall if-not-reduced)))
(funcall if-not-reduced)))

* (beta '((lambda (x y) (lambda (z) (* x y z))) a (+ z 3))
#'identity (constantly nil))
(LAMBDA (#:Z460) (* A (+ Z 3) #:Z460))```

A large, complex expression may or may not have subexpressions that can be β-reduced. If neither an expression or any of its subexpressions can be β-reduced, then we say the expression is in “β-normal form”. We may be able to reduce an expression to β-normal form by β-reducing where possible. A β-reduction can introduce further reducible expressions if we substitute a lambda expression for a symbol in operator position, so reducing to β-normal form is an iterative process where we continue to reduce any reducible expressions that arise from substitution.

```(defun beta-normalize-step (expression)
(expression-dispatch expression

;; case application
(lambda (subexpressions)
;; Normal order reduction
;; First, try to beta reduce the outermost application,
;; otherwise, recursively descend the subexpressions, working
;; from left to right.
(beta expression
#'identity
(lambda ()
(labels ((l (subexpressions)
(if (null subexpressions)
'()
(let ((new-sub (beta-normalize-step (car subexpressions))))
(if (eq new-sub (car subexpressions))
(let ((new-tail (l (cdr subexpressions))))
(if (eq new-tail (cdr subexpressions))
subexpressions
(cons (car subexpressions) new-tail)))
(cons new-sub (cdr subexpressions)))))))
(let ((new-subexpressions (l subexpressions)))
(if (eq new-subexpressions subexpressions)
expression
(make-application new-subexpressions)))))))

;; case lambda
(lambda (bound-variables body)
(let ((new-body (beta-normalize-step body)))
(if (eql new-body body)
expression
(make-lambda bound-variables new-body))))

;; case symbol
(constantly expression)))

;;; A normalized expression is a fixed point of the
;;; beta-normalize-step function.
(defun beta-normalize (expression)
(do ((expression expression (beta-normalize-step expression))
(expression1 '() expression)
(count 0 (+ count 1)))
((eq expression expression1)
(format t "~%~d beta reductions" (- count 1))
expression)))```

You can compute just by using β-reduction. Here we construct an expression that reduces to the factorial of 3. We only have β-reduction, so we have to encode numbers with Church encoding.

```(defun test-form ()
(let ((table
(table/extend*
(table/empty)
'(one
three
*
pred
zero?
y)
'(
;; Church numeral one
(lambda (f) (lambda (x) (f x)))

;; Church numeral three
(lambda (f) (lambda (x) (f (f (f x)))))

;; * (multiply Church numerals)
(lambda (m n)
(lambda (f)
(m (n f))))

;; pred (subtract 1 from Church numeral)
(lambda (n)
(lambda (f)
(lambda (x) (((n (lambda (g)
(lambda (h)
(h (g f)))))
(lambda (u) x))
(lambda (u) u)))))

;; zero? (test if Church numeral is zero)
(lambda (n t f) ((n (lambda (x) f)) t))

;; Y operator for recursion
(lambda (f)
((lambda (x) (f (x x)))
(lambda (x) (f (x x)))))

)))
(expr
'((lambda (factorial)
(factorial three))
(y (lambda (fact)
(lambda (x)
(zero? x
one
(* (fact (pred x)) x))))))))
(xsubst expr table)))

* (test-form)

((LAMBDA (FACTORIAL) (FACTORIAL (LAMBDA (F) (LAMBDA (X) (F (F (F X)))))))
((LAMBDA (F) ((LAMBDA (X) (F (X X))) (LAMBDA (X) (F (X X)))))
(LAMBDA (FACT)
(LAMBDA (X)
((LAMBDA (N T F) ((N (LAMBDA (X) F)) T)) X
(LAMBDA (F) (LAMBDA (X) (F X)))
((LAMBDA (M N) (LAMBDA (F) (M (N F))))
(FACT
((LAMBDA (N)
(LAMBDA (F)
(LAMBDA (X)
(((N (LAMBDA (G) (LAMBDA (H) (H (G F))))) (LAMBDA (U) X))
(LAMBDA (U) U)))))
X))
X))))))

* (beta-normalize (test-form))

127 beta reductions
(LAMBDA (F) (LAMBDA (X) (F (F (F (F (F (F X))))))))```

This is the Church numeral for 6.

I find it pretty amazing that we can bootstrap ourselves up to arithmetic just by repeatedly β-reducing where we can. It doesn't seem like we're actually doing any work. We're just replacing names with what they stand for.

The β-substitution above replaces all the bound variables with their arguments if there is the correct number of arguments. One could easily implement a partial β-substitution that replaced only some of the bound variables. You'd still have an application, but some of the bound variables in the lambda would be eliminated and the corresponding argument would be removed.