Língua Natural EXERCÍCIOS RESOLVIDOS

Documentos relacionados
Cálculo Lambda Sem Tipos

Programação Funcional - Introdução a Cálculo Lambda

Módulo I: λ-calculus. MCC - 2 o ano. Departamento de Informática Universidade do Minho. Módulo I: λ-calculus 0. 2 o semestre

Minicurso 1 Uma introdução ao cálculo lambda e a linguagens de programação funcionais

Módulo II: Implementação do λ-calculus

Apontamentos de matemática 6.º ano Decomposição de um número em fatores primos

Centro Universitário do Triângulo

Fundamentos de Cálculo Lambda

Nelma Moreira. Departamento de Ciência de Computadores da FCUP. Aula 17

Actividade Formativa 1

Funções Recursivas. Prof.: Edson Holanda Teoria da computação - Diverio e Menezes

ALGORITMOS E LÓGICA DE PROGRAMAÇÃO PRÉ AULA DIAGNÓSTICO 22/10/2015. Analise o algoritmo a seguir e depois assinale a alternativa correspondente:

Métodos Numéricos - Notas de Aula

GABARITO PROVA P2 CALCULO 2 2/2017. (Em cada questão não é necessário reproduzir cálculos feitos em questão anterior) Questão 1 (1,5 ponto).

Formação Continuada Nova Eja. Plano de Ação II INTRODUÇÃO

Nelma Moreira. Departamento de Ciência de Computadores da FCUP. Aula 20

Análise de Algoritmos Estrutura de Dados II

Fundamentos de Programação

Prova. t ::= t t. t 1 t 4 t 2 t 3 (t 1 t 2 ) (t 3 t 4 ) (t 2 t 1 ) (t 4 t 3 )

semana 03/05/2014 a 09/05/2014 semana 10/05/2014 a 16/05/2014 semana 17/05/2014 a 23/05/ e 25/05/2014

Utilização do Conjunto de Cantor para a resolução da Torre de Hanoi

ALGORITMOS E ESTRUTURA DE DADOS

Introdução à Programação Funcional

Redução de grafos. Pedro Vasconcelos. 4 de Março de 2014

Fluxogramas e variáveis

30 de setembro de 2015

216 e) 10 1 = 10 f) (-0,4) 0 = 1 g) (-4,3) 1 = - 4,3

META-MODELO FUNCIONAL PARA RECUPERAÇÃO DE INFORMAÇÃO



Elementos de Matemática Finita

Circuitos Digitais Primeira Lista de Exercícios

Variável. Expressões. Atribuição. Tipos básicos Declaração. Aritméticas Lógicas. Professor Leandro Augusto Frata Fernandes

Working 03 : Conceitos Básicos II

Introdução à Lógica de Programação

Unidade 5: Introdução à Programação com Python Prof. Daniel Caetano

Agenda do Dia Aula 14 (19/10/15) Sistemas Lineares: Introdução Classificação

Primeira Prova de Linguagens de Programação - DCC024 -

ESTRUTURA DE DADOS. Aula 2 Conceitos Básicos da Linguagem Java Professor MSc. Ariel da Silva Dias Complexo Educacional FMU

Aula 4B. Lógica e Algoritmos. Profª. Fabiany

Introdução aos Algoritmos

Arquitetura de Computadores

Aritmética Binária e Complemento a Base. Introdução ao Computador 2010/1 Renan Manola

Representação de Arranjos

INFORMÁTICA APLICADA AULA 05 LINGUAGEM DE PROGRAMAÇÃO C++

Introdução ao cálculo-λ

Introdução aos Algoritmos

Unidade 2: Algoritmos e programação

Complexidade de Algoritmos. Edson Prestes

Métodos iterativos dão-nos uma valor aproximado para s. Sequência de valores de x que convergem para s.

PORTAS E OPERAÇÕES LÓGICAS

6 Matrizes. Matrizes. Aluno Matemática Eletricidade Básica Desenho Técnico A B C D 3 7 4

Teoria da Computação I

Cálculo Numérico BCC760

EBS DA GRACIOSA - ENSINO BÁSICO 7.º ANO

Ficha de Avaliação Sumativa. Notas Gerais:

Aritmética em Bases Não Decimais

Os Problemas de Optimização Combinatória e a Teoria da Complexidade

αx + 2y + (α + 1)z + 2αw = β 1. [40 pontos] Discuta o sistema em função dos parâmetros α, β e γ.

01/08/2011. Tipos de dados Numéricos Alfanuméricos Lógicos. Numéricos. Tipos de dados. Dados Numéricos Inteiros. Dados Numéricos Reais.

Aula prática 5. Funções Recursivas

Fundamentos de Programação

Programação Funcional Cálculo Lambda - Aula Nº 3

AULA 8- ÁLGEBRA MATRICIAL VERSÃO: OUTUBRO DE 2016

Programação de Computadores III

Working 03 : Conceitos Básicos II

Teoria dos Grafos AULA

05/11/2018. Linguagem de Programação e Estruturada

Sistemas Digitais I LESI :: 2º ano

Agrupamento de Escolas Diogo Cão. Nome : N.º Turma : Ficha Informativa - Matemática - 7º Ano

Linguagens de Programação Programação Funcional (Haskell)

CENTRO DE CIÊNCIAS EXATAS, AMBIENTAIS E DE TECNOLOGIAS FACULDADE DE ENGENHARIA DE PRODUÇÃO CURSO DE ENGENHARIA DE PRODUÇÃO Currículo Atual MATUTINO

Cálculo Numérico / Métodos Numéricos. Solução de equações polinomiais Briot-Ruffini-Horner

Linguagem Computacional

Resolução de Sistemas Lineares. Método de Gauss. O algoritimo conhecido como Método de Gauss é desenvolvido a partir de dois ingredientes básicos:

Conceitos Básicos Linguagem C

Função de 2º Grau. Parábola: formas geométricas no cotidiano

Engenharia Civil. Introdução à Programação

Algoritmos e Estruturas de Dados I

Métodos Numéricos. Turma CI-202-X. Josiney de Souza.

decomposição de Cholesky.

Aula 7: Portas Lógicas: AND, OR, NOT, XOR, NAND e NOR

Algoritmos Computacionais

Álgebra Booleana: Axiomas, Teoremas e Leis de De Morgan

IGUALDADES EM IR IDENTIDADES NOTÁVEIS

Universidade Estadual De Santa Cruz (UESC)

CURSO de NIVELAMENTO INTRODUÇÃO À PROGRAMAÇÃO

Programação de Computadores I. Professor Ilaim Costa Junior

Programação de Computadores:

TÉCNICO DE INFORMÁTICA - SISTEMAS

1 0 para todo x, multiplicando-se os dois membros por. 2x 1 0 x 1 2. b a x. ba 2. e b 2 c

Linguagem Computacional

Equações. João Marcos Ferreira

Podemos concluir que o surgimento do número fracionário veio da necessidade de representar quantidades menores que inteiros, por exemplo, 1 bolo é um

Fluxogramas. Vanessa Braganholo

P3 de Álgebra Linear I

MATEMÁTICA PROF. JOSÉ LUÍS FRAÇÕES

Linguagem de Programação JAVA. Técnico em Informática Professora Michelle Nery

CRÉDITOS DO CURSO. Carga Horária Créditos IN1030 Seminários 30 2

ESCOLA SUPERIOR DE TECNOLOGIA DE VISEU

Transcrição:

Mestrado em Engenharia Informática e de Computadores Língua Natural EXERCÍCIOS RESOLVIDOS (Linguagem Lambda) 3ª Edição Nuno Mamede Maio 2010 Departamento de Engenharia Informática Instituto Superior Técnico

PLF - Programação Funcional (Linguagem Lambda) - Exercícios resolvidos 2 Í NDICE ENUNCIADOS 3 SOLUÇÕES 7 Problema 1 - Substituição de variáveis...7 Problema 2 - Redução Beta...7 Problema 3 - Numerais (adição e multiplicação)...8 Problema 4 - Numerais (zero?)...9 Problema 5 - Condicional...10 Problema 6 - Cálculo combinatório (simplificação)...11 Problema 7 - Cálculo combinatório (simplificação)...11 Problema 8 - Combinador B...11 Problema 9 - Combinador F...11 Problema 10 - Combinador W...12 Problema 11 - Algoritmo de abstracção (combinadores M, T e B)...12 Problema 12 - Algoritmo de abstracção (λg.λy.g y y)...12 Problema 13 - Algoritmo de abstracção (factorial)...13 Problema 14 - Combinador de pontos fixos...13 Problema 15 - Cálculo de 6!...13 Problema 16 - Numerais (predecessor)...15

PLF - Programação Funcional (Linguagem Lambda) - Exercícios resolvidos 3 ENUNCIADOS Problema 1 - Substituição de variáveis Calcule as seguintes substituições de variáveis: (a) [λz.λy.(y z)/x] ((λu.x u)(u x)) (b) [λu.(y u)/x] (λy.(x y)) (c) [2/z] λy.(λx.x y z) λz.z y Problema 2 - Redução Beta Aplicando redução- simplifique os seguintes termos: (a) (λu.u u)(λu.u u) (b) (λy.(λz.w)y) ((λu.u u) (λu.u u)) (c) (λz.λy.λx.y(z x)) p q r (d) (λz.λy.λx.y z) (z y) (u x) y (e) (λx.λy.x (y y)) (λz.x (z z)) (λu.λv.u) w Problema 3 - Numerais (adição e multiplicação) Considere a seguinte representação em termos lambda dos numerais: 0 = λf.λx.x 1 = λf.λx.f x 2 = λf.λx.f (f x) n = λf.λx.(f n x) onde f n x exprime a aplicação de f a x exactamente n vezes. e a seguinte representação em termos lambda: mais = λn.λm.λf.λx.n f (m f x) vezes = λn.λm.λf.n (m f) Prove que: (a) mais 1 2 = 3 (b) vezes 1 1 = 1 (c) vezes 2 1 = 2 (d) vezes 3 2 = 6 Problema 4 - Numerais (zero?) Considere as representações apresentadas no Problema 3 e as seguintes: zero? = λx.x (λy.λz.falso) (λx.x) verd falso = λx.λy.y verd = λx.λy.x

PLF - Programação Funcional (Linguagem Lambda) - Exercícios resolvidos 4 Prove que: (a) zero? 3 = falso (b) zero? 2 = falso (c) zero? 1 = falso (d) zero? 0 = verd Problema 5 - Condicional Considere a seguinte representação em termos lambda: falso = λx.λy.y verd = λx.λy.x se = λx.x Prove que: (a) se verd 1 2 = 1 (b) se falso 1 2 = 2 Problema 6 - Cálculo combinatório (simplificação) Simplifique o máximo que puder a seguinte expressão: S (S (K S) (S (K K) K)) (K (S K K)) M N Problema 7 - Cálculo combinatório (simplificação) Simplifique o máximo que puder a seguinte expressão: S (B B S) (K K) M N O em que: B M N O -> M (N O) Problema 8 - Combinador B Sabendo que B M N O -> M (N O) mostre que o combinador E M N O P Q -> M N (O P Q) é equivalente a: B(B B B). Problema 9 - Combinador F Mostre que o combinador F M N O -> O N M é equivalente a: B(B(T(B B T)) (B B T)) (B B T) em que: B M N O -> M (N O) T M N -> N M Problema 10 - Combinador W Seja W o combinador com o seguinte esquema de redução: Prove que W = SS(KI) W M N -> M N N Problema 11 - Algoritmo de abstracção (combinadores M, T e B) Exprima em termos de S, K e I os seguintes combinadores: (a) M O -> O O (b) T M N -> N M (c) B M N O -> M (N O) Problema 12 - Algoritmo de abstracção (lg.ly.g y y) Elimine variáveis e abstracções no programa: λg.λy.g y y Confirme o resultado.

PLF - Programação Funcional (Linguagem Lambda) - Exercícios resolvidos 5 Problema 13 - Algoritmo de abstracção (factorial) Elimine variáveis e abstracções no programa: λx.se (zero? x) 1 (vezes x( f (pred x 1))) Problema 14 - Combinador de pontos fixos Mostre que o seguinte combinador é um determinante de pontos fixos: λf.(λg.λx.f (g g) x) (λg.λx.f (g g) x) Problema 15 - Cálculo de 6! Mostre que: Y (λf.λn.se (zero? n) 1 (vezes n (f (pred n)))) 3 = 6 Em que Y é o determinante de pontos fixos: Y = λf.(λx.f (x x)) (λx.f (x x))

PLF - Programação Funcional (Linguagem Lambda) - Exercícios resolvidos 6 Problema 16 - Numerais (predecessor) Considere as representações apresentadas no Problema 3 e que: pred = Y??????????? Em que Y é o determinante de pontos fixos: Y = λf.(λx.f (x x)) (λx.f (x x)) Prove que: (a) pred 3 = 2 (b) pred 2 = 1 (c) pred 1 = 0

PLF - Programação Funcional (Linguagem Lambda) - Exercícios resolvidos 7 SOLUÇÕES Problema 1 - Substituição de variáveis (a) [λz.λy.(y z)/x]((λu.x u)(u x)) = ([λz.λy.(y z)/x](λu.x u) [λz.λy.(y z)/x](u x)) = ([λz.λy.(y z)/x](λu.x u) ([λz.λy.(y z)/x]u [λz.λy.(y z)/x]x)) = ([λz.λy.(y z)/x](λu.x u) (u (λz.λy.(y z)))) = ((λu.[λz.λy.(y z)/x](x u) (u (λz.λy.(y z)))) = ((λu.([λz.λy.(y z)/x]x [λz.λy.(y z)/x]u) (u (λz.λy.(y z)))) = ((λu.(λz.λy.(y z)) u) (u (λz.λy.(y z)))) (b) [λu.(y u)/x] (λy.(x y)) = [λu.(y u)/x](λz.(x z)) = (λz.[λu.(y u)/x](x z)) = (λz.([λu.(y u)/x]x [λu.(y u)/x]z)) = (λz.((λu.(y u)) z)) (c) [2/z] λy.(λx.x y z) λz.z y = λy.[2/z]((λx.x y z) (λz.z y) = λy.[2/z](λx.x y z) [2/z](λz.z y) = λy.[2/z](λx.x y z) (λz.z y) = λy.(λx.[2/z]((x y) z)) (λz.z y) = λy.(λx.[2/z](x y) [2/z]z))(λz.z y) = λy.(λx.x y 2) (λz.z y) = λy.(λx.x y 2) λz.z y Problema 2 - Redução Beta (a) (λu.u u)(λu.u u) [λu.u u/u] (u u) = (λu.u u)(λu.u u) [λu.u u/u] (u u) = (λu.u u)(λu.u u) (λu.u u)(λu.u u) (b) (λy.(λz.w)y) ((λu.u u) (λu.u u)) [((λu.u u) (λu.u u))/y]((λz.w)y) = (λz.w) ((λu.u u) (λu.u u)) [((λu.u u) (λu.u u))/z] (w) = w (c) (λz.λy.λx.y(z x)) p q r [p/z](λy.λx.y(z x)) q r = (λy.λx.y (p x)) q r

PLF - Programação Funcional (Linguagem Lambda) - Exercícios resolvidos 8 [q/y](λx.y (p x)) r = (λx.q (p x)) r [r/x](q (p x)) = q (p r) (d) (λz.λy.λx.y z) (z y) (u x) y [(z y)/z](λy.λx.y z)) (u x) y = [(z y)/z](λy.λx.y z)) (u x) y = (λw.[(z y)/z][w/y](λx.y z)) (u x) y = (λw.[(z y)/z](λx.w z)) (u x) y = (λw.[(z y)/z](λx.w z)) (u x) y = (λw.λx.w (z y)) (u x) y [(u x)/w](λx.w (z y)) y = (λv.[(u x)/w][v/x](w (z y)) y = (λv.[(u x)/w](w (z y)) y = (λv.(u x) (z y)) y [y/v]((u x) (z y)) = (u x) (z y) (e) (λx.λy.x (y y)) (λz.x (z z)) (λu.λv.u) w (λy.(λz.x (z z)) (y y)) (λu.λv.u) w (λy.x ((y y) (y y))) (λu.λv.u) w x (((λu.λv.u) (λu.λv.u)) ((λu.λv.u) (λu.λv.u))) w x ((λv.(λu.λv.u)) (λv.(λu.λv.u))) w x (λu.λv.u) w Problema 3 - Numerais (adição e multiplicação) (a) mais 1 2 = 3 (λn.λm.λf.λx.n f (m f x)) (λf.λx.f x) (λf.λx.f (f x)) (λm.λf.λx.(λf.λx.f x) f (m f x)) (λf.λx.f (f x)) (λm.λf.λx.(λx.f x) (m f x)) (λf.λx.f (f x)) (λm.λf.λx.f (m f x)) (λf.λx.f (f x)) λf.λx.f ((λf.λx.f (f x)) f x) λf.λx.f ((λx.f (f x)) x) λf.λx.f (f (f x)) = 3 (b) vezes 1 1 = 1 (λn.λm.λf.n (m f)) (λf.λx.f x) (λf.λx.f x) (λm.λf.(λf.λx.f x) (m f)) (λf.λx.f x) (λm.λf.(λx.(m f) x)) (λf.λx.f x) λf.λx.(λf.λx.f x) f x λf.λx.(λx.f x) x λf.λx.f x = 1 (c) vezes 2 1 = 2

PLF - Programação Funcional (Linguagem Lambda) - Exercícios resolvidos 9 (λn.λm.λf.n (m f)) (λf.λx.f (f x)) (λf.λx.f x) (λm.λf.(λf.λx.f (f x)) (m f)) (λf.λx.f x) (λm.λf.(λx.(m f) ((m f) x))) (λf.λx.f x) (λm.λf.λx.m f ((m f) x)) (λf.λx.f x) λf.λx.(λf.λx.f x) f (((λf.λx.f x) f) x) λf.λx.(λx.f x) (((λf.λx.f x) f) x) λf.λx.(λx.f x) ((λx.f x) x) λf.λx.(λx.f x) (f x) λf.λx.f (f x) = 2 (d) vezes 3 2 = 6 (λn.λm.λf.n (m f)) (λf.λx.f (f (f x)) (λf.λx.f (f x)) (λm.λf.(λf.λx.f (f (f x))) (m f)) (λf.λx.f (f x)) (λm.λf.(λx.(m f) ((m f) ((m f) x))) (λf.λx.f (f x)) λf.(λx.((λf.λx.f(f x))f) (((λf.λx.f(f x))f)(((λf.λx.f(f x))f)x))) λf.λx.((λf.λx.f(f x))f) (((λf.λx.f(f x))f) (((λf.λx.f(f x))f)x)) λf.λx.(λx.f (f x)) ((λx.f (f x)) ((λx.f (f x)) x)) λf.λx.f (f ((λx.f (f x)) ((λx.f (f x)) x))) λf.λx.f (f (f (f ((λx.f (f x)) x)))) λf.λx.f (f (f (f (f (f x))))) = 6 Problema 4 - Numerais (zero?) (a) zero? 3 = falso (λx.x (λy.λz.falso) (λx.x) verd) (λf.λx.f (f (f x))) (λf.λx.f (f (f x))) (λy.λz.falso) (λx.x) verd λx.(λy.λz.falso) ((λy.λz.falso) ((λy.λz.falso) x)) (λx.x) verd λx.(λz.falso) (λx.x) verd λx.falso verd λx.(λx.λy.y) (λx.λy.x) λx.λy.y = falso

PLF - Programação Funcional (Linguagem Lambda) - Exercícios resolvidos 10 (b) zero? 2 = falso (λx.x (λy.λz.falso) (λx.x) verd) (λf.λx.f (f x)) (λf.λx.f (f x)) (λy.λz.falso) (λx.x) verd λx.(λy.λz.falso) ((λy.λz.falso) x) (λx.x) verd λx.(λz.falso) (λx.x) verd λx.falso verd λx.(λx.λy.y) (λx.λy.x) λx.λy.y = falso (c) zero? 1 = falso (λx.x (λy.λz.falso) (λx.x) verd) (λf.λx.f x) (λf.λx.f x) (λy.λz.falso) (λx.x) verd λx.((λy.λz.falso) x) (λx.x) verd λx.(λz.falso) (λx.x) verd λx.falso verd λx.(λx.λy.y) (λx.λy.x) λx.λy.y = falso (d) zero? 0 = verd (λx.x (λy.λz.falso) (λx.x) verd) (λf.λx.x) (λf.λx.x) (λy.λz.falso) (λx.x) verd λx.x (λx.x) verd (λx.x) verd verd Problema 5 - Condicional (a) se verd 1 2 = 1 (λx.x) (λx.λy.x) 1 2 (λx.λy.x) 1 2 (λy.1) 2 (λy.1) 2 1 (b) se falso 1 2 = 2 (λx.x) (λx.λy.y) 1 2 (λx.λy.y) 1 2

PLF - Programação Funcional (Linguagem Lambda) - Exercícios resolvidos 11 (λy.y) 2 2 Problema 6 - Cálculo combinatório (simplificação) S (S (K S) (S (K K) K)) (K (S K K)) M N = (S (K S) (S (K K) K)) M ((K (S K K)) M) N = S (K S) (S (K K) K) M (K (S K K) M) N = S (K S) (S (K K) K) M (S K K) N = (K S M) ((S (K K) K) M) (S K K) N = S (S (K K) K M) (S K K) N = S ((K K M) (K M)) (S K K) N = S (K (K M)) (S K K) N = (K (K M) N) (S K K N) = (K M) (S K K N) = K M (S K K N) = M Problema 7 - Cálculo combinatório (simplificação) S (B B S) (K K) M N O = (B B S M) (K K M) N O = (B B S M) K N O = B (S M) K N O = (S M) (K N) O = S M (K N) O = M O (K N O) = M O N Problema 8 - Combinador B B (B B B) M N O P Q = (B B B) (M N) O P Q = B B B (M N) O P Q = B (B (M N)) O P Q = (B (M N)) (O P) Q = B (M N) (O P) Q = (M N) ((O P) Q) = M N ((O P) Q) = M N (O P Q) Problema 9 - Combinador F B (B (T (B B T)) (B B T)) (B B T) M N O = (B (T (B B T)) (B B T)) (B B T M) N O = B (T (B B T)) (B B T) (B B T M) N O = B (T (B B T)) (B B T) (B (T M)) N O = (T (B B T)) ((B B T) (B (T M))) N O = T (B B T) (B B T (B (T M))) N O = T (B B T) (B (T (B (T M)))) N O = (B (T (B (T M)))) (B B T) N O = B (T (B (T M))) (B B T) N O = (T (B (T M))) (B B T N) O = T (B (T M)) (B (T N)) O = (B (T N)) (B (T M)) O

PLF - Programação Funcional (Linguagem Lambda) - Exercícios resolvidos 12 = B (T N) (B (T M)) O = (T N) (B (T M) O) = T N (B (T M) O) = (B (T M) O) N = B (T M) O N = (T M) (O N) = T M (O N) = (O N) M = O N M Problema 10 - Combinador W S S (KI) M N = S M ((K I) M) N = S M (K I M) N = S M I N = M N (I N) = M N N Problema 11 - Algoritmo de abstracção (combinadores M, T e B) (a) M O -> O O M <-> λx.x x x [x x] = S x [x] x [x] = S (S K K) (S K K) = S I I, Logo, M = S I I (b) T M N -> N M T <-> λx.λy.y x x [ y [y x]] = x [ S y [y] y [x] ] = x [ S I (K x) ] = S x [S I] x [K x] (c) B M N O -> M (N O) = S (K (S I)) K, Logo, T = S (K(S I)) K B <-> λx.λy.λz.x (y z) z [ y [ z [x (y z)] ] ] = x [ y [ (S z [x] [(y z)]) ] ] z = x [ y [ S (K x) y ] ] = x [ S (K x) ] = S x [S] x [K x] = S (K S) K, Logo, B = S (K S) K Problema 12 - Algoritmo de abstracção (λg.λy.g y y) λg.λy.g y y g [ y [g y y] ] = g [ S y [g y] y [y] ] = g [ S g I ]

PLF - Programação Funcional (Linguagem Lambda) - Exercícios resolvidos 13 = S g [S g] g [I] = S S (K I) Verificação: (λg.λy.g y y) M N (λy.m y y) N M N N S S (K I) M N = S M (K I M) N = S M I N = M N (I N) = M N N Problema 13 - Algoritmo de abstracção (factorial) λx.se (zero? x) 1 (vezes x( f (pred x))) [se (zero? x) 1 (vezes x (f (pred x)))] x = S x [se (zero? x) 1] x [vezes x (f (pred x))] = S (S x [se (zero? x)] x [1]) (S x [vezes x] x [f (pred x)]) = S (S (S x [se] x [zero? x]) x [1]) (S vezes (S x [f] x [pred x])) = S (S (S (K se) zero?) (K 1)) (S vezes (S (K f) pred)) = S (S (S (K se) zero?) (K 1)) (S vezes (S (K f) pred)) Problema 14 - Combinador de pontos fixos Se Pfixo = λf.(λg.λx.f (g g) x) (λg.λx.f (g g) x) é um combinador de pontos fixos então temos de provar que: (Pfixo E) = E (Pfixo E) (λf.(λg.λx.f (g g) x) (λg.λx.f (g g) x)) E (λf.(λx.f ((λg.λx.f (g g) x) (λg.λx.f (g g) x)) x) ) E (λf.f ((λg.λx.f (g g) x) (λg.λx.f (g g) x))) E η E [E/f]((λg.λx.f (g g) x) (λg.λx.f (g g) x)) E ((λf.(λg.λx.f (g g) x) (λg.λx.f (g g) x)) E) = E (Pfixo E) Problema 15 - Cálculo de 6! Vamos representar (λf.λn.se (zero? n) 1 (vezes n (f (pred n)))) por FACT Como Y é um determinante de pontos fixos: (Y FACT) = FACT (Y FACT) (λf.λn.se (zero? n) 1 (vezes n (f (pred n)))) (Y FACT) 3 λn.se (zero? n) 1 (vezes n ((Y FACT) (pred n))) 3 se (zero? 3) 1 (vezes 3 ((Y FACT) (pred 3))) Recordando o Problema 4a e Problema 5b, obtém-se: vezes 3 ((Y FACT) (pred 3)) No

PLF - Programação Funcional (Linguagem Lambda) - Exercícios resolvidos 14 Problema 16 mostra-se que (pred 3) é equivalente a 2; assim a expressão anterior simplifica-se: vezes 3 ((Y FACT) 2) Reinicia-se uma nova iteração (não esquecer que Y é um determinante de pontos fixos): vezes 3 (FACT (Y FACT) 2) = vezes 3 ((λf.λn.se (zero? n) 1 (vezes n (f (pred n)))) (Y FACT) 2) vezes 3 (λn.se (zero? n) 1 (vezes n ((Y FACT) (pred n))) 2) vezes 3 (se (zero? 2) 1 (vezes 2 ((Y FACT) (pred 2)))) * vezes 3 (vezes 2 ((Y FACT) 1)) Nova iteração: vezes 3 (vezes 2 (FACT (Y FACT) 1) = vezes 3 (vezes 2 ((λf.λn.se (zero? n) 1 (vezes n (f (pred n)))) (Y FACT) 1) vezes 3 (vezes 2 (λn.se (zero? n) 1 (vezes n ((Y FACT) (pred n))) 1) vezes 3 (vezes 2 (se (zero? 1) 1 (vezes 1 ((Y FACT) (pred 1)))) * vezes 3 (vezes 2 (vezes 1 ((Y FACT) 0)) E mais uma: vezes 3 (vezes 2 (vezes 1 (FACT (Y FACT) 0) = vezes 3 (vezes 2 (vezes 1 ((λf.λn.se (zero? n)1(vezes n(f(pred n)))) (Y FACT)0) vezes 3 (vezes 2 (vezes 1 (λn.se (zero? n) 1 (vezes n ((Y FACT) (pred n))) 0) vezes 3 (vezes 2 (vezes 1 (se (zero? 0) 1 (vezes 0 ((Y FACT) (pred 0)))) * vezes 3 (vezes 2 (vezes 1 1)) No Problema 3 já verificámos que: vezes 3 (vezes 2 (vezes 1 1)) = 6

PLF - Programação Funcional (Linguagem Lambda) - Exercícios resolvidos 15 Problema 16 - Numerais (predecessor) (a) pred 3 = 2??? (b) pred 2 = 1??? (c) pred 1 = 0???