Cours 1: Algèbre initiale

Algèbre intiale (pour un foncteur)

Soit une catégorie et F: un foncteur.

Une F-algèbre:

est une paire (A,α)A et α:FAA

Un morphisme de F-algèbres (A,α)(B,β):

est un morphisme f:AB tq le diagramme suivant commute: FAαFfAfFBβB

On note Alg(F) la catégorie des F-algèbres.

Algèbre initiale pour F:

un objet initial de Alg(F): (Z,ζ), avec ζ:FZZ tel que (A,α) F-algèbre !iA:(Z,ζ)(A,α)

Prop: Soit (Z,ζ) une F-alg initiale. Alors (FZ,Fζ)(Z,ζ)

NB: en un certain sens, c’est le plus petit point fixe de F.

Structures libres

Structure libre:

est un n-uplet (T,c1,,cn)

  • TSet
  • ci:θi(T)T pour des foncteurs θ1,,θn:SetSet donnés

tq (T,[c1,,cn]) est la (θ1++θn)-algèbre initiale

Co-pairing de f:AC,g:BC:

[f,g]:A+BC (définition par cas, fonction donnée par la propriété universelle du coproduit)

Donc [c1,,cn]:θ1(T)++θn(T)(θ1++θn)(T)T

En théorie des types: θi(X)θik1(X)××θiki(X)

Que signifie le caractère initial?

Point fixe:

T(θ1++θn)(T)

Donc tout xT s’écrit ci(y)θi(T)i{1,,n} et yT sont uniques.

Ex:

  • θ1id:SetSet
  • θ21:SetSet
(θ1+θ2)(A)=(id+1)(A)=A+1A plus un autre élément 

Algèbre initiale: l’ensemble

  • θ2 est le constructeur zéro
  • θ1 est le constructeur successeur

Clôture par id+1 ⟹ on a tous les entiers

Les entiers dans le système F

NatX.(XX)XX

Lemme: les termes normaux de type Nat sont de la forme

  1. nΛX.λsXX.λzX.sn(z)

    c’est-à-dire les entiers de Church!

  2. ou l’identité ΛX.λfXX.fηΛX.λfXX.λxX.fx
Rappel: η-équivalence:
Mηλx.Mx

Système T

M,N:=xλx.MMN0SNif z then P else x.MM,NπiMiter(N,x.M,P)

  • iter(0,M,P)P

  • iter(SN,M,P)M[iter(N,M,P)/x]

i.e.

ΓN:NatΓ,x:AM:AΓP:AΓiter(N,x.M,P):A

Système T dans le système F

Γ0:Nat

c’est clair car tous les entiers de Church sont de type Nat


ΓN:NatΓSN:Nat

Vérifions que

succλnNat.(ΛX.λsXX.λzX.nXs(sz)):NatNat ΓN:NatΓsucc:NatNatΓsuccN:Nat
  • 0A(λxA.M)P:P
  • n+1A(λxA.M)P(λxA.M)((λxA.M)P))(λxA.M)(iter(n,M,P))M[iter(n,M,P)/x]
predλnNat.π1(n(Nat×Nat)(λpNat×Nat.π2p,succ(π2p))0,0) boolX.XXX Γb:boolΓP:AΓM:AΓif b then P else M:A trueΛX.λxX.λyX.xfalseΛX.λxX.λyX.yif b then P else MbAPM isZeroλnNat.nBool(λkBool.false)true:NatBool

Puis: règle du “if zero”

Donc système F contient le système T.

Par un argument diagonal: un langage de programmation total ne peut pas exprimer toutes les fonctions récursives totales.


Système de réécriture (faiblement) normalisant:

ssi pour tout M, il existe N normal (plus de réduction possible) tq MN (mais: il se pourrait qu’il existe une stratégie de réduction qui ne termine pas)

Ex: λ-calcul pas normalisant ⟹ cf. Ωδδ(λx.xx)(λx.xx)Ω

Gödel a introduit le système T pour réduire la cohérence de l’arithmétique de Peano à la normalisation de ce système

Gödel: Normalisation du système T ⟹ cohérence de PA

Fortement normalisant:

ssi il n’existe pas de chemin de réécriture infini partant de M (le graphe de réduction de tout terme est fini)

Confluence:

il existe au plus une forme normale.

Girard: Normalisation (faible) du système F ⟹ cohérence de PA2

En fait: systèmes T et F sont fortement normalisants, mais on ne va montrer que leur normalisation faible.

Système de réécriture du système F

  • (λxA.M)NM[N/x]
  • (ΛX.M)AM[A/X]

La deuxième règle ne “fait rien”, on peut la vérifier sans à l’extérieur du système F.

Réductibilité (Tait)

  • λ-calcul simplement typé ⟶ logique propositionelle
Types pour le λ-calcul simplement typé:
A,B:=XAB

Candidats de réductibilité

On définit un prédicat sur les types: l’ensemble des termes réductibles de type A.

Red(X)WNX{M:XM normalisant}(WN = weakly normalisable)Red(AB){M:ABNRed(A),MNRed(B)}
Un terme est neutre:

s’il n’est pas une abstraction (soit une variable, soit une application)

NB: on ne crée pas de nouveaux rédex quand on remplace les termes neutres par une variable

NNA{M:AM normal et neutre}

Lemme 1: Pour tout type A,

NNARed(A)WNA

Lemme 2 (Adéquation):

Si x1:C1,,xn:CnM:A est dérivable, alors pour tout i{1,,n}, NiRed(Ci), on a M[N1/x1,,Nn/xn]Red(A)

Attention: pour démontrer l’adéquation, on fait une induction qui dépend de types arbitrairement complexes ⟶ pas de borne sur les formules sur lesquelles on applique l’induction ⟹ ne marchera pas pour le système T à l’intérieur du système T (mais fonctionne dans le système F, au second ordre).

Conséquence: le λ-calcul simplement typé est faiblement normalisant, puisque que c’est le cas de toutes les variables, et on conclut par induction.

Pour le système F

Red(X.A){M:X.AB,MBRed(A[B/X])}

MAIS: définition circulaire !!! Pas bien fondée ⟶ A[B/X] n’est pas “plus petit” que A

Leave a comment