Unit-2

Lambda calculus
 What is Lambda calculus?
• Formal system for expressing computation
• Uses “function abstraction” and “function
application”
• Developed by mathematician Alonso church in
1930
• Also used as theoretical framework in
computer science and programming languages
 Lambda Abstraction
• Lambda abstraction is the process of defining
anonymous functions

• represented by the Greek letter lambda (λ)

followed by a variable and an expression.

• λx. x + 1 represents a function that takes an

argument 'x' and returns 'x + 1'.
 Function Application
• Functions are applied to arguments using function application. (to say)
• The arguments to functions are placed next to the function
• For example,
– (λx. x + 1) 2 results in 2 + 1.
– add = λx. λy. x + y
– λx. λy. x + y (anonymous function – without name)
• The arguments to the function can be written as
– (add 3) 5
– (λx. λy. x + y) 3 5
• In lambda calculus the format typically is
– (function argument1) argument2
• follows a left-associative notation where you apply the function to its
arguments in a sequential manner
 Application
• Lambda function to add three variables
– add = λx. λy. λz. x + (y + z)
– (add 3) 5 7

• Lambda function to add three values using

two variable function
– add = λx. λy. x + y
– ((addTwo 3) 5) 7
 Lambda and functional languages
• Basis for Functional Programming: Lambda calculus is the theoretical foundation
of functional programming languages, influencing their design and semantics.

• Higher-Order Functions: Lambda calculus supports the concept of higher-order

functions, which are essential in functional programming.

• Anonymous Functions: It enables the creation of anonymous functions, a key

feature in many programming languages.

• Closure and Lexical Scoping: Lambda calculus principles underlie the concept of
closure and lexical scoping in programming languages.

• Map, Filter, Reduce: Functional programming constructs like map, filter, and
reduce are based on lambda calculus.
• Recursion: Lambda calculus demonstrates the use of recursion, a fundamental concept
in programming.

• Formal Semantics: Lambda calculus provides a formal framework for defining the
semantics of programming languages.

• Lisp and Scheme: Lisp and Scheme are programming languages directly influenced by
lambda calculus.

• Type Systems: Typed lambda calculus forms the basis for type systems in programming
languages.
• Expressive Power: Lambda calculus demonstrates the expressive power of functions
and their role in computation.

• Algorithmic Understanding: It aids in understanding algorithms and algorithmic

thinking in programming.
 Features of lambda calculus
• Lambda Abstraction (λ): The lambda symbol λ is used to define
anonymous functions.
• Variable Binding: Variables can be bound within lambda
abstractions, allowing for local scope.
• Function Application: Functions are applied to arguments using
function application.
• Beta Reduction: Beta reduction is the process of evaluating
functions by substituting arguments.
• Variables: Variables represent values and functions.
• Free and Bound Variables: Variables can be free (unbound) or
bound within expressions.
• Alpha Conversion: Alpha conversion allows renaming variables
without changing meaning.
• Function Composition: Functions can be composed to create
new functions.
• Higher-Order Functions: Functions can take functions as
arguments and return functions.
• Universality: Lambda calculus is Turing complete and can
express any computable function.
• Computational Simplicity: Lambda calculus provides a simple
but powerful notation for computation.
• Basis for Functional Programming: It forms the basis for
functional programming languages and their constructs.
 Bound and Free Variable
• Free Variables: Variables not bound by a lambda
abstraction.
– They are "free" to take values from the surrounding
context.
– Essential concept in lambda calculus.
 Example:
 (λx. x + y) z
 z is a free variable because it's not bound within a lambda
expression.
 Its value depends on the context in which the lambda expression
is applied.
 ‘y’ is also a free variable
• Bound Variables: Variables explicitly defined
within a lambda abstraction.
– They are confined to the scope of that lambda
expression.
– Play a critical role in defining the behavior of lambda
expressions.
 Example:
 (λx. x + y) z
 x is a bound variable because it's defined within the lambda
expression (λx. ...).
 Its scope is limited to this expression.
 Another Example
• TeamAverageRating = λteamName. (λratings.
SUM(ratings) / COUNT(ratings))

– Here, ‘teamName’ is introduced by λ (lambda) and is not quantified within the

inner lambda abstraction. It represents a parameter that can vary depending on
the specific team name you provide when you apply the lambda expression.

– ‘ratings’ is a bound variable within the inner lambda abstraction because it follows
λ and is explicitly defined within that abstraction. It represents the list of ratings,
and its scope is limited to the inner lambda expression.
 Capturing Variables
• Variables may be captured by enclosing lambda
abstractions.
• Understanding variable capture is crucial for
avoiding unexpected behavior.
• Occurs when a variable from an outer scope is
used within an inner scope.
– Example:
 (λx. x + y)(λy. y + 1)
 The inner y is bound by the outer lambda abstraction.
 This demonstrates variable capture in action.
 Example
• Consider Outer = λx. (λy. x + y)
• In this expression:
– The outer lambda abstraction binds the variable "x."
– The inner lambda abstraction defines the variable "y" and uses "x" as a free
variable.
• applying this lambda expression with arguments:
– (Outer 3) 5
– First, we apply the outer lambda expression to the argument 3. This substitutes "x"
with 3 within the inner lambda expression.
• (λx. (λy. x + y) 3) 5
– Next, we apply the inner lambda expression to the argument 5. However, this is
where capturing occurs because "x" is a free variable within the inner expression.
• (λy. 3 + y) 5
– The inner lambda expression calculates the sum of "x" (which is 3) and "y" (which is
5) and returns 8.
• 3+5=8
 Alpha Conversion
• Alpha Conversion: Renaming variables to
prevent naming conflicts.
• Ensures clarity and independence of variables.
• A common practice to maintain well-formed
lambda expressions.
– Example:
 (λx. x + y) z can be rewritten as (λa. a + y) z.
 Prevents confusion between the bound variable x
and the free variable z.
 Beta Reduction
• It is an operation to simplify or evaluate lambda
expressions by replacing bound variables with
the argument they are applied to. For example,

– Add = λx. λy. x + y

– (Add 3) 5 , becomes
• λy. 3 + y
• 5 , then next step it is reduced to
– 3 + 5, and then the sum finally
» 8
Re-visiting the Automata & TM
 Automata block diagram

Finite Automata Pushdown Automata

Turing Machine
 Transition functions
• FA
• Q: Set of states.
• Σ: Input alphabet.
• δ(q, a) = p, where q is the current state, a is the input symbol, and p is the next state.
• F: Set of final states.
• q0: Start state.

• PDA
• Q: Set of states.
• F: Set of final states.
• q0: Start state.
• Σ: Input alphabet.
• Γ: Stack alphabet.
• Δ: Transition function.
• δ(q, a, X) = (p, α), where q is the current state, a is the input symbol, X is the symbol at the
top of the stack, p is the next state, and α represents the stack operation (push, pop, or no
change).
 Transition function
• TM
• Q: Set of states.
• Σ: Input alphabet.
• Γ: Tape alphabet.
• δ(q, a) = (p, b, D), where q is the current state, a is the
symbol being read, p is the next state, b is the symbol
to be written, and D represents the direction of the
head movement (L for left, R for right, or S for stay)
• q0: initial state
• B: Blank symbol on tape
• F: Set of final states
 Movement on Tape
• Finite Automata (FA):
– Movement of Head: Finite automata do not have a read/write head that moves along the input
tape because they operate on finite input strings. Instead, they transition between states based on
the current input symbol.
– Movement Characteristics: No head movement; state transitions are based solely on the input
symbol.
– Direction: N/A (No head movement).

• Pushdown Automata (PDA):

– Movement of Head: Pushdown automata do have a read/write head (in the form of a stack), but it
doesn't move along the input string.
– Movement Characteristics: The PDA's stack head can push symbols onto the stack or pop symbols
from the stack as it processes the input string.
– Direction: Upward (pushing symbols onto the stack) or downward (popping symbols from the
stack).

• Turing Machine (TM):

– Movement of Head: Turing machines have a read/write head that moves along an infinite tape.
– Movement Characteristics: The tape head can both read and write symbols on the tape, and it can
move left or right.
– Direction: Left or right, or stay in the same position (if no head movement is needed).
 Turing Machine example
Write a TM for a^nb^nc^n
δ(q0, x) = δ(q1, x, R) δ(q3, x) = δ(q3, x, L)
δ(q1, x) = δ(q1, x, R)
δ(q1, y) = δ(q2, y, R) δ(q3, x) = δ(q0, x, R)
δ(q2, y) = δ(q2, y, R)
δ(q2, z) = δ(q3, z, R) δ(q2, y) = δ(q4, y, R)
δ(q4, y) = δ(q4, y, R)
δ(q3, z) = δ(q3, z, L) δ(q4, z) = δ(q4, z, R)
δ(q3, z) = δ(q3, z, L)
δ(q3, y) = δ(q3, y, L) δ(q4, X) = (q5, X, R)
δ(q3, y) = δ(q3, y, L)
 Equivalent Lambda equations
The lambda function equivalent to previous problem may be stated as below:

TuringMachine = λx. (ApplyRules StartState x)

ApplyRules = λstate. λtape. (

IF (IsEmpty tape) THEN
(IF (IsAcceptState state) THEN 'Accept' ELSE 'Reject')
ELSE
(IF (IsTransitionDefined state (Read tape)) THEN
(ApplyRules (NextState state (Read tape)) (WriteOnTape tape (ReplaceWith
state (Read tape))) (MoveTape tape (MoveDirection state (Read tape))))
ELSE 'Reject')
)
)

The lambda function stated here is a complex function but implements the same logic. We have stated
this example only for your understanding of equivalence.
 Type Theory
• A systematic way of classifying and reasoning
about the structure and behavior of data
within computer programs.
• A formal System to deals with the study of
data types
• A fundamental in programming language
design and formal methods for verification
and ensuring correctness of program
 Key components:
• Data Types: defines a set of data types, such as integers,
booleans, characters, lists, and user-defined types like records
and classes.
• Type Checking: ensure that operations and functions are
applied to operands of appropriate types.
• Type Inference: the types of expressions are determined
automatically by the compiler, relieving programmers from
specifying types explicitly.
• Polymorphism: supports polymorphism, which allows a single
function or operation to work with values of multiple types.
• Type Soundness: ensures that well-typed programs do not
produce unexpected behavior.
 Example
• If we attempt to add a string • // Example Java code
public class TypeExample {
to an integer (num1 + text), public static void main(String[] args)
it would result in a type {
error. int num1 = 5;
int num2 = 3;
• Type theory helps prevent String text = "Hello, World!";
such errors, and it's
// This line would cause a type error
particularly crucial in in Java:
statically-typed languages // int result = num1 + text;

like Java, which require int sum = num1 + num2;

explicit type declarations. System.out.println("Sum: " + sum);
}
}
 Operational semantics
• formal description of program execution

• Defines how the program's state changes during its

execution.

• defines the meaning of a program by specifying how

individual statements or expressions affect the program's
state.

• can be defined using various approaches, including small-

step semantics and big-step semantics.
 Example
Consider the below scenario where different
constructs of a program are described below:
• Syntax:
– Variables: x, y
– Statements: Assignment (x = expr) and Expression
(expr)
• Operational Semantics Rules:
– Assignment Rule: x = E1 executes to E2 if E1 evaluates
to a value v, where E2 is the remaining program.
– Evaluation Rule: If E1 is an expression, it evaluates to v.
 Big-step operational semantics
• defining the meaning of an entire program in a single step, instead of breaking
down the program into small steps.

• focuses on the overall evaluation and result of the program.

• define how a program evaluates to a final value or state, and this evaluation
happens in one big step.

• It is used to reason about the overall behavior and correctness of programs.

• provides a clear and concise way to describe program evaluation and the final
result of a program without analyzing individual execution steps.

• also known as natural semantics

 Small-step operational semantics
• also known as structural operational semantics

• formal method used to describe the semantics of a programming language

by breaking down the execution of a program into individual, small steps or
transitions

• focuses on how a program evolves from one configuration to another

through a series of reduction steps

• the execution of a program is divided into tiny computational steps, and the
rules define how these steps occur

• useful for understanding the inner workings of a program and for reasoning
about its behavior
 Use of operational semantics
• Formal Language Semantics :how programs should be executed, enabling a
clear and unambiguous interpretation of code.

• Program Verification: prove the correctness of programs and verify that

they meet certain specifications

• Compiler Design: helps in specifying the transformation of high-level source

code into low-level machine code or intermediate representations

• Code Optimization: By understanding how programs execute, compilers can

apply various optimization techniques to improve program efficiency

• Language Implementation: operational semantics guides the creation of

interpreters and compilers
 Continued…
• Debugging: can be used to understand the inner workings of programs and to
debug them

• Understanding Language Constructs: explaining the behavior of specific language

constructs, control flow, and data manipulation

• Teaching and Education: helps students understand the semantics of

programming languages and how code execution works

• Proof of Properties: Operational semantics allows for reasoning about program

properties

• Program Analysis: It is used for program analysis, including static analysis and
model checking, to identify potential issues and analyze program behavior
without running the program
 Definition- Basic Type System
• defines a set of primitive data types and the rules for
type checking and type inference in a programming
language or formal system.

• It serves as the fundamental building block for more

complex type systems used in programming
languages

• it provides the foundation for ensuring type safety,

data integrity, and consistency in a software program
 Basic type system
•
Here, the ⊢ can be read to mean “the following statement is true”

• Γ is called “the context” or “the type environment”

• some of the typing rules for our type system:

• horizontal bar over each of these rules with nothing on top means that they are always true,
which makes them axioms

• similar axioms for integer literals:

 Continued…
• rules for expressions that have sub-
expressions
 Key characteristics -basic type system
• Primitive Types: It defines a set of primitive or basic data types that serve as
the simplest units of data in a language. Common primitive types might
include integers, booleans, characters, and floating-point numbers.

• Type Constructors: Basic type systems often include type constructors that
allow the creation of more complex types from simpler ones. For example,
lists, tuples, records, and functions can be constructed from basic types.

• Type Assignment: It specifies how types are assigned to variables, constants,

and expressions. Type assignment rules ensure that variables are given
appropriate types and that operations between types are well-defined.

• Type Compatibility: Basic type systems define rules for determining whether
two types are compatible, which is crucial for ensuring that operations and
assignments are valid.
 continued
• Type Inference: It may provide a simple type inference mechanism to deduce
the types of expressions without explicitly specifying them. Type inference can
simplify programming by reducing the need for explicit type annotations.

• Type Checking: The basic type system includes type checking rules to verify that
programs adhere to type constraints. Type checking helps detect type errors and
ensures that programs are type-safe.

• Type Compatibility Rules: It establishes compatibility rules for type conversions

or promotions. These rules dictate how one type can be converted or promoted
to another type.

• Type Safety: Basic type systems aim to ensure type safety by preventing
operations that could lead to type errors or memory corruption. This involves
checking operations and ensuring that they are consistent with the types of the
operands.
 Continued..
• Type Equivalence: Basic type systems define when two types are considered
equivalent or compatible. For example, in some languages, user-defined types may
be equivalent if they have the same structure.

• Type Hierarchy: In some type systems, a basic hierarchy of types is established,

with more specific types inheriting properties from more general types. This allows
for subtyping and polymorphism.
 Type soundness
• It is fundamental concept in programming language theory that ensures the safety
and correctness of programs with respect to their types.

• It guarantees that if a program is well-typed, meaning it adheres to the type rules

and constraints defined by the programming language, then it will not produce
certain kinds of runtime errors, such as type errors, during its execution

• is a critical property of programming languages and type systems, as it provides a

high level of confidence in the correctness and safety of software

• It allows developers to catch many common programming errors at compile-time

rather than at runtime, leading to more robust and reliable software systems.

• Programming languages with strong type systems, such as Haskell, and Rust, aim for
strong type soundness as a key design goal.
 Key properties
Type soundness is typically expressed in three main properties:

• Type Safety: Type safety ensures that every well-typed program does not cause type
errors during execution. This means that operations and expressions involving data are
guaranteed to be consistent with the types of the data, preventing type-related errors
such as adding a string to an integer or accessing an undefined variable.

• Progress: Progress, also known as the "no stuck state" property, guarantees that a well-
typed program will not get stuck or reach an undefined state during its execution. It
ensures that there is always a next step or reduction that can be taken in the program's
execution.

• Preservation (or Preservation of Typing): Preservation, or the preservation of typing

property, guarantees that if a program takes a step (i.e., an evaluation or reduction
step), the result of that step will also be well-typed. In other words, well-typed
programs will maintain their type properties as they execute.
 Advanced Type System
• Advanced type systems are extensions of basic type systems in programming
languages.

• They introduce more sophisticated and expressive features.

• These features provide finer control over types and support additional
abstractions.

• Advanced type systems enable powerful static analysis and offer stronger
guarantees about program correctness and safety.

• Their primary goal is to detect a broader range of errors during compilation.

• This leads to the creation of more reliable and maintainable code.

 Key features
• Polymorphism: Advanced type systems often include support for polymorphism,
allowing the same code to work with different types. There are several forms of
polymorphism, including parametric polymorphism (generics), ad-hoc polymorphism
(operator overloading), and subtype polymorphism (inheritance).

• Type Inference: Advanced type systems can perform more sophisticated type
inference, deducing the types of expressions and variables automatically. This
reduces the need for explicit type annotations and makes code more concise.

• User-Defined Types: These type systems allow developers to define their own
custom data types, which can be highly expressive and domain-specific. Examples
include algebraic data types, records, and abstract data types.

• Union and Intersection Types: Advanced type systems can handle union types (types
that can represent multiple possibilities) and intersection types (types that require
both of their constituents). These types enhance expressiveness and precision.
 Continued…
• Dependent Types: Dependent types allow types to depend on values, enabling strong
guarantees about the behavior of programs. They are often used in theorem provers and
formal verification.

• Type Constraints: Type constraints or type classes enable ad-hoc polymorphism, allowing
developers to define type-specific behaviors and operations for their custom types.

• Refinement Types: Refinement types add constraints to existing types, allowing

developers to express precise invariants and properties about data.

• Type Annotations: While advanced type systems often support type inference, they also
allow developers to provide explicit type annotations when needed.

• Type System Extensions: Advanced type systems might include extensions such as row
polymorphism, type-level programming, type-level functions, and more, further
enhancing expressiveness and precision.
Example – Advance type inference
• In this code a recursive function, factorial,
takes an integer n as input and returns an
integer as the result.
 factorial 0 = 1
 factorial n = n * factorial (n - 1)

• Let see next, that how the system may

implement type inference
 For example
• Pattern Matching: The function is defined using pattern matching. It specifies two
cases: one where n is 0, in which case the result is 1, and another for all other
values of n.
• Type Inference: Haskell's type inference system analyzes the code to deduce the
types of the expressions and variables.
• Type Deduction:
– The type inference system deduces that n is an integer (Int) because it's used in numeric
operations (* and -).
– It deduces that 1 is also an integer because it's the base case result.
– The factorial function is determined to have the type factorial :: Int -> Int, meaning it takes
an integer as input and returns an integer as output.
• Automatic Type Annotations: While the programmer did not provide explicit type
annotations, the type inference system automatically determines and associates
types with the expressions and the function.
• Type Safety: Thanks to advanced type inference, the compiler ensures that the
function is used consistently with integers, preventing type-related errors.