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

Transcrição

1 Minicurso 1 Uma introdução ao cálculo lambda e a linguagens de programação funcionais Rodrigo Machado rma@infufrgsbr

2 2/68 Conteúdo Ideias iniciais Cálculo lambda Sintaxe Operação de substituição Equivalência alfa Redução beta Propriedades da redução beta Programação em cálculo lambda Booleanos Números naturais Pares ordenados Listas Definições locais Funções recursivas Funcões de alta ordem Revisão Referências

4 4/68 Antes de iniciarmos Considere os seguintes grupos de linguagens de programação: Grupo 1 : OCAML, F#, LISP, Scheme/Racket, Haskell Grupo 2 : Javascript, Python, Ruby, C# Grupo 3 : C, C++, Java, Pascal/Delphi Quais grupos contém linguagens de programação nas quais vocês já programaram? Você já ouviu falar antes de Máquinas de Turing, Funções Recursivas Parciais ou Cálculo Lambda?

5 5/68 Antes de iniciarmos (2) Suponha uma linguagem de programação com números e valores booleanos Considere as seguintes construções: 1 execução condicional (if-then e if-then-else) 2 laços de repetição (while e for) 3 definição de variáveis e operador de atribuição 4 definição e aplicação de funções Se fosse lhe pedido para você escolher três itens acima e jogar fora o item restante, quais itens seriam escolhidos? Seria possível escrever todos os programas desejados somente com os itens escolhidos? E se fosse possível escolher somente um dos itens acima?

6 Origem: notação lambda Considere a seguinte definição matemática: f(x) = x A igualdade acima está definindo uma função f, que consome um número e devolve um número f(3) = = 16 A igualdade acima está aplicando a definição de f a um valor específico O propósito original da notação lambda foi resolver a seguinte ambiguidade: f(e) = e Afinal, se trata da aplicação de f sobre a constante e = 2716 ou da definição de f? 6/68

7 7/68 Origem: notação lambda (2) A notação lambda (Church, 1932) permite diferenciar claramente a definição de uma função de sua respectiva aplicação f = λxx Acima temos a definição da função O λx indica que x deve ser interpretado como um parâmetro formal, isto é, um nome temporário para o valor a ser recebido pela função f(3) = (λxx 2 + 7)(3) = Acima temos a aplicação da função f, definida anteriormente, ao valor 3 Note que o significado da aplicação é a substituição do parâmetro formal x pelo valor concreto 3

8 8/68 Origem: cálculo lambda Ao formalizar as ideias fundamentais de definição e aplicação de funções, se chegou ao cálculo lambda A versão pura do cálculo não continha nada além de funções (sem números, sem operações) Ainda na década de 1930, Church e seus alunos (Kleene, Rosser) mostraram que a versão pura do cálculo era tão expressiva quanto outros modelos de computação propostos (em particular, Máquinas de Turing e Funções Recursivas Parciais) Atualmente, Cálculo Lambda diz respeito a uma grande família de formalismos construídos sobre os mesmos conceitos fundamentais

9 9/68 Motivação: por que cálculo lambda? O cálculo lambda original tem aproximadamente 80 anos! Não existiam nem computadores naquela época! Por que estudar algo tão antigo em 2013? Algumas razões: cálculo lambda foi e continua sendo influente: ele serviu de inspiração para linguagens de programação como (Lisp e Haskell) e para o estilo de programação funcional nas demais linguagens cálculo lambda (com tipos) é a base para o estudo formal de linguagens de programação e sistemas de tipos (mesmo as orientadas a objetos e imperativas) cálculo lambda (com tipos) possui uma conexão importante com Lógica Matemática, sendo a base de assistentes de prova como Coq e Agda cálculo lambda é um cálculo minimalista e elegante para saber utilizar de forma eficaz as novas linguagens de programação

10 10/68 Motivação: funções anônimas hoje em dia Linguagens de programação e suporte a funções anônimas: C : não Pascal : não C++ : sim (a partir da versão C++11) Javascript : sim Python : sim Ruby : sim C# : sim (a partir de versão 30) Java : sim (a partir de versão 8) E é claro, todas as linguagens de programação funcionais/mistas: LISP, Scheme, Clojure, Scala, Ocaml, F#, Haskell,

11 11/68 Este minicurso Objetivos 1 Apresentar as ideias fundamentais de cálculo lambda: termos-lambda, substituição, alfa-equivalência, redução beta 2 Argumentar sobre propriedades do cálculo: confluência de redução beta, universalidade 3 Mostrar como codificar diversos tipos de dados e estruturas de controle como termos-lambda Abordagem conceitual (alguns detalhes formais serão omitidos) foco em programação: vamos definir a função fatorial em cálculo lambda puro

13 13/68 Sintaxe: pré-termos Começaremos definindo um conjunto Λ de pré-termos Considere um conjunto infinito (mas contável) de nomes (aka parâmetros, identificadores, variáveis) o qual chamaremos Var Vamos denotar os elementos de Var por x, y, z, Definição: o conjunto Λ é o menor conjunto tal que: 1 se x Var então x Λ (variáveis) 2 se M Λ e N Λ N) Λ (aplicação) 3 se x Var e M Λ então λxm Λ (abstração lambda) Notação: vamos utilizar simplesmente M N para N)

14 14/68 Sintaxe: exemplos Exemplos de elementos de Λ : x x y λxx λxy (λxx) y λx(x y) (λxx) (λxx) λxλyx λxλyy (λxy) Nota: precisamos de regras claras para evitar ambiguidade na escrita de um pré-termo Exemplo: λxx y representa λx(x y) ou (λxx) y?

15 Sintaxe: regras de notação 1 O λ engloba tudo à direita (o máximo possível) λxx y = λx(x y) (λxx) y x λy(λxx y)(z 2 O é associativo à esquerda x y z = (x y) z x (y z) x 3 Notação simplificada para λ s seguidos λx y zm = λxλyλzm x z w 15/68

16 16/68 Sintaxe: termos com nomes especiais Alguns pré-termos são famosos e possuem nomes especiais Combinadores (lógica combinatorial) I = λxx K = λx yx S = λx y z(x z (y z)) Auto-aplicação e ponto fixo ω = λxx x Ω = ω ω Y = λf (λx f(x x))(λx f(x x)) A utilidade desses termos será vista posteriormente

17 17/68 Variáveis livres e ligadas Definição: dentro do pré-termo λxm, dizemos que M é o escopo de λx Definição: uma ocorrência de x dentro do escopo de λx é dita ligada Caso contrário, x ocorre livre Exemplo: a) λxx y x é ligada, y é livre b) λxz λzz x z é livre, z e x são ligadas c) λxx λxx y x e x são ligadas, y é livre Nota: 1 Um mesmo nome por ter ocorrências ligadas e livres no mesmo pré-termo (b) 2 Uma ocorrência de x é sempre ligada ao λx mais interno (c)

18 Variáveis livres e ligadas (2) Ocorrências livres e ligadas de variáveis têm significados distintos: variáveis livres referem-se a nomes externos (globais) variáveis ligadas referem-se a parâmetros formais (locais) Nomes de variáveis livres são importantes: expressões distintas sin(π) 42 + π 2 sin(e) 42 + e 2 Nomes de parâmetros formais não são importantes: mesma definição λx sin(x) 42 + x 2 λe sin(e) 42 + e 2 18/68

19 19/68 Variáveis livres e ligadas (3) Definição: a função FV computa as variáveis que ocorrem livres em um pré-termo FV(x) = {x} FV(λxM) = FV(M) {x} FV(M N) = FV(M) FV(N) Definição: um pré-termo M onde FV(M) = {} é fechado, também chamado combinador Caso contrário, ele é aberto

20 20/68 Operação de substituição A operação de substituição M[x = N] substitui todas as ocorrências livres de x em M por N Exemplo: 1) (λxxy)[x = w] = λxxy 2) (λxxy)[y = w] = λxxw 3) (λxxy)[z = w] = λxxy 4) (zλzz)[z = w] = wλzz 5) (zz)[z = λzzz] = (λzzz)(λzzz) 6) (λxxy)[y = x] = (λxxx)? Pergunta: alguém nota algo estranho com a substituição 6?

21 21/68 Captura de variáveis livres Problema do Ex 6: captura de variáveis livres M N (λxxy) [y = x ] Considere M: na posição onde está y, o nome x é ligado Considere N: o nome x ocorre livre Ao substituir y por N, podemos colocar um x livre em uma posição onde o mesmo nome x está ligado Mas nomes livres e ligados possuem interpretações distintas, e isso altera o significado do termo Vamos querer evitar esse problema ao definirmos substituição

22 Operação de substituição: definição formal Definição: operação de substituição evitando captura de variáveis livres x[y = P] = { P x se x = y caso contrário (λxm)[y = P] = { λxm λx(m[y = P]) se x = y se x y e x FV(P) (M N)[y = P] = M[y = P] N[y = P] Pergunta: segundo esta definição, qual o resultado de (λxxy)[y = x]? Resposta: indefinido! 22/68

23 23/68 Equivalência alfa Definição: dois pré-termos M e N são α-equivalentes (M = α N) sss eles diferem somente na escolha dos nomes de variáveis ligadas Exemplo: λxxy = α λzzy λxxx = α λzzz λxxy α λyyy λyzy α λyxy O conceito de α-equivalência captura a intuição que a escolha dos nomes dos parâmetros formais realmente não é importante

24 24/68 Equivalência alfa: definição formal Definição: = α é a menor relação de equivalência sobre Λ tal que y FV(M) λxm = α λy(m[x = y]) (α) M = α M N M = α N M M = α M M N = α M N M = α M λxm = α λxm

25 25/68 Termos lambda Definição: um termo lambda é uma classe de equivalência de pré-termos α-equivalentes Notação: vamos denotar por {M} α o termo lambda contendo o pré-termo M Exemplo: {λxx} α = { λxx, λyy, λzz, } {λxx y} α = { λaa y, λbb y, } Definição: Λ é conjunto de todos os termos lambda: Λ = Λ = α

26 26/68 Termos lamba: operação de substituição Operações definidas em Λ podem ser estendidas para Λ Lembre: Porém, como e (λxxy)[y = x] indefinido λxxy = α λaay (λaay)[y = x] = λaax podemos estender M[x = N] para termos, obtendo {λxxy} α [y = {x} α ] = {λaax} α Efeito: temos em Λ uma operação de substituição que é total e bem-definida (evita captura de variáveis livres)

27 27/68 Termos vs pré-termos No que segue, vamos falar de termos e não mais de pré-termos Contudo, vamos escrever termos usando M ao invés de {M} α, e assumir que a operação de substituição é total e evita a captura de variáveis livres Essa convenção é também chamada convenção de Barendregt, devido à sua utilização no livro deste autor A principal justificativa é reduzir a poluição excessiva da notação

28 28/68 Redexes e formas normais Definição: um redex (reducible expression) é um subtermo de M com o formato (λxp) Q e o seu respectivo contractum é P[x = Q] Definição: um termo que não contenha nenhum redex é chamado forma normal (ou termo irredutível) Exemplo: a) λy(λxy x)((λyx) y) contém dois redexes b) λxλy x x é uma forma normal

29 29/68 Redução beta Redução beta descreve a avaliação de termos lambda através de substituição Temos M β N se obtivermos N através da contração de um redex de M Exemplo: (λzλxx z) y β λy(λxy x) ((λyx) y) β λy(λxy x) x β λxx y λy(λxy x) x λyy x

30 30/68 Redução beta: definição formal Definição: β é a menor relação em Λ tal que (λxp) Q β P[x = Q] (β) M β M N M β N M M β M λxm β λxm M β M M N β M N Definição: β é o fecho transitivo e reflexivo de β Intuitivamente, M N quando M reduz para N em 0 ou mais passos de redução beta

31 31/68 Equivalência beta β-equivalência identifica termos que possuem reescritas confluentes Definição: = β é a menor relação em Λ tal que M β P N β P M = β N Exemplo: os seguintes termos são β-equivalentes: M = (λzλxx z) y N = (λuλxx y) (t t) P = λxx y Nota: perceba que M / β N e N / β M

32 32/68 Equivalência beta: possuir forma normal Definição: dizemos que um termo M possui forma normal sss M = β N e N é uma forma normal Exemplo: (λxx x) possui forma normal (ele é fn) (λxx x) a possui forma normal (ele β-reduz para (a a), que é fn) (λxx x) (λxx x) não possui forma normal (ele β-reduz para si mesmo)

33 33/68 Estratégias de avaliação Um termo P pode ter diversos redexes e, portanto, avaliar para distintos termos Exemplo: (considere ω = λxx x e I β ω I I I ω I ω I

34 34/68 Estratégias de avaliação (2) Definição: Uma estratégia de avaliação é uma escolha fixa para todos os termos de qual redex tem prioridade na redução Avaliação preguiçosa (lazy): redex mais externo, mais à esquerda realiza a aplicação sem normalizar os argumentos Avaliação estrita (strict): redex mais interno, mais à esquerda normaliza todos os argumentos antes de aplicar a função Exemplo: lazy: (true I Ω) β (λyi) Ω β I strict: (true I Ω) β (λyi) Ω β (λyi) Ω β

35 35/68 Propriedades de redução beta: confluência Confluência: (Church-Rosser) se N β M β N então existe P tal que N β P β N Corolário: formas normais são únicas Exemplo: ω(ii) ω(i) (II)(II) I(II) II

36 36/68 Propriedades de redução beta: normalização Normalização: se o termo M possui forma normal N, então avaliar M usando a estratégia preguiçosa certamente alcança N observe que nem todo termo possui forma normal avaliação estrita pode não alcançar forma normal determinar equivalência beta de termos é um problema indecidível Nota: não vamos apresentar neste minicurso as provas de confluência e normalização da redução beta Contudo, elas são essenciais para a utilização do cálculo como linguagem de programação

37 37/68 Cálculo lambda: revisão da teoria Os seguintes conceitos e definições foram apresentados: pré-termos (Λ ), variáveis livres e ligadas, operação de substituição, captura de variáveis livres α-equivalência, termos (Λ), extensão de operações de pré-termos para termos redexes, formas normais, β-redução, β-equivalência, possuir forma normal, estratégia de avaliação propriedades de β-redução: confluência, normalização Alguns aspectos importantes não foram mencionados (por brevidade): provas formais das propriedades de confluência e normalização (β-redução) redução η (extensionalidade) redução δ (tipos de dados e operações primitivas)

39 39/68 Cálculo lambda como linguagem de programação A linguagem de termos lambda juntamente com a redução beta (e uma estratégia de avaliação fixa) compõe uma linguagem de programação idealizada Podemos enxergar a seguinte associação: termo lambda = estado da máquina redução beta = passo de execução da máquina formas normais = valores finais (parada da máquina) Ainda em 1936, Church mostrou que todas as funções computáveis podem ser descritas em cálculo lambda Isso significa que esse modelo de computação é universal

40 40/68 Codificações Como a linguagem lambda pura provê somente variáveis, abstração lambda e aplicação de termos a termos, é necessário codificar em termos lambda Dados: valores booleanos e operações lógicas números, operações aritméticas e operações relacionais coleções: pares e listas Estruturas de controle: execução condicional definições locais recursão Nota: nessas codificações o foco não é eficiência!

41 41/68 Booleanos Definição: booleanos de Church: true = λx y x false = λx y y Intuição true consome dois termos, e retorna o primeiro false consome dois termos, e retorna o segundo

42 42/68 Construção condicional Definição: construção if-then-else : if a then b else c = λa b c a b c Ideia: aplicar o booleano resultante do teste sobre os valores a serem retornados Justifica a definição de valores-verdade como seletores Exercício: definir as operações booleanas not, and e or

43 43/68 Números naturais Definição: numerais de Church: 0 = λf x x 1 = λf x f x 2 = λf x f (f x) 3 = λf x f (f (f x)) n = λf x n f (f (f (f x) )) Também referenciados por c n, para n N

44 44/68 Operações aritméticas: sucessor Função sucessor: succ = λn p q p (n p q) Ideia da construção: 1 receber um numeral de Church n com estrutura n = λf x f (f (f x) ) 2 o resultado deve ter p e q ligados por lambdas: λp q 3 o termo (n p q) muda os f s em p s, e o x em q 4 por último, introduzimos um p adicional ao número

45 45/68 Operações aritméticas e relacionais Definição: operações aritméticas básicas: add = λ m n p q m p (n p q) mult = λ m n p q m (n p) q exp = λ m n n m Definição: teste de zero: iszero = λn n (λxfalse) true Nota: a função predecessor é trabalhosa e será vista posteriormente

46 46/68 Pares ordenados Definição: um par (M, N) pode ser representado por pair M N onde pair = λ m n b b m n Exemplo: pair 0 true = λb b 0 true Definição: funções de acesso ao conteúdo de um par fst = λp p true snd = λp p false Notação: usaremos M, N como um sinônimo para pair M N

47 47/68 Pares ordenados: predecessor Usando pares podemos definir pred N N onde pred(n) = Função auxiliar: shiftinc(a, b) = (b, b + 1) 0 se n 1 n 1 caso contrário shiftinc = λp snd p, succ (snd p) Definição: o termo pred abaixo implementa a função pred pred = λnfst (n shiftinc 0, 0 )

48 48/68 Listas Listas podem ser consideradas as estruturas de dados fundamentais em linguagens de programação funcionais A definição algébrica de uma lista oferece dois construtores: empty (lista vazia) cons, que recebe um valor e uma lista, e retorna a lista prefixada pelo valor Exemplo: empty (cons 2 empty) (cons 2 (cons 5 (cons 1 empty)))

49 49/68 Listas (2) Três funções são definidas para acessar o conteúdo da lista: isempty testa se a lista é vazia head retorna o primeiro elemento da lista tail retorna a lista resultante da remoção do primeiro elemento Aplicar head ou tail sobre empty é um erro Exemplo: isempty empty => true isempty (cons 2 empty) => false head (cons 2 empty) => 2 tail (cons 3 (cons 2 empty)) => (cons 2 empty) head (tail (cons 3 (cons 2 empty))) => 2

50 50/68 Listas (3) A seguinte codificação implementa as operações de listas sobre cálculo lambda Definição: construtores de listas: empty = λx true cons = λh t pair h t Definição: operações de lista: isempty = λll (λx λyfalse) head = fst tail = snd

51 51/68 Definições locais Programas habitualmente tem o formato definição 1 definição 2 definição n programa principal Em cálculo lambda podemos representar definições locais (não-recursivas) através do seguinte esquema: def a = v in p = (λap) v

52 52/68 Funções recursivas Considere o problema de definir um termo para executar iteração (laço for) ou definições recursivas em cálculo lambda (função fatorial, por exemplo) Assuma que temos na linguagem termos primitivos: booleanos, naturais, succ, pred, iszero, e if-then-else (sem ser via codificação de Church) Queremos definir uma função I que recebe um número n uma função f um valor inicial x para o qual (I n f x) resulta em n f (f (f (f x) ))

53 53/68 Funções recursivas (2) Tentativa inicial: Ideia da construção: I = λ n f x if (iszero n) then x else (I (pred n) f (f x)) se n = 0 : retorna x se n > 0 : itera (n 1) vezes a função f no argumento (f x) Problemas: não há memória para armazenar a definição de I definição circular qual o termo lambda que codifica I?

54 54/68 Funções recursivas (3) Imagine o lado direito da equação como a aplicação de um combinador S sobre I Nesse caso a equação I = λ n f x if (iszero n) then x else (I (pred n) f (f x)) se torna onde I = S I S = λ X λ n f x if (iszero n) then x else (X (pred n) f (f x)) Nota: veja que a definição de S não é circular! Outra visão do problema: achar um termo I que é o ponto fixo de S

55 55/68 Pontos fixos Definição: o ponto fixo (fixed-point, FP) de uma função f X X é um elemento x X tal que f(x) = x Exemplo: 1) x x 2 N N FP = {0, 1} 2) x x Z Z FP = {0, 1, 2, } 3) x x Z Z FP = {0} 4) x x 1 Z Z FP = {} Estamos interessados em encontrar um ponto fixo para S Λ Λ Boas novas! há um termo que nos constrói o ponto fixo!

56 56/68 Pontos fixos: combinador Y Chamamos o termo abaixo de combinador Y (ou combinador de ponto fixo) Y = λf(λxf(x x))(λxf(x x)) Teorema: o combinador Y produz um ponto fixo para seu argumento Demonstração: YS (λxs(x x)) (λxs(x x)) S (λxs(x x)) (λxs(x x)) S(YS) β β = β YS = β S(YS) e, portanto, YS é um ponto fixo de S Podemos finalmente definir I = YS

57 Pontos fixos: combinador Y em Y λx x x @ x x x x 57/68

58 58/68 Pontos fixos: combinador Y em ação (2) se S = β λ X (iszero n) λ n f x x if X (pred n) f (f x)

59 59/68 Pontos fixos: combinador Y em ação (3) então (Y S) = β (iszero n) x λ n f x if (iszero (pred n)) (f x) if if (iszero (pred (pred n))) (f (f x))

60 Funções recursivas e operador Y Usando Y podemos codificar funções como termos nos baseando em suas definições recursivas Definição recursiva: Combinador: fact(n) = 1 se n 1 n fact(n 1) caso contrário F = λmλnif (iszero (pred n)) then 1 else (mult n (M (pred n))) Definição final: fact = YF Nota: avaliação preguiçosa é requerida (Y diverge quando avaliado estritamente) 60/68

61 61/68 Funções de alta ordem Em programação funcional, é comum termos funções que processam outras funções junto com os dados Funções que consomem ou retornam outras funções são chamadas funções de alta ordem ou funcionais Os três funcionais clássicos em linguagens funcionais são map, filter e fold A função map consome uma função f e uma lista de valores l, e retorna a lista de resultados da aplicação de f a cada elemento da lista l map succ (cons 3 (cons 1 empty)) => (cons 4 (cons 2 empty))

62 62/68 Funções de alta ordem (2) A função filter consome um predicado p (função com retorno booleano) e uma lista de valores l, e retorna a lista contendo os valores em l que satisfazem o predicado filter par (cons 3 (cons 2 (cons 1 empty))) => (cons 2 empty) A função fold consome uma operação binária op, um valor inicial init e uma lista l, e substitui cons por op e empty por init em l, retornando um valor final fold + 0 (cons 3 (cons 2 (cons 1 empty))) => (+ 3 (+ 2 (+ 1 0))) Exercício: defina map, filter e fold em cálculo lambda

63 63/68 Universalidade de cálculo lambda Universalidade Cálculo-lambda como linguagem de programação é Turing-computável Há várias formas de provar isso, mas é fácil perceber que Usando duas listas podemos codificar uma fita bidirecional Podemos codificar estados e símbolos utilizando números Usando listas, pares, podemos codificar uma função de transição de estado Procedimentos recursivos pode ser utilizados para implementar consulta à função de transição de estado Com esses componentes, podemos codificar Máquinas de Turing

65 65/68 Revisão O que vimos: os componentes fundamentais da teoria de cálculo lambda como utilizar o cálculo lambda puro como uma linguagem de programação funcional, utilizando diversos mecanismos de codificação O que não foi visto: a teoria de lambda calculi é vasta, e inclui diversas variações importantes com sistemas de tipos associados: cálculo lambda simplesmente tipado cálculo lambda polimórfico cálculo lambda com tipos dependentes mesmo a teoria do cálculo lambda sem tipos possui diversos resultados que não foram citados Para mais informações, ver as referências ao final

66 66/68 Retomando a pergunta inicial Suponha uma linguagem de programação com números e valores booleanos Considere as seguintes construções: 1 execução condicional (if-then e if-then-else) 2 laços de repetição (while e for) 3 definição de variáveis e operador de atribuição 4 definição e aplicação de funções Pergunta: se fosse necessário escolher somente um dos itens acima, ainda teríamos uma linguagem de programação expressiva o suficiente? Resposta: certamente, desde que a escolha seja o item 4!

68 68/68 Referências The lambda calculus: its syntax and semantics (Barendregt, 1984) An introduction to functional programming through lambda calculus (Michaelson, 1989) Lectures on the Curry-Howard isomorphism (Sørensen and Urzyczyn, 2006) A short introduction to the Lambda Calculus (Jung, 2004) Disponível online em papers/lambda-calculuspdf How to Design Programs: An Introduction to Computing and Programming (Felleisen, Findler, Flatt, Krishnamurthi, 2003) Disponível online em