UNIVERSIDAD NACIONAL

“SANTIAGO ANTÚNEZ DE MAYOLO”

FACULTAD DE CIENCIAS

ESCUELA ACADÉMICO-PROFESIONAL
INGENIERÍA DE SISTEMAS E INFORMÁTICA

TEMA:
EL CÁLCULO LAMBA

TEORIA DE LENGUAJE
PRESENTADO POR:
1. APONTE CLINTON
2. CHAVEZ ALVARASO SHUBERT
3. RAMIREZ NORABUENA JHON
4. HUAMAN LEANDRO NEDER
5. LOPEZ WILDER
6. OBREGÓN RICHARD FIGUEROA
7. RODRIGUEZ OSORIO ROSALIA FABIOLA

ASESOR:
Ing. Silva Zapata Miguel Ángel
HUARAZ - PERU
 PRESENTACIÓN

Ante todo tenga nuestro cordial saludo en esta oportunidad tenemos el agrado de
presentarle nuestro trabajo que será entendible sobre “El Cálculo Lamba”.

2
 ÍNDICE

PRESENTACIÓN ................................................................................................................... 2
ÍNDICE .................................................................................................................................... 3
EL CÁLCULO LAMBA .......................................................................................................... 4
1. HISTORIA.................................................................................................................... 4
2. EL CÁLCULO LAMBA ............................................................................................... 4
3. CÁLCULO LAMBDA Y LOS LENGUAJES DE PROGRAMACIÓN ......................... 5
3.1 EJEMPLOS :........................................................................................................ 5
4. CARACTERÍSTICAS .................................................................................................. 7
5. SINTAXIS DEL CALCULO LAMBDA ........................................................................ 7
6. VARIABLES LIBRES Y LIGADAS............................................................................. 8
7. REGLAS DEL CÁLCULO LAMBA ............................................................................ 9
1) α-CONVERSIÓN ................................................................................................... 10
2) β-REDUCCIÓN ...................................................................................................... 10
3) ƞ-CONVERSIÓN ................................................................................................... 11
8. APLICACIÓN PRÁCTICA ........................................................................................ 12
CONCLUSIÓN...................................................................................................................... 14
BIBLIOGRAFÍA .................................................................................................................... 15

3
 EL CÁLCULO LAMBA
1. HISTORIA
Fue introducido en los 30's por Alonzo Church y Stephen Kleene con el
objetivo de dar una teoría general de las funciones es un sistema formal
diseñado para definir funciones, la forma de utilizarlas y la recursión. El
cálculo lambda influye en lenguajes funcionales como Lisp, Haskell y ML.
Es utilizado como un fundamento de lenguajes deprogramación porque
aporta una sintaxis básica de programación, la semántica para el concepto
e función en la transformación de argumentos en resultados y una forma de
definir primitivas de programación.Originalmente, Church había tratado de
construir un sistema formal completo para modelizar la matemática;pero en
1934 Kleene and Rosser publicaron una implementación de la paradoja de
Richard.Desde ese punto, el cálculo lambda fue usado para estudiar la
computabilidad, culminando en la respuesta negativa al problema de la
parada. En 1940, Church introdujo el Cálculo Lambda simplemente tipado
que es computacionalmente menos poderoso, pero lógicamente consistente

2. EL CÁLCULO LAMBA
El cálculo lambda es un sistema formal diseñado para investigar la
definición de función, la noción de aplicación de funciones y la recursión.
Se puede considerar al cálculo lambda como el languaje universal de
programación más pequeño. Consiste en una regla de transformación
simple (sustitución de variables) y un esquema simple para definir
funciones.
El cálculo lambda es universal porque cualquier función computable puede
ser expresada y evaluada a través de él. Por lo tanto, es equivalente a las
máquinas de Turing. Sin embargo, el cálculo lambda no hace énfasis en el
uso de reglas de transformación y no considera las máquinas reales que
pueden implementarlo. Se trata de una propuesta más cercana al software
que al hardware.

4
3. CÁLCULO LAMBDA Y LOS LENGUAJES DE PROGRAMACIÓN
Como lo menciona Peter Landin en su libro clásico Correspondencia entre
ALGOL 60 y el cálculo lambda de Church, la mayoría de los lenguajes de
programación tienen sus raíces en el cálculo lambda, lo que provee los
mecanismos básicos para las abstracciones de procedimiento y
abstracciones de aplicaciones (subprogramas).

La implementación del cálculo lambda en una computadora involucra tratar

a las "funciones" como objetos de primera clase, lo que aumenta la
complejidad de su implementación. Un problema particularmente difícil es la
implementación de funciones de orden superior, conocido como el problema
de Funarg.

Las contrapartes más prominentes del cálculo lambda en programación son

los lenguajes de programación funcional, que esencialmente implementa el
cálculo aumentado con algunas constantes y tipos de dato.

Los lenguajes funcionales no son los únicos que soportan las funciones
como objetos de primera clase. Muchos lenguajes de programación
imperativa, como Pascal, hace tiempo que permiten pasar subprogramas
como argumentos a otros subprogramas. En C y su derivado C++ el
resultado equivalente se obtiene pasando punteros al código de las
funciones (subprogramas). Estos mecanismos están limitados a
subprogramas escritos explícitamente en el código, y no soportan
directamente funciones de alto nivel. Algunos lenguajes imperativos
orientados a objetos, tiene notaciones que representan funciones de
cualquier orden; tales mecanismos están disponibles en C++, Smalltalk y
más recientemente en ("agentes" de ) Eiffel y ("delegados" de) C#.

3.1 EJEMPLOS :
Como ejemplo, la expresión de "agente en línea" de Eiffel :

agent (x: REAL): REAL do Result := x * x end

5
 denota un objeto correspondiente a la expresión lambda λ x. x*x (con
llamada por valor). Puede ser tratada como cualquier otra expresión, por
ejemplo, asignarla a una variable o pasada a una rutina. Si el valor de
square es el de la expresión de agente anterior, entonces el resultado de
aplicar square a un valor (una reducción β) es expresada como
square.item ([a]), donde el argumento es pasado como una tupla.

Un ejemplo en Python usa la forma lambda de funciones:

func = lambda x: x * x

Lo anterior crea una función anónima llamada func que puede ser pasada
como parámetros a otras funciones, ser almacenada en variables, etc.
Python también puede tratar cualquier otra función creada con la
sentencia estándar def como un first-class object.

Lo mismo se aplica a la siguiente expresión en Smalltalk:

[ :x | x * x ]

Este es un objeto de primera clase (clausura de bloque), que puede ser

guardado en variables, pasado como argumento, etc.

Un ejemplo similar en C++ (usando la biblioteca Boost.Lambda):

for_each(v.begin(), v.end(), cout << _1 * _1 << endl;);

Aquí, la función de librería estándar for_each itera sobre todos los

miembros del vector (o lista) v, e imprime el cuadrado de cada elemento.
La notación _1 es la convención Boost de Lambda para representar el
elemento contenedor, representado como x en cualquier otro lado.

Un delegado simple de c# que toma una variable y retorna el cuadrado.

Esta variable función puede ser pasada a otros métodos (o delegados de
funciones)

6
 // Declare a delegate signature
delegate double MathDelegate (double i);

// Create an delegate instance

MathDelegate f = delegate (double i) { return Math.Pow (i, 2);
};

// Passing 'f' function variable to another method, executing,

// and returning the result of the function
double Execute (MathDelegate func)
{
return func(100);
}

4. CARACTERÍSTICAS
El cálculo lambda ha sido empleado como fundamento conceptual de los
lenguajes de programación, aportando:

 una sintaxis básica

 una semántica para el concepto de función como proceso de
transformación de argumentos en resultados
 un medio para definir primitivas de programación

5. SINTAXIS DEL CALCULO LAMBDA

En el cálculo lambda, una expresión o términose define recursivamente a
través de las siguientes reglas de formación:

1. Toda variable es un término: x, y, z, u, v, w, x, y

2. Si t es un término y x es una variable, entonces (λx.t) es un término
(llamado una abstracción lambda).
3. Si t y s son términos, entonces (ts) es un término (llamado una
aplicación lambda).
4. Nada más es un término. Según estas reglas de formación, las
siguientes cadenas de caracteres son términos:
7
 Según estas reglas de formación, las siguientes cadenas de caracteres son
términos:

(xy)

(((xz)y)x)

(λx.x)

(( λx.x)y)

(λz.(λx.y))

((x(λz.z))z)

Por convención se suelen omitir los paréntesis externos, ya que no cumplen

ninguna función de desambiguación. Por ejemplo se escribe (λz.z)z en vez
de

((λz.z)z), y se escribe x(y(zx)) en vez de (x(y(zx))). Además se suele adoptar

la convención de que la aplicación de funciones es asociativa hacia la
izquierda. Esto quiere decir, por ejemplo, que xyzz debe entenderse como
(((xy)z)z), y que (λz.z)yzx debe entenderse como ((((λz.z)y)z)x).

Las primeras dos reglas generan funciones, mientras que la última describe
la aplicación de una función a un argumento. Una abstracción lambda λx.t
representa una función anónima que toma un único argumento, y se dice
que el signo λ liga la variable x en el término t. En cambio, una aplicación
lambda ts representa la aplicación de un argumento s a una función t. Por
ejemplo, λx.x representa la Función Identidad x → x, y(λx.x)y representa la
función identidad aplicada a y<tt>. Luego, <tt>λx.y representa la función
constante x → y, que devuelve y sin importar qué argumento se le dé.

6. VARIABLES LIBRES Y LIGADAS

Las apariciones (ocurrencias) de variables en una expresión son de tres
tipos:

8
 1. Ocurrencias de ligadura (binders)
2. Ocurrencias ligadas (bound occurrences)
3. Ocurrencias libres (free occurrences)

Las variables de ligadura son aquellas que están entre el Λ y el punto. Por
ejemplo, siendo E una expresión lambda:

(λ x y z.E) Los binders son x,y y z.

El binding de ocurrencias de una variable está definido recursivamente

sobre la estructura de las expresiones lambda, de esta manera:

1. En expresiones de la forma V, donde V es una variable,V es una

ocurrencia libre.
2. En expresiones de la forma λV.E, las ocurrencias son libres en E
salvo aquellas de V . En este caso las V En E se dicen ligadas por el λ
antes V.
3. En expresiones de la forma (E E′ ), las ocurrencias libres son aquellas
ocurrencias de E y E′ .

Expresiones lambda tales como λx.(xy) no definen funciones porque las

ocurrencias de y están libres. Si la expresión no tiene variables libres, se
dice que es cerrada.

Como se permite la repetición del identificador de variables, cada binding

tiene una zona de alcance asociada (scope de ahora en adelante) Un
ejemplo típico es:(λx.x(λx.x))x, donde el scope del binding más a la derecha
afecta sólo a la x que tiene ahí, la situación del otro binding es análoga,
pero no incluye el scope de la primera. Por último la x más a la derecha
está libre. Por lo tanto, esa expresión puede reexpresarse así (λy.y(λz.z))x.

7. REGLAS DEL CÁLCULO LAMBA

9
1) α-CONVERSIÓN
La regla de alfa-conversión fue pensada para expresar la idea siguiente:
los nombres de las variables ligadas no son importantes.

Por ejemplo λx.x y λy.y son la misma función. Sin embargo, esta regla
no es tan simple como parece a primera vista. Hay algunas
restricciones que hay que cumplir antes de cambiar el nombre de una
variable por otra. Por ejemplo, si reemplazamos x por y en
λx.λy.x,obtenemos λy.λy.y, que claramente, no es la misma función.
Este fenómemo se conoce como captura de variables

La regla de alfa-conversión establece que si V y W son variables, E es

una expresión lambda, y

E[V := W]

representa la expresión E con todas las ocurrencias libres de V en E

reemplazadas con W , entonces

λV. E ==λW. E[V := W]

si W no está libre en E y W no está ligada a un λ donde se haya

reemplazado a V. Esta regla nos dice, por ejemplo, que λx .(λx .x )x es
equivalente a λy(λx .x )y.

En un ejemplo de otro tipo, se ve que

for (int i = 0; i < max; i++) { proc (i); }

es equivalente a

for (int j = 0; j < max; j++) { proc (j); }

2) β-REDUCCIÓN
La regla de beta reducción expresa la idea de la aplicación funcional.
Enuncia que
10
 ((λV. E)E′ ) == E[V :=E′ ]

si todas las ocurrencias de E′ están libres en E[V :=E′ ]

Una expresión de la forma ((λV .E )E′ ) es llamada un beta redex. Una

lambda expresión que no admite ninguna beta reducción se dice que
está en su forma normal. No toda expresión lambda tiene forma normal,
pero si existe, es única. Más aún, existe un algoritmo para computar la
formal normal: la reducción de orden normal. La ejecución de este
algoritmo termina si y sólo si la expresión lambda tiene forma normal. El
Teorema de Church-Rosser nos dice que dos expresiones reducen a
una misma si y sólo si son equivalentes (salvo por el nombre de sus
variables ligadas)

3) ƞ-CONVERSIÓN
Es la tercer regla, eta conversión, que podría ser añadida a las dos
anteriores para formar una nueva relación de equivalencia. La eta
conversión expresa la idea de extensionalidad, que en este contexto
implica que dos funciones son la misma si y solo si dan el mismo
resultado para cualquier argumento. La eta conversión convierte entre
λx.fx y f siempre que x no aparezca sola en f.Esto puede ser entendido
como equivalente a la extensionalidad así:

Si f y g son extensionalmente equivalentes, es decir, si f a==g a para

cualquier expresión lambda a entonces, en particular tomando a como
una variable x que no aparece sola en f ni en g , tenemos que f x==gx y
por tanto λ x .f x ==λ x g x , y así por eta conversión f ==g. Entonces, si
aceptamos la eta conversión como válida, resulta que la
extensionalidad es válida Inversamente, si aceptamos la
extensionalidad como válida entonces, dado que por beta reducción de
todo y tenemos que (λx .f x )y ==fy, resulta que λx .f x ==f; es decir,
descubrimos que la eta conversión es válida.

11
8. APLICACIÓN PRÁCTICA

A) Características:

 Escrito en html5
 Diseño adaptable
 Utiliza java script
 Se hace uso de la librería “lambda-min.js” escrita por el profesor Carl
Burch disponible en:http://www.cburch.com/

B) Funcionamiento:

Esta aplicación resuelve ejercicios del tipo numérico simplificando las

expresiones para obtener el resultado buscado

Si por ejemplo se desea calcular la expresión:

(λy.4 × y) ((λz.z² + 2 × z) 5)

Esta debe escribirse de la siguiente manera:

(\y.* 4 y) ((\z.+ (* z z ) (* 2 z)) 5)

El resultado esperado seria:

12
Como se observa el desarrollo se da paso por paso simplificando las
expresiones y reemplazando por los valores esperados Los operadores
soportados son:

+, -, *, /

dados dos números enteros , se aplican la operación aritmética a ellos

=, /=, <, >, <=, >=

dados dos números enteros , se aplican la comparación para llegar al

identificador de verdadero o falso.

If

dado tres valores de los cuales el primero es verdadero o falso , devuelva

el segundo valor si la primera es verdadera y la tercera si la primera es
falsa

13
 CONCLUSIÓN
El cálculo lambda es un sistema formal diseñado para investigar la definición de
función, la noción de aplicación de funciones , la recursión y computacionalmente
equivalente en poder a muchos otros modelos plausibles para el cómputo
(máquinas de Turing incluidas); es decir, cualquier cálculo que se pueda lograr en
cualesquiera de estos otros modelos se puede expresar en el cálculo lambda y
viceversa. Según la tesis de Church-Turing, ambos modelos pueden expresar
cualquier cómputo posible.

Quizás parezca sorprendente que el cálculo lambda pueda representar cualquier

cómputo concebible usando solamente las nociones simples de abstracción
funcional y aplicación basado en la substitución textual simple de términos por
variables. Pero aún más notable es que incluso la abstracción no es requerible: la
lógica combinatoria es un modelo del cómputo equivalente al cálculo lambda, pero
sin la abstracción.

14
BIBLIOGRAFÍA

15