INE 11

(1)

Principes des lang. de progr.

INE 11

Michel Mauny

Inria-Paris

pré[email protected]

Michel Mauny (Inria-Paris) INE 11 pré[email protected] 1 / 31

Le lambda-calcul

1 Termes duλ-calcul

2 Propriétés

3 Programmer enλ-calcul

4 Stratégies d’évaluation Stratégies internes/externes Réduction faible

Stratégie externe gauche, standardisation

Le λ -calcul

Système formel basé sur les fonctions Alonzo Church, 193x

problème de décision – de validité de formules logiques –

⇒fonctions calculables

Alan Turing : machines⇒fonctions calculables λ-calcul≈machines de Turing

Utilité

fondement des langages de programmation (bloc, fonction/procédure) fondement des langages fonctionnels

sémantique dénotationnelle

systèmes de spécification et de preuves de programmes

(2)

Termes

GrammaireLes termes duλ-calcul, aussi appelésλ-termes, sont donnés par la grammaire suivante :

M, e ::= x identificateurs

| e e applications

| λx.e abstractions (eest le corps la portéedex) Lire «λx.e» comme «funx→ e»

Syntaxe concrète

l’application «associe à gauche» :

e1e2e3≡(e1e2)e3

l’abstraction «porte» aussi loin que possible : λx.λy.λz.xzyz≡λx.(λy.(λz.xzyz))

Variables, occurrences

Occurrences de variables

Occurrences liantes: là où on introduit une variable (λ) Occurrences liées: se rapportant à une occurrence liante Occurrences libres: pas d’occurrence liante correspondante

freeVars(x) ={x}

freeVars(e1e2) =freeVars(e1)∪freeVars(e2) freeVars(λx.e) =freeVars(e)− {x}

Exemple: (les occurrences rougessont libres)

Substitution

La substitution d’un termeM à une variablex dans le termee, notée [M/x]e, est définie comme le terme résultant du remplacement de toutes lesoccurrences libresdex parM danse :

[M/x]x = M

[M/x]y = y, poury6=x [M/x](e1e2) = ([M/x]e1)([M/x]e2) [M/x](λx.e) = (λx.e)

[M/x](λy.e) = λy.[M/x]epourx 6=y ety6∈freeVars(M) [M/x](λy.e) = λz.[M/x]([z/y]e)

pourz 6∈freeVars(e)∪freeVars(M) etz 6=x ety6=x

(3)

Équivalences, réductions

α-équivalence

le nom des variables liées (les variables muettes) importe peu on peut les renommer à volonté, mais de façon cohérente α

-équivalence (ou

α

-conversion)

(α) λx.e←→λy.[y/x]e,

poury n’apparaissant ni libre, ni liée danse

relation d’équivalence passage au contexte

Les λ-termes sont (presque toujours) considérés modulo α-équivalence

Équivalences, réductions

β-équivalence

passage d’argument à une fonction de paramètre formelx β-équivalence (ouβ-conversion)

(β) (λx.e)M←→[M/x]e sens→: avancer dans le calcul

sens←: factoriserM

La règle importante duλ-calcul

Équivalences, réductions

η-équivalence

egalité entref etx7→f(x) η-équivalence (ouη-conversion)

(η) λx.ex ←→e, six6∈freeVars(e) en OCaml :

changerfacten (funn→fact(n)) changere: ()en (fun() →e()) pour évaluereà chaque application

(4)

Notations

Utilisation des conversions (équivalence, réduction)

«candidat à réduction» appeléradical

passage au contexte : réduire des sous-termes quelconques fermeture transitive : chaînes de conversions

Notation M=αN M←→^∗ N M→^∗β,αN Vocabulaire

terme irréductible / normalisé / en forme normale

Questions

Utiliser la règleβ pour réduire (calculer) choisir un (sous-terme) radical

le réduire⇒nouveau terme recommencer

Questions

comment choisir le prochain radical (stratégie) ? cela termine-t-il toujours ?

le résultat final dépend-il de ce choix ?

Terminaison

Cela termine-t-il toujours ? Non !

la réduction de(λx.xx)(λx.xx)ne termine pas pas étonnant (expressivité théorique)

Définitions

Normalisation forte

eest ditfortement normalisant si

toutes les réductions partant dee sont finies.

Normalisation faible

eest dit faiblement normalisant si

∃une réduction finie de emenant à un terme irréductible.

(λx.λy.y)((λx.xx)(λx.xx))est faiblement normalisant

(5)

Confluence

Théorème

SiM→^∗β N etM→^∗β P, alors∃Q tel queN →^∗βQ etP→^∗β Q

M

N P

Q

* *

Corollaire

Les formes normales, quand elles existent, sont uniques

Programmer en λ-calcul

Booléens True≡λx.λy.x False≡λx.λy.y If≡λa.λb.λc.a b c On a : If TrueB C →^∗β B

If FalseB C →^∗β C Paires/Listes Pair≡λa.λb.λp.p a b

First≡λa.aTrue Rest≡λa.aFalse

On a : First(PairA B) →^∗β A Rest(PairA B) →^∗β B

Programmer en λ -calcul

Liste vide Nil≡λx.True Cons≡Pair

Null≡λa.a(λx.λy.False) On a : Null Nil →^∗ True

Null(ConsA B) →^∗ False Nombres Zero ≡ λf.λx.x

One ≡ λf.λx.f x Two ≡ λf.λx.f (f x) Three ≡ λf.λx.f (f (f x)) . . .

Succ ≡ λn.λf.λx.f ((n f)x)

(6)

Programmer en λ-calcul

Nombres (suite) IsZero≡λn.n(λx.False)True Plus≡λm.λn.(mSucc)n Mult≡λm.λn.λf.m(n f)

Power≡λm.λn.(n(Multm)) (Succ Zero)

Points fixes

Un point fixe d’une fonctionf est un élémentatel que : a=f(a)

Dans leλ-calcul, un point fixe d’un termef est un termeetel que : e←→f e

Unopérateur (combinateur) de pointfixe est un terme Fix tel que : FixM←→M(FixM)

FixM est donc un point fixe deM

Points fixes et récursion

Dans le λ-calculles opérateurs de point fixe sont définissables : Y ≡λf.(λx.f(xx))(λx.f(xx))

En effet

YM ←→ (λx.M(xx))(λx.M(xx))

←→ M((λx.M(xx))(λx.M(xx)))

←→ M(YM)

Construction d’une fonction récursive f =...f...

plus petit point fixe d’une fonctionnelle(λf. ...f...)

«plus petit» = «le moins défini», au sens des CPO

(7)

Récursion

Exemple : factorielle let rec fact n=

if n= 0then1elsen∗fact(n−1) Fonctionnelle correspondante : let ffact fact=funn→

if n= 0then1elsen∗fact(n−1) On a :

(Fixffact) 3

←→Fix (ffact(Fixffact)) 3

←→^β (funn→ifn=0then1else

n∗(Fixffact)(n−1)) 3

←→^β,δ if3=0then1else3∗(Fixffact)(3−1)

←→^δ 3∗(Fixffact) 2

←→ . . .

Stratégies

Le choix du prochain radical à réduire n’influe pas sur la valeur (confluence) influe sur la terminaison

Stratégie = choix systématique radical interne ou externe à gauche ou à droite

externes

internes

Stratégies internes

Choisir le prochain radical le plus à l’intérieurdans le terme évaluer les arguments de fonction avant de les substituer aux paramètres formels

(λx.(λy.y))((λx.xx)(λx.xx))

Gauche, droite

correspond à l’ordre d’évaluation des arguments (λx.λy.e)e1e2

peu important (mais attention aux effets de bord !)

(8)

Stratégies extermes

Choisir le prochain radical le plus à l’extérieurdans le terme substituer les arguments de fonction aux paramètres formels sans les évaluer

(λx.(λy.y))((λx.xx)(λx.xx))

Gauche, droite

choix de la fonction ou de l’argument ((λx.e1)M) ((λy.e2)N)

on s’intéresse essentiellement à la stratégie externe gauche (leftmost-outermost)

Spécifier une stratégie

Quelle est la forme des termes irréductibles ? notion devaleur, notées iciv,v1,etc.

Quelle(s) règle(s) de réduction ? ici,β-réduction

Contextes d’application ?

arbitraires ? argument déjà évalué ?etc.

Réduction faible

s’interdire de réduire le corps des abstractions exécution de programmes

contraire : réduction forte Valeurs

v ::=xv₁. . .vn|λx.e avecn≥0

Appel par valeur des langages de programmation évaluer les argumentsavantde les passer à la fonction

on évalue des termes clos (pas de valeur de la forme(xv₁. . .vn)) ordre d’évaluation des arguments pas nécessairement spécifié

(9)

Stratégie interne, réduction faible

Valeurs

v ::=xv₁. . .vn|λx.e avecn≥0

Règle de réduction (λx.e)v→e[v/x]

Contextes de réduction e1→e₁⁰

e₁e₂→e₁⁰e₂(Fun) e2→e₂⁰

e₁e₂→e₁e₂⁰(Arg)

Réduction faible et langages de programmation

Appel par valeur

gauche d’abord (SML, . . . ) droite d’abord

non-spécifié (OCaml, C, . . . ) Fonctions, constructions syntaxiques

évaluation des arguments systématique et partagée entre les différentes occurrences

pas de substitution explicite, mais environnements conditionnelle : pas une fonction

encodage de la récursion avec

Z =λf.((λx.f(λy.(xx)y))(λx.f(λy.(xx)y)))

Stratégie externe gauche : standardisation

Réduire le radical le + externe, le + à gauche

ne réduire que les radicaux nécessaires (pas de calcul inutile) risque de dupliquer le calcul des arguments

Conduit à la forme normale si elle existe

Theorème de standardisation

Si le termeeest faiblement normalisant, alors la stratégie externe gauche trouvera sa forme normale en un nombre fini d’étapes

(10)

Stratégie externe gauche et réduction faible

Valeurs (formes normales de tête) v ::=xe₁. . .en |λx.e avecn≥0

Règle de réduction (λx.e1)e2→e1[e2/x]

Contexte de réduction

e1→e₁⁰ e₁e₂→e₁⁰e₂(Fun)

Appel par nom, évaluation paresseuse

Externe + gauche + faible pas de calcul inutile, mais . . .

. . . évaluations multiples d’arguments appel par nom

Remède : évaluation paresseuse

arguments évaluéssietlorsquenécessaire

partager leur évaluation entre différentes occurrences du paramètre formel

première évaluationx→^∗ 5 ultérieurement : 5 sans calcul langage Haskell

Évaluation paresseuse

Évaluation paresseuse en OCaml structure de donnée «paresseuse»

mot-clé lazy

moduleLazy: sig

typeαt

exceptionUndefined val force:αt → α

[...]

end

# letx =

lazy (printf "Hello\n%!");;

val x : unit Lazy.t= <lazy>

#Lazy.force x ;;

Hello

−: unit= ()

#Lazy.force x ;;

−: unit= ()

(11)

Conclusion

λ-calcul : théorie du calcul et de la fonctionnalité

support d’expression et d’étude de sémantiques, de modes d’exécution, d’analyses de programmes, de compilation

doté de systèmes de types, il devient formalisme logique