În calcul lambda, o variabilă v este legată numai prin λv și este vizibilă în corpul din λv.corp, în toate locurile unde nu este vizibilă o legare λv mai din interior În exemplul din Slide 3:15, λx.(λx.(λy.x z) x) 1 2 2 1 x1 este vizibil în toată expresia (λx.(λy.x z) x), cu excepția expresiei λx.(λy.x z) (unde este declarat un alt x) În expresia (λx.(λy.x z) x) variabila x este liberă (în sensul că există o variabilă cu numele x care este liberă) Pentru funcția: λx.(λx.(λy.x z) x) ^ doar această apariție este liberă în corp (λx.(λy.x z) x) este corpul funcției 1 2 3 x3 este o apariție liberă în corp, pentru că x2 era deja legat de x1 Beta-redexul este ușor de recunoscut pentru că *începe cu (λ și este până la paranteza închisă corespunzătoare* (λx.λx.x y) -> corpul λx.x în care înlocuiesc aparițiile libere ale lui x cu y (dar nu am nicio apariție liberă a lui x în corp) => rezutatul este chiar corpul (λx.λy.x y) -> corpul λy.x în care înlocuiesc aparițiile libere ale lui x cu y Eu mă aștept ca ((λx.λy.x y) z) să îmi întoarcă y Dar (λy.y z) îmi va întoarce z *Atenție! beta-reducerea nu poate schimba statutul de liber/legat al variabilelor în nicun context din interiorul expresiei* * dacă se întâmplă, trebuie să fac o redenumire înainte de a realiza beta-reducerea - în expresia (λx.λy.x y) voi redenumi variabila din corpul funcției (care este vizibilă doar în acest beta-redex) - redenumesc: (λx.λw.x y) - apoi fac beta-reducerea (λx.λw.x y) -> λw.x în care înlocuiesc pe x cu y -> λw.y - acum, (λw.y z) -> y, conform așteptărilor *Alfa-conversia nu poate schimba statutul de liber/legat al variabilelor în nicun context din interiorul expresiei* pas de reducere = [alfa-conversie +] beta-reducere secvență de reducere = pas de reducere* ((λx.λy.(y x) y) λx.x) - 1 beta-redex (λx.λy.(y x) y) - trebuie să redenumesc pe y (redenumesc la z) (λx.λz.(z x) y) -> λz.(z x) în care înlocuiesc pe x cu y => λz.(z y) revin la expresia mare (λz.(z y) λx.x) - 1 beta-redex este (z y) în care pe z înlocuiesc cu λx.x este (λx.x y) (λx.x y) - 1 beta-redex în x înlocuiesc pe x cu y este y expreisa inițială ajunge printr-o secvență de reducere (3 pași de reducere) la y (λx.(x x) λx.(x x)) - 1 beta redex, corpul este (x x) înlocuiesc x cu λx.(x x) (λx.(x x) λx.(x x)) - expresie ireductibilă "Să se termine" -> să nu mai am beta-redecși (λx.y (λx.(x x) λx.(x x))) - 2 beta-redecși (În general) Forma normală a unei expresii este o formă standardizată în așa fel încât putem să verificăm echivalența a 2 expresii prin faptul că ele au aceeași formă normală. Pot ajunge la un rezultat de forma λx.corp unde corp mai conține beta-redecși dar reducerea acestora nu mă ajută în acest moment *Dacă există o formă normală a expresiei, ajungem la ea prin orice secvență de reducere care se termină* *forma normală este valoarea expresiei* 1. Calculul se termină când ajungem la forma normală Calculul nu se termină întotdeauna 2,3. Toate secvențele de reducere care se termină dau același rezultat 4. Dacă există secvențe de reducere care se termină, atunci reducerea stânga-dreapta se termină. Putem considera un _program_ în calcul lambda ca o lambda expresie (închisă). Execuția programului este reducerea acestei expresii. Valoarea (forma normală) obținută în urma reducerii este rezultatul programului. (λx.λy.( x y ) (λx.x y)) - 2 beta-redecși sevența de reducere 1 (λx.λy.( x y ) (λx.x y)) - beta-redex ---------- -------- corp param actual λy.(x y) [(λx.x y) / x] corpul conține apariții legate ale lui y dar y este variabilă liberă (există apariții libere) în parametrul actual trebuie alfa-conversie λz.(x z) [(λx.x y) / x] λz.((λx.x y) z) (λx.x y) - beta redex corp x, PA y x [y / x] y λz.(y z) - Formă normală secvența de reducere 2 (λx.λy.( x y ) (λx.x y)) (λx.x y) - beta-redex x corp, PA y x [y / x] y (λx.λy.( x y ) y) - 1 beta-redex ---------- - corp PA λy.( x y ) [y / x] corpul conține apariții legate ale lui y dar y este variabilă liberă (există apariții libere) în parametrul actual trebuie alfa-conversie λw.( x w ) [y / x] λw.(y w) - Formă normală Este aceeași expresie, sub o redenumire a variabilelor e.g. w / z Calcul λ ca limbaj de programare ================================ Valori? Instrucțiuni condiționale Funcții recursive? if ~ λcond.λval-true.λval-false.________________ una dintre val-true și false, în funcție de cond λx.λy.x - fn selector de prim argument λx.λy.y - fn selector de al doilea argument if și Bool ---------- if ~ λcond.λval-true.λval-false.((cond val-true) val-false) - mă aștept ca în cond să primesc una dintre funcțiile selector True ~ λx.λy.x False ~ λx.λy.y Tipuri de date abstracte (TDA) - mulțime de valori pe care le *interpretez* ca având o anumită semnificație - modul de construcție a valorilor să fie compatibil cu modul de utilizare - valorile și funcțiile care le folosesc respectă niște *axiome* În calcul λ, iau niște valori (funcții) și le interpretez ca valori în niște TDA Implementez not: not ~ λval.((val F) T) ~ λval.((val λx.λy.y) λx.λy.x) - mă aștept să primească T/F, și să întoarcă F/T Perechi ------- pair ~ λa.λb. ___________ construiește ceva care poate fi utilizat ulterior ca pereche car ~ λp.___________ primește ceva ce a fost întors de pair și întoarce primul argument pe care a fost apelat pair fie λp.(___ p) - nu știu să desfac p sau λp.(p ____) pair/cons ~ λa.λb.λselector.((selector a) b) ((pair X) Y) -> λselector.((selector X) Y) car ~ λp.(p λx.λy.x) (car ((pair X) Y)) ~ (λp.(p λx.λy.x) λselector.((selector X) Y)) -> (λselector.((selector X) Y) λx.λy.x) -> ((λx.λy.x X) Y) -> X cdr ~ λp.(p λx.λy.y) Recursivitate ============= x pentru care f(x)=x se numește punct fix al lui f caut punctul fix a al lui F, astfel încât (F a) = a aplic (Fix F) (λf.(λx.(f ( x x )) λx.( f ( x x ))) F) (λx.(F ( x x )) λx.( F ( x x ))) (F ( λx.( F ( x x )) λx.( F ( x x )) )) = (F (Fix F)) = (Fix F) -> într-adevăr, (Fix F) este punct fix al lui F