INF 321 Programmation fonctionnelle, typage, isomorphisme de Curry-Howard

(1)

INF 321

Programmation fonctionnelle, typage, isomorphisme de Curry-Howard

Eric Goubault

Cours 9

3 juillet 2013

(2)

Dans le dernier ´ episode...

On a vu:

Validation

Syst`emes de preuve en logique On va voir:

Retour sur la programmation fonctionnelle (Caml, Haskell...)!

Strat´egies d’´evaluation (eager/lazy) Typage et isomorphisme de Curry-Howard

En fait c’est un cours sur la récursivité, les références, et la preuve de programmes, revisitées dans les langages fonctionnels! C’est aussi l’occasion de voir une nouvelle sémantique, opérationnelle, des langages de programmation

(3)

Dans le dernier ´ episode...

On a vu:

Validation

Syst`emes de preuve en logique On va voir:

Retour sur la programmation fonctionnelle (Caml, Haskell...)!

Strat´egies d’´evaluation (eager/lazy) Typage et isomorphisme de Curry-Howard

En fait c’est un cours sur la récursivité, les références, et la preuve de programmes, revisitées dans les langages fonctionnels! C’est aussi l’occasion de voir une nouvelle sémantique, opérationnelle, des langages de programmation

(4)

PCF

“Programming Computable Functions” (Gordon Plotkin 1977) Substantifique mo¨elle des langages fonctionnels

Les fonctions sont des objets “de premi`ere classe”

Construction de fonction fun x -> t correspondant au Caml (au nommage pr`es):

l e t f x = t

Application d’une fonction à un argumentt t (on peut appliquer une fonction à une fonction - et même à soi-même!

(“Sucre syntaxique” au dessus du λ-calcul)

(5)

Grammaire de PCF

t ::= x

| fun x−>t

| t t | t×t

| n

| t+t | t−t | t∗t | t/t

| ifz t then t else t

| fix x t

| let x=t in t

Remarques

On pourrait rajouter une construction somme...

Le langage PCF est complet au sens de Turing! (permet de calculer toutes les fonctions r´ecursives partielles, cf. cours 5)

(6)

fix ?

Op´erateur de point fixe

Permet de d´efinir des fonctions r´ecursives (interdites syntaxiquement dans PCF)

Exemple, la fonction factorielle:

fix f fun n -> ifz n then 1 else n∗(f(n−1)) C’est la “plus petite” fonction f telle que

f(n) =

1 si n= 0

n∗f(n−1) sinon

S´emantique donn´ee au cours 7! (plus petit point fixe d’une certaine fonctionnelle)

En Caml, c’est lelet rec

(7)

S´ emantique op´ erationnelle

On va décrire les actions, une à une, lors de l’exécution d’un programme PCF (sémantiquepetits pas)

Cela va prendre la forme derègles de réductionou de réécriture:

p→q

ou “le termep se réécrit (ou se réduit en une étape) en le terme q”

On a le droit de r´e´ecrire n’importe quel sous-terme, a priori dans n’importe quel ordre

En fait

Forme un automate (cf. taupe)

Ou encore un graphe ´etiquet´e (cf. cours 10)

(8)

R` egles de r´ eduction

β-r´eduction

(fun x -> t)u →t[u/x]

o`u t[u/x] est le termet dans lequel on remplace syntaxiquement toutes les occurrences de la variablex par le termeu.

Calcul arithm´etique (tautologique!) p+q →n

si l’entierp plus l’entier q est ´egal `an... Reste similaire...

Conditionnelles

ifz 0 then t else u→t

ifz n then t else u →u sin 6= 0

(9)

R` egles de r´ eduction, suite

fix x t →t[fix x t/x]

Ce qui veut dire? Doit vous rappeler les r`egles de calcul de point fixe (par exemple en preuve `a la Hoare)

D´efinition

let x =t in u→u[t/x]

(10)

Exemples

Un calcul arithm´etique simple

(fun x -> x+ 2) 3 → 3 + 2 β-r´eduction

→ 5 règles arithmétiques Remarque: notion soulignée pour la partie qui intéragit, qui va être réduite. S’appelle un rédex.

(11)

En fait...

On peut mˆeme se passer de l’arithm´etique...

[n] =fun z -> fun s -> s(s(s(. . .(s z). . .))) (où on répète n∈Nfois l’application de s) représentel’entier n

On peut ensuite coder facilement les op´erations, addition, multiplication...:

+ = fun n -> fun p -> fun z -> fun s -> n(pzs)s

× = fun n -> fun p -> fun z -> fun s ->

nz(fun z -> pzs)

entiers de Church (Alonzo Church, 1930)

De mˆeme pour les bool´eens et pour la conditionnelle...

PCF:sucre syntaxique autour duλ-calcul (Church!)

(12)

Terminaison des r` egles de r´ eduction?

Exemple

fix x x →fix x x →. . .ne termine pas!

En même temps, qu’est-ce que ca veut dire? (penser au typage...cf. la deuxième moitié de ce cours)

Mais pratique, car en fait...du coup...

Le termefix n’est pas n´ecessaire non plus! (dans un cadre non-typ´e, voir la suite...)

(13)

Combinateur Y

Definir le terme Y suivant:

fun f -> (fun x -> f (x x))(fun x -> f (x x)) Soit g un terme PCF, alors:

Y g = (fun f -> (fun x -> f (x x)) (fun x -> (f (x x))))g

(14)

Combinateur Y

Y g = (fun f -> (fun x -> f (x x)) (fun x -> (f (x x))))g β-r´eduction externe

= (fun x -> g (x x))(fun x -> g (x x))

(15)

Combinateur Y

= (fun x -> g (x x))(fun x -> g (x x)) β-r´eduction interne

= g(fun x -> g (x x))(fun x -> g (x x))

(16)

Combinateur Y

= (fun x -> g (x x))(fun x -> g (x x)) β-r´eduction interne

= g(fun x -> g (x x))(fun x -> g (x x))

= g (Y g)

(17)

Oui mais...

On aurait aussi ´evaluer de la fa¸con suivante:

En effectuant la deuxi`emeβ-reduction (interne) avant la premi`ere...

On aurait eu:

Y g = (fun f -> (fun x -> (f (x x)) (fun x -> (f (x x))))) g

(18)

Oui mais...

On aurait eu:

Y g = (fun f -> (fun x -> (f (x x)) (fun x -> (f (x x))))

g (β-r´eduction interne)

= (fun f -> (f (fun x -> f (x x))) (fun x -> f (x x))) g

(19)

Oui mais...

On aurait eu:

Y g = (fun f -> (fun x -> (f (x x)) (fun x -> (f (x x))))) g (β-r´eduction interne)

= (fun f -> (f (fun x -> f (x x))) (fun x -> f (x x)))g

(β-r´eduction interne)

= (fun f -> f f (fun x -> f (x x)) (fun x -> f (x x)))g

= etc.!

(20)

Oui mais...

On aurait eu:

Y g = (fun f -> (fun x -> (f (x x)) (fun x -> (f (x x))))) g (β-r´eduction interne)

= (fun f -> (f (fun x -> f (x x))) (fun x -> f (x x)))g

(β-r´eduction interne)

= (fun f -> f f (fun x -> f (x x)) (fun x -> f (x x)))g

= etc.!

Ne termine pas (en fait c’est Kleene...)! (rappelez vous fix x x!)

(21)

Ordre d’´ evaluation

On voit que:

On n’a pas spécifié l’ordre d’utilisation des règles de réduction!

Ca peut tout changer?

Notre chance:

Appelons terme irréductible (dans PCF) un terme sur lequel on ne peut appliquer aucune règle de réduction

On a une propriété de confluence: si on utilise les règles de réduction dans n’importe quel ordrequi termine sur un terme irréductible, alors on termine toujours sur le même terme irréductible

Clairement pas vrai si on oublie la condition d’irr´eductibilit´e...

(penser encore `afix x x!)

(22)

Ordres d’´ evaluation

Exemple

(fun f -> fun x -> f(f x))(fun x -> x+ 2)

fun x -> (fun x -> x+ 2)(fun x -> x+ 2)x

fun x -> (fun x -> x+ 2) (x+ 2)

fun x -> (fun x -> (x+ 2) + 2) x

fun x -> (x+ 2) + 2

(23)

Beaucoup d’ordres d’´ evaluation possibles!

(merci Jean-Jacques L´ evy)

(24)

Beaucoup d’ordres d’´ evaluation possibles!

(merci Jean-Jacques L´ evy)

(25)

Passage par valeur, passage par r´ ef´ erence, revisit´ es

Imposons un ordre d’´evaluation!

Ici, commen¸cons par r´eduire les sous-termes les plus profonds (sans ˆetre trop formel)

Cela revient à évaluer d’abord les arguments des fonctions, avant les fonctions elles-mêmes

C’est le passage d’arguments par valeur!

Passage par valeur: exemple

(fun x -> (x+x))(2 + 3) → (fun x -> (x+x)) 5

´

evaluation de l’argument

→ 5 + 5

→ 10

terme irr´eductible!

(26)

Passage par valeur, passage par r´ ef´ erence, revisit´ e

Imposons un ordre d’´evaluation!

Evaluons les rédexs de l’extérieur vers l’intérieur

Cela revient à calculer ce que l’on peut d’une fonction, sans les arguments, et de n’évaluer les arguments qu’au besoin, petit à petit...

Revient à un passage par référence des arguments: on ne regarde ce qui est pointé par une référence, qu’au besoin Passage par référence: exemple

Y g! (on ne veut pas évaluer à l’intérieur deY, pour avoir la terminaison!)

(27)

Combinateur de point fixe pour l’appel par valeur

Peut-on quand même définir un opérateur de point fixe pour l’appel par valeur?

Oui!

Appel par valeur

Utiliser plutˆot dans ce cas le combinateurZ (dans un langage non typ´e...):

fun f -> (fun x -> f (fun v -> ((x x)v))) (fun x -> f (fun v -> ((x x)v)))

(28)

Autre exemple

Exemple: appel par nom

fun x -> (fun x -> x+ 2)(fun x -> x+ 2) x

fun x -> (fun x -> x+ 2) (x+ 2)

fun x -> (fun x -> (x+ 2) + 2) x

fun x -> (x+ 2) + 2

(29)

Autre exemple

fun x -> (fun x -> x+ 2) (x+ 2)

fun x -> (fun x -> (x+ 2) + 2) x

fun x -> (x+ 2) + 2

(30)

Autre exemple

fun x -> (fun x -> x+ 2) (x+ 2)

fun x -> (fun x -> (x+ 2) + 2) x

fun x -> (x+ 2) + 2

(31)

Autre exemple

fun x -> (fun x -> x+ 2) (x+ 2)

fun x -> (fun x -> (x+ 2) + 2) x

fun x -> (x+ 2) + 2

(32)

Autre exemple

Rappel: appel par valeur

fun x -> (fun x -> x+ 2) (x+ 2)

fun x -> (fun x -> (x+ 2) + 2) x

fun x -> (x+ 2) + 2

(33)

Autre exemple

fun x -> (fun x -> x+ 2) (x+ 2)

fun x -> (fun x -> (x+ 2) + 2) x

fun x -> (x+ 2) + 2

(34)

Autre exemple

fun x -> (fun x -> x+ 2) (x+ 2)

fun x -> (fun x -> (x+ 2) + 2) x

fun x -> (x+ 2) + 2

(35)

Autre exemple

fun x -> (fun x -> x+ 2) (x+ 2)

fun x -> (fun x -> (x+ 2) + 2) x

fun x -> (x+ 2) + 2

(36)

Evaluation paresseuse - Haskell

Appel par n´ecessit´e

Variante de l’appel par nom avec partage des sous-termes et des r´eductions correspondantes

Assez proche de l’appel par nom, permet aussi de d´efinir simplement des combinateurs de points fixe typeY

Est implémenté dans le langage fonctionnel Haskell (pas Caml) Haskell langage crée en 1987 et nommé en l’honneur du

logicien Haskell Curry

Plus dur `a compiler efficacement

Plus souple pour le programmeur (exemple: structures de donn´ees infinies)

(37)

Exemple: n´ ecessit´ e (merci JJL!)

(38)

N´ ecessit´ e et structures de donn´ ees infinies

Exemple: en Haskell

numsFrom n = n : numsFrom ( n+1) s q u a r e s =map (\ˆ 2 ) ( numsfrom 0 ) t a k e 5 s q u a r e s=> [ 0 , 1 , 4 , 9 , 1 6 ]

Explication

numsFrom nconstruit une liste infinie d’entiers, commen¸cant enn

square applique la fonction “carr´ee” sur la liste infinie (0,1,2, . . .)

take extrait un préfixe fini: c’est l’évaluationpar nécessité de ce terme qui demande juste ce qu’il faut d’évaluation de la liste infinie numsFrom 0

(39)

Combinateurs de point fixe en Haskell

Exemple

En Haskell, on peut programmer directement (bien que non n´ecessaire!) un combinateur de point fixe (mais pas le code de Y!), qui va terminer:

y ( f ) = f ( y f )

f a c t f n = i f ( n == 0 ) t h e n 1 e l s e n ∗ f ( n−1) y ( f a c t ) 10

. . .

Remarquez les types:

f : α→α

y : (α→α)→(α→α) fact : (int →int)→int →int

(40)

En Caml?

A priori

On ne peut pas coder le combinateurY`a cause de l’appel par valeur (et du typage, cf. plus loin dans ce cours...), mais on peut tricher un peu...

Utiliser une cloture

l e t r e c f i x f x = f ( f i x f ) x

l e t f a c t a b s f a c t =f u n c t i o n 0−>1

| x−> x ∗ f a c t ( x−1) l e t x = ( f i x f a c t a b s ) 5

v a l f i x : ( ( ’ a−> ’ b )−> ’ a−> ’ b )−> ’ a−> ’ b =<f u n>

v a l f a c t a b s : (i n t−> i n t)−> i n t −> i n t =<f u n>

v a l x : i n t = 120

(41)

En Caml?

A priori

On ne peut pas coder le combinateurY`a cause de l’appel par valeur (et du typage, cf. plus loin dans ce cours...), mais on peut tricher un peu...

Utiliser une cloture

l e t r e c f i x f x = f ( f i x f ) x

l e t f a c t a b s f a c t =f u n c t i o n 0−>1

| x−> x ∗ f a c t ( x−1) l e t x = ( f i x f a c t a b s ) 5

v a l f i x : ( ( ’ a−> ’ b )−> ’ a−> ’ b )−> ’ a−> ’ b =<f u n>

v a l f a c t a b s : (i n t−> i n t)−> i n t −> i n t =<f u n>

v a l x : i n t = 120

(42)

En Caml

On peut s’en sortir aussi avec des références, bien sûr, et types récursifs;...

t y p e ’ a r e c c = I n o f ( ’ a r e c c−> ’ a ) l e t o u t ( I n x ) = x

l e t y f = (f u n x a−> f ( o u t x x ) a ) ( I n (f u n x a−> f ( o u t x x ) a ) )

(43)

En Java?

Il faut ˆetre s´erieusement fou...

On utiliser une forme faible des clotures, en utilisant des objets JAVA (interfaces - cf. cours 4)

Pr´eliminaires...

(merci `a Ken Shirriff) c l a s s YFact {

// i n t −> i n t

i n t e r f a c e I n t F u n c { i n t a p p l y (i n t n ) ; } // ( i n t −> i n t ) −> ( i n t −> i n t )

i n t e r f a c e I n t F u n c T o I n t F u n c {

I n t F u n c a p p l y ( I n t F u n c f ) ; };

Cf. poly pour les courageux...

(44)

Le typage, qu’est-ce que c’est?

Int´erˆet

1 torchon + 2 serviettes = ? (donc doit ´eliminer des choses comme (fun x -> x) + 1 etc.)

Et finalement, pas non plusfun x -> x x ni Y! - donc un langage typ´e aura a priori un combinateur de point fixe explicite!

Choix dans les languages

On peut avoir un langage où on déclare les types et où il y a une vérification minimale des types (Java etc.); éventuellement avec règles de transtypage (Java, C etc.): typage faible Ou un langage avec inférence de types (Caml etc.), et où ceux-ci (hors références...) assurent un bon comportement des programmes, minimal - de l’ordre de la preuve (à la Hoare, ou presque) de certaines propriétés de programme

(45)

Bon typage et absence de bug

En quelque sorte...

Le typage est une preuve de coh´erence du programme, tr`es formelle!

Correspondance type et formule de logique / programme de ce type et preuve de cette formule, que l’on va voir bri`evement (isomorphisme de Curry-Howard)

Sûreté du typage Théorème:

Si∅ |=t:τ alors la réduction det est infinie ou se termine sur une valeur (le|= est décrit formellement après: c’est l’inférence que le termet a le typeτ)

(46)

Typage monomorphe/polymorphe

Types monomorphes pour PCF

τ ::= int

| τ →τ

| τ ×τ

Types polymorphes et sch´emas de types

On veut ´eviter d’avoir par exemple une fonction identit´eN→N, de typeR→R, de type (R→R)→(R→R) etc.!:

τ ::= int | bool | . . . types de base

| τ×τ type produit

| τ →τ type d’une fonction

| α variable de type

| ∀α.τ type polymorphe

(47)

Environnements et jugements

Environnement (abstrait!)

Pour typer une expression, on a besoin de la connaissance du typage de l’environnement Env.

Au lieu d’avoir Env = Var→Val, un environnement Γ associe

`

a chaque variable x, un type Γ(x) dans notre grammaire de types

On ´ecrira souvent Γ,x:τ pour l’environnement qui vaut Γ (d´efini sur toutes les variables sauf x), et dans lequelx a le type τ

Jugement de typage

Dans l’environnement Γ, l’expression e (de PCF) a le typeτ se note:

Γ|=e :τ

(48)

R` egles de typage

Variables

Γ|=x: Γ(x) Constantes

Γ|=n :int

Op´erations arithm´etiques

Γ|=s :int Γ|=t :int Γ|=s+t :int etc.

(49)

R` egles de typage, suite

Cr´eation de fonctions

Γ,x :A|=t :B Γ|=fun x -> t:A→B

Application

Γ|=u :A Γ|=v :A→B Γ|=v u:B

(50)

R` egles de typage, suite

Affectation

Γ|=t :A Γ,x:A|=u:B Γ|=let x=t in u :B

Conditionnelle

Γ|=t :int Γ|=u:A Γ|=v :A Γ|=ifz t then u else v :A

(51)

R` egles de typage, suite et fin

Γ,x:A|=t :A Γ|=fix x t :A

Paire

Γ|=u :A Γ|=v :B Γ|= (u,v) :A×B

(52)

Exemple de typage

Terme: let f =fun x -> x+ 1 in f 2

...

x :int |= 1 :int x:int |=x+ 1 :int

∅ |=fun x -> x+ 1 :int→int

...

f :int →int |= 2 :int

∅ |=let f =

fun x -> x+ 1 in f 2 :int

(53)

Algorithme de typage

V´erification de type/inf´erence de type

On a donné des règles pour vérifier que le typage est correct On veut maintenant trouver l’existence

Algorithmes

Algorithme de Hindley (monomorphe) et de Damas-Milner (polymorphe - `a l’origine du typage Caml):

Tout terme de Caml a un type principal (le plus général) L’algorithme est fondé surl’unificationde termes du premier ordre (sorte de résolution d’équation dans une algèbre libre de termes)

Complexité au pire exponentielle, en pratique quasi linéaire L’inférence de types est une forme d’inférence de preuve (cf.

calcul des s´equents, cours 8)

(54)

Remarque (importante!): logique et typage...

On revient aux id´ees du cours 8!

Très proche de la déduction naturelle, dans un fragment de la logique du cours 8 - en fait, présentation d’un fragment intuitioniste par uncalcul de séquents...

Oublions les termes PCF dans certaines r`egles de typages, un instant...

(55)

R` egles de typage - revisit´ ees

Cr´eation de fonctions

Γ,x :A|=t :B Γ|=fun x -> t:A→B

(56)

R` egles de typage - revisit´ ees

Cr´eation de fonctions = (⇒I_d)?

Γ,A`B Γ`A→B Rappel (cours 8)

(⇒I_d) Γ,A`B,∆ Γ`A⇒B,∆ (donc oui, avec ∆ =∅)

(57)

R` egles de typage, suite

Affectation

Γ|=t :A Γ,x:A|=u:B Γ|=let x=t in u :B

(58)

R` egles de typage, suite

Affectation -(cut)?

Γ`A Γ,A`B Γ`B Rappel cours 8

(cut) Γ`A,∆ Γ⁰,A`∆⁰ Γ,Γ⁰ `∆,∆⁰ Donc oui, avec ∆ =∅, Γ⁰ = Γ et ∆⁰=B

(59)

R` egles de typage, suite et fin

Paire

Γ|=u :A Γ|=v :B Γ|= (u,v) :A×B

(60)

R` egles de typage, suite et fin

Paire - (∧I_d)?

Γ`A Γ`B Γ`A∧B Rappel, cours 8

(∧I_d) Γ`A,∆ Γ`B,∆ Γ`A∧B,∆

(61)

Revenons aux produits: curryfication

Lien types produits/types fonctionnels

Une fonction def :X ×Y versZ peut-être considérée comme:

(i) bien sˆur une fonction qui `a un couple de valeurs (x,y), avec x ∈X ety ∈Y, renvoie f(x,y)∈Z

(ii) une fonction de X versY →Z, qui `a unx dansX associe la fonction partielle fx :Y →Z telle quefx(y) =f(x,y)

(iii) un ´el´ement deX×Y →Z (soit une fonction de () (unit) vers X ×Y →Z)

Passer de (i) `a (ii) est “naturel”

On a une fonction (d’ordre sup´erieur)

curry : ((X×Y)→Z)→(X →(Y →Z))

(62)

En Caml

Curryfication

l e t c u r r y f x y = f ( x , y ) ; ;

v a l c u r r y : ( ’ a ∗ ’ b−> ’ c )−> ’ a−> ’ b−> ’ c =<f u n>

D´e-curryfication

l e t u n c u r r y f ( x , y ) = f x y ; ;

v a l u n c u r r y : ( ’ a−> ’ b−> ’ c )−> ’ a ∗ ’ b−> ’ c =<f u n>

Exemple

l e t f ( x , y ) = x+y and g = c u r r y f ; ; v a l f : i n t ∗ i n t −> i n t =<f u n>

v a l g : i n t−> i n t−> i n t =<f u n>

l e t f 5 = g 5 ; ;

v a l f 5 : i n t−> i n t =<f u n>

l e t h x = f u n c t i o n y−> f ( x , y ) and

i = f u n c t i o n x−> f u n c t i o n y−> f ( x , y ) ; ; v a l h : i n t−> i n t−> i n t =<f u n>

v a l i : i n t−> i n t−> i n t =<f u n>

(63)

Evaluation

Autre fonction “naturelle”

eval : (X →Z)×X →Z

qui a toutx de X, et toute fonction deX →Z associe eval(f,x) =f(x) dansZ

l e t e v a l f x = f x ; ;

v a l e v a l : ( ’ a−> ’ b )−> ’ a−> ’ b =<f u n>

(64)

Similarit´ e avec la logique propositionnelle minimale...

“Proofs as programs”

Dans une logique constructive au moins:

“Programme=preuve de son type”

Caml - rappel

l e t c u r r y f x y = f ( x , y ) ; ;

v a l c u r r y : ( ’ a ∗ ’ b−> ’ c )−> ’ a−> ’ b−> ’ c =<f u n>

La fonctioncurry est une preuve de:

((a∧b) =⇒ c) =⇒ (a =⇒ (b =⇒ c))

(65)

curry en Coq

Lemma c u r r y : f o r a l l A B C : Prop , ( ( A/\B)−>C)−>A−>B−>C . P r o o f .

i n t r o s A B C . i n t r o H . i n t r o . i n t r o . a p p l y H .

s p l i t . e x a c t H0 . e x a c t H1 . Qed .

P r i n t c u r r y .

(66)

curry en Coq

c u r r y =

f u n (A B C : Prop ) (H : A/\B−>C) ( H0 : A) ( H1 : B)

=> H ( c o n j H0 H1 ) : f o r a l l A B C : Prop , (A/\B−>C)−>A−>B−>C

(67)

Autre exemple

“Application”

l e t a p p l y = u n c u r r y e v a l ; ;

v a l a p p l y : ( ’ a −> ’ b ) ∗ ’ a−> ’ b =<f u n>

La fonctionapply est une preuve du “modus ponens”:

((a =⇒ b)∧a) =⇒ b

(68)

eval en Coq

Lemma e v a l : f o r a l l A B : Prop , ( A−>B)−>A−>B . P r o o f .

i n t r o s A B . i n t r o H . i n t r o . a p p l y H . e x a c t H0 . Qed .

P r i n t e v a l .

(69)

eval en Coq

f u n (A B : Prop ) (H : A−>B) ( H0 : A)

=> H H0

: f o r a l l A B : Prop , (A−>B)−>A−>B

(70)

De fa¸ con g´ en´ erale

Correspondance de Curry-Howard

Un programme de typet est une preuve det comme suit: (en logiqueintuitioniste)

Terme logique Type informatique Implication type fonctionnel conjonction type produit

disjonction type somme

vrai type unit

faux ⊥(exception/boucle infinie) Les quantificateurs correspondent aux typesd´ependants

(71)

Exemple en Caml

Encore apply...

Supposons qu’on ait les axiomes (=”combinateurs”)eval et uncurry: on peut en d´eduire une preuve constructive dumodus ponens:

(uncurry) ((u =⇒ v) =⇒ w) =⇒ ((u∧v) =⇒ w) en faisantu = (a =⇒ b),v =a,w =b d’o`u:

(((a =⇒ b) =⇒ a) =⇒ b) =⇒ (((a =⇒ b)∧a) =⇒ b) Mais on sait par (eval):

(eval) ((a =⇒ b) =⇒ a) =⇒ b

(72)

Donc:

(uncurry eval) ((a =⇒ b)∧a) =⇒ b

Preuve correspondant `a l’ex´ecution de la composition des fonctions uncurryet eval:

u n c u r r y e v a l ; ;

−: ( ’ a−> ’ b ) ∗ ’ a−> ’ b =<f u n>

(73)

Pour aller plus loin

Réalisabilité, systèmes de types dépendants etc.

Généralisation de la correspondance de Curry-Howard à la logique classique (call-with-current-continuation,

transformationcontinuation passing style)

Certains “grands” théorèmes ont été interprétés comme des programmes (ex. théorèmes de complétude et d’incomplétude de Gödel, forcing de Cohen etc. - par Jean-Louis Krivine) Lien topologie algébrique et certains systèmes de types: cf.

Vladimir Voevodsky (m´edaille Fields 2002)

(74)

C’est tout pour aujourd’hui...

La prochaine fois

Les langages synchrones, r´eseaux de Kahn LUSTRE et la programmation r´eactive Quelques conseils avant les vacances Bon TD!

(75)

C’est tout pour aujourd’hui...

La prochaine fois

Les langages synchrones, r´eseaux de Kahn LUSTRE et la programmation r´eactive Quelques conseils avant les vacances Bon TD!