Language on Siddharth Mishra

Lambda Calculus - Equivalences & Reductions

Thu, 06 Feb 2025 00:00:00 +0000

This section is important, because we’ll learn how are applications performed on given lambda expressions.

Info

TL;DR, to apply a lambda term in a lambda expression, we use a series of reductions. These reductions come from corresponding equivalence relations. A reduction is just another way of replacing the lambda expression with a corresponding equivalent expression.

Equivalence

When considering equivalence of two expressions, they can be equivalent in four ways

$\alpha$-equivalence - Renaming of bound variables
$\beta$-equivalence - Function application and reduction
$\eta$-equivalence - Function extensionality
syntactic equivalence

These equivalences are basically the equivalence relations we talked about above. Using a series of these equivalence relations between two lambda expressions, we can apply reductions to source lambda expression, and then reach a final, target expression from a source expression.

Lambda Calculus - Fixed Point Theorem

Thu, 06 Feb 2025 00:00:00 +0000

Fixed Point Theorem

$ \forall F \quad \exists X \mid FX = X $

For all lambda expression $F$, there exists another lambda expression $X$, such that $FX = X$, meaning when $F$ is applied over $X$ we get $X$ (itself).

Let’s take $F = \lambda x . x$ (the identity abstraction), Then any lambda expression can take place of $X$.
Now consider $F = \lambda x . y$, then we have $X \equiv y$, because $(\lambda x . y)y = y$.
If $F = \lambda x . xy$, then? Then can use $X \stackrel{\beta}{=} \lambda y . X$, because $FX \equiv (\lambda x . xy)(\lambda y . X) \stackrel{\beta}{\rightarrow} (\lambda y . X) y \stackrel{\beta}{\rightarrow} X$.
What if $F = \lambda x . xx$ then? We have $X \stackrel{\beta}{=} \lambda x . x$ or $X \stackrel{\eta}{=} I$ (the identity abstraction). Then $FX = FI = II = I$.

Info

Lambda Calculus - Free & Bound Variables

Thu, 06 Feb 2025 00:00:00 +0000

Free & Bound Variables

A variable occurrence is bound if it lies inside the scope of some $\lambda$ that binds it. Otherwise it’s free. Free variables are just the “inputs” a term still depends on.

Info

When I say a variable is free/bound, I mean the occurrence. The same symbol can be both free and bound inside the same expression.

Definitions

We can define the set of free variables $\text{FV}(M)$ and bound variables $\text{BV}(M)$ inductively:

Lambda Calculus - Logic

Thu, 06 Feb 2025 00:00:00 +0000

Logic

If, Else

Let’s build some boolean login out of power of pure combinations. Unlike usual logic, we won’t get true/false as values. Here true and false are lambda abstractions itself.

$\text{True} \stackrel{\beta}{=} \lambda xy.x$ - Meaning, take two values, and evaluate to only the first one.
$\text{False}\stackrel{\beta}{=} \lambda xy.y$ - Take two, and evaluate to only the second one, discarding the first.

These are often called $\text{First}$ and $\text{Second}$ correspondingly for these reasons. So we can write $\text{First} \equiv \text{True}$ and $\text{Second} \equiv \text{False}$.

Lambda Calculus - Grammar & Terms

Tue, 04 Feb 2025 00:00:00 +0000

Introduction

Lambda calculus, just like any other programming language out there is a programming language. In fact it’s the simplest programming language there is. It’s even simpler than assembly.

Tip

Whenever we compare something, it must be in respect with some common property. Saying one this is better than other, or one is easier than other is meaningless.

Lambda calculus is simpler than any language with respect to types of instructions available. Lambda calculus has just two instructions :

Fixing Recursions In Grammar

Sat, 01 Feb 2025 00:00:00 +0000

Edit 12th Feb 2025

Info

So, it turns out the actual grammar is more complex than what I initially thought. There seems to be a kind-of induced recursion due to mutual recursion between rule $\text{prefix}$, $\text{template-prefix}$ and $\text{prefix}$, $\text{closure-prefix}$. If you’re reading this post for the first time, just disregard this message.

\[ \text{A long-standing issue regarding algorithms that manipulate} \\ \text{context-free grammars (CFGs) in a “top-down” left-to-right fashion} \\ \text{is that left recursion can lead to nontermination.} ^{\text{[1]}} \]