14 KiB

Raw Blame History

jupyter

jupytext

kernelspec

formats

text_representation

ipynb,md

extension	format_name	format_version	jupytext_version
.md	markdown	1.2	1.6.0

display_name	language	name
Python 3	python	python3

$\lambda$-calcul

from lambda_calcul import Lambda_terme

Voici la grammaire du langage décrivant les $\lambda$-termes

term ::= VAR | LAMBDA VAR POINT term | LPAR term term RPAR

La classe `Lambda_terme`

T1 = Lambda_terme("x")
T2 = Lambda_terme("(x x)")
T3 = Lambda_terme("!x.x")
T4 = Lambda_terme('!x.(x x)')
T5 = Lambda_terme('(!x.(x y) z)')

print(T1)
print(T2)
print(T3)
print(T4)
print(T5)

termes = (T1, T2, T3, T4, T5)

tuple(t.est_variable() for t in termes)

tuple(t.est_abstraction() for t in termes)

tuple(t.est_application() for t in termes)

tuple(t.est_redex() for t in termes)

tuple(t.est_forme_normale() for t in termes)

tuple(t.variables_libres() for t in termes)

print(T1, '-->', T1.subs('y', Lambda_terme('(y x)')))
print(T1, '-->', T1.subs('x', Lambda_terme('(y x)')))

T5 = Lambda_terme('!x.y')
print(T5, '-->', T5.subs('x', Lambda_terme('(y z)')))
print(T5, '-->', T5.subs('y', Lambda_terme('(t z)')))
print(T5, '-->', T5.subs('y', Lambda_terme('(x z)')))

print(T3, '-->', T3.subs('y', Lambda_terme('(y x)')))
print(T3, '-->', T3.subs('x', Lambda_terme('(y x)')))

for t in termes:
    for v in ('x', 'y'):
        print(t.abstrait(v))

for t1 in termes:
    for t2 in termes:
        print(t1.applique(t2))

OMEGA = Lambda_terme('(!x.(x x) !x.(x x))')

print(OMEGA)

OMEGA.est_redex()

OMEGA.est_forme_normale()

OMEGA.variables_libres()

res, est_red = OMEGA.reduit()
print(res)
print(est_red)

res, est_red = Lambda_terme('(!x.(eric x) vero)').reduit()
print(res, est_red)

OMEGA.forme_normale(nb_etapes_max=10, verbose=True)

Entiers, successeurs, addition, multiplication et exponentiation

ZERO = Lambda_terme('!f.!x.x')

UN = Lambda_terme('!f.!x.(f x)')

DEUX = Lambda_terme('!f.!x.(f (f x))')

SUC = Lambda_terme('!n.!f.!x.(f ((n f) x))')

TROIS = SUC.applique(DEUX).forme_normale(verbose=True)

TROIS.applique(SUC).applique(ZERO).forme_normale(verbose=True)

ADD = Lambda_terme('!n.!m.!f.!x.((n f) ((m f) x))')

QUATRE = ADD.applique(UN).applique(TROIS).forme_normale(verbose=True)

CINQ = ADD.applique(TROIS).applique(DEUX).forme_normale(verbose=True)

SEPT = ADD.applique(QUATRE).applique(TROIS).forme_normale(verbose=True)

MUL = Lambda_terme('!n.!m.!f.(n (m f))')

SIX = MUL.applique(DEUX).applique(TROIS).forme_normale(verbose=True)

EXP = Lambda_terme('!n.!m.(m n)')

HUIT = EXP.applique(DEUX).applique(TROIS).forme_normale(verbose=True)

NEUF = EXP.applique(TROIS).applique(DEUX).forme_normale(verbose=True)

Booléens, opérateurs logiques et conditionnelles

VRAI = Lambda_terme('!x.!y.x')

FAUX = Lambda_terme('!x.!y.y')

COND = Lambda_terme('!c.!a.!s.((c a) s)')

COND.applique(VRAI).applique(UN).applique(DEUX).forme_normale(verbose=True)

COND.applique(FAUX).applique(UN).applique(DEUX).forme_normale(verbose=True)

ET = COND.applique(Lambda_terme('a')).applique(Lambda_terme('b')).applique(FAUX).abstrait('b').abstrait('a')

print(ET)

ET.applique(VRAI).applique(VRAI).forme_normale(verbose=True)

ET.applique(VRAI).applique(FAUX).forme_normale(verbose=True)

ET.applique(FAUX).applique(VRAI).forme_normale(verbose=True)

ET.applique(FAUX).applique(FAUX).forme_normale(verbose=True)

OU = COND.applique(Lambda_terme('a')).applique(VRAI).applique(Lambda_terme('b')).abstrait('b').abstrait('a')

print(OU)

OU.applique(VRAI).applique(VRAI).forme_normale(verbose=True)

OU.applique(VRAI).applique(FAUX).forme_normale(verbose=True)

OU.applique(FAUX).applique(VRAI).forme_normale(verbose=True)

OU.applique(FAUX).applique(FAUX).forme_normale(verbose=True)

NON = COND.applique(Lambda_terme('a')).applique(FAUX).applique(VRAI).abstrait('a')

print(NON)

NON.applique(VRAI).forme_normale(verbose=True)

NON.applique(FAUX).forme_normale(verbose=True)

NUL = Lambda_terme('!n.((n !x.{:s}) {:s})'.format(str(FAUX), str(VRAI)))

print(NUL)

NUL.applique(ZERO).forme_normale(verbose=True)

NUL.applique(TROIS).forme_normale(verbose=True)

Couples

CONS = Lambda_terme('!x.!y.!s.((({:s} s) x) y)'.format(str(COND)))

print(CONS)

UN_DEUX = CONS.applique(UN).applique(DEUX).forme_normale(verbose=True)

CAR = Lambda_terme('!c.(c {:s})'.format(str(VRAI)))

print(CAR)

CAR.applique(UN_DEUX).forme_normale(verbose=True)

CDR = Lambda_terme('!c.(c {:s})'.format(str(FAUX)))

print(CDR)

CDR.applique(UN_DEUX).forme_normale(verbose=True)

M_PRED = Lambda_terme('!n.(CAR ((n !c.((CONS (CDR c)) (SUC (CDR c)))) ((CONS ZERO) ZERO)))')
print(M_PRED)
PRED = M_PRED.subs('CAR', CAR).subs('CONS', CONS).subs('CDR', CDR).subs('SUC', SUC).subs('ZERO', ZERO)
print(PRED)

PRED.applique(DEUX).forme_normale(verbose=True)

PRED.applique(ZERO).forme_normale(verbose=True)

M_SUB = Lambda_terme('!n.!m.((m PRED) n)')
print(M_SUB)
SUB = M_SUB.subs('PRED', PRED)
print(SUB)

SUB.applique(TROIS).applique(UN).forme_normale(verbose=True)

M_INF = Lambda_terme('!n.!m.(NUL ((SUB n) m))')
print(M_INF)
INF = M_INF.subs('NUL', NUL).subs('SUB', SUB)

print(INF.applique(TROIS).applique(UN).forme_normale())

print(INF.applique(UN).applique(TROIS).forme_normale())

print(INF.applique(UN).applique(UN).forme_normale())

M_EGAL = Lambda_terme('!n.!m.((ET ((INF n) m)) ((INF m) n))')
print(M_EGAL)
EGAL = M_EGAL.subs('ET', ET).subs('INF', INF)
print(EGAL)

print(EGAL.applique(UN).applique(UN).forme_normale())

print(EGAL.applique(UN).applique(DEUX).forme_normale())

Itération

M_FACTv1 = Lambda_terme('!n.(CDR ((n !c.((CONS (SUC (CAR c))) ((MUL (SUC (CAR c))) (CDR c)))) ((CONS ZERO) UN)))')
print(M_FACTv1)
FACTv1 = M_FACTv1.subs('CONS', CONS).subs('CAR', CAR).subs('CDR', CDR).subs('SUC', SUC).subs('MUL', MUL).subs('UN', UN).subs('ZERO', ZERO)
print(FACTv1)

print(FACTv1.applique(ZERO).forme_normale())

print(FACTv1.applique(UN).forme_normale())

print(FACTv1.applique(DEUX).forme_normale())

print(FACTv1.applique(DEUX).forme_normale(nb_etapes_max=200))

print(FACTv1.applique(TROIS).forme_normale(nb_etapes_max=500))

print(FACTv1.applique(QUATRE).forme_normale(nb_etapes_max=1700))

Et la récursivité ?

M_PHI_FACT = Lambda_terme('!f.!n.(((COND ((EGAL n) ZERO)) UN) ((MUL n) (f (PRED n))))')
print(M_PHI_FACT)
PHI_FACT = M_PHI_FACT.subs('COND', COND).subs('EGAL', EGAL).subs('ZERO', ZERO).subs('UN', UN).subs('MUL', MUL).subs('PRED', PRED)
print(PHI_FACT)

BOTTOM = Lambda_terme('!y.OMEGA').subs('OMEGA', OMEGA)
print(BOTTOM)

FACT0 = PHI_FACT.applique(BOTTOM)

print(FACT0.applique(ZERO).forme_normale())

FACT0.applique(UN).forme_normale(verbose=True, nb_etapes_max=40)

FACT1 = PHI_FACT.applique(FACT0)

print(FACT1.applique(ZERO).forme_normale())

print(FACT1.applique(UN).forme_normale(nb_etapes_max=200))

FIX_CURRY = Lambda_terme('!f.(!x.(f (x x)) !x.(f (x x)))')
print(FIX_CURRY)

FACTv2 = FIX_CURRY.applique(PHI_FACT)

print(FACTv2.applique(ZERO).forme_normale())

print(FACTv2.applique(UN).forme_normale(nb_etapes_max=200))

print(FACTv2.applique(DEUX).forme_normale(nb_etapes_max=700))

print(FACTv2.applique(TROIS).forme_normale(nb_etapes_max=4000))

print(FACTv2.applique(QUATRE).forme_normale(nb_etapes_max=25000))

PF = FIX_CURRY.applique(Lambda_terme('M'))

PF.forme_normale(verbose=True, nb_etapes_max=10)

$\lambda$-calcul avec les lambda-expressions de Python

Les entiers de Church

zero = lambda f: lambda x: x

un = lambda f: lambda x: f(x)

deux = lambda f: lambda x: f(f(x))

trois = lambda f: lambda x: f(f(f(x)))

def entier_church_en_int(ec):
    return ec(lambda n: n+1)(0)

tuple(entier_church_en_int(n) for n in (zero, un, deux, trois))

suc = lambda n: lambda f: lambda x: f(n(f)(x))

tuple(entier_church_en_int(suc(n)) for n in (zero, un, deux, trois))

def int_en_entier_church(n):
    if n == 0:
        return zero
    else:
        return suc(int_en_entier_church(n - 1))

tuple(entier_church_en_int(int_en_entier_church(n)) for n in range(10))

add = lambda n: lambda m: lambda f: lambda x: n(f)(m(f)(x))

cinq = add(deux)(trois)
entier_church_en_int(cinq)

mul = lambda n: lambda m: lambda f: n(m(f))

six = mul(deux)(trois)
entier_church_en_int(six)

exp = lambda n: lambda m: m(n)

huit = exp(deux)(trois)
entier_church_en_int(huit)

Les booléens

vrai = lambda x: lambda y: x
faux = lambda x: lambda y: y

def booleen_en_bool(b):
    return b(True)(False)

tuple(booleen_en_bool(b) for b in (vrai, faux))

cond = lambda c: lambda a: lambda s: c(a)(s)

cond(vrai)(1)(2)

cond(faux)(1)(2)

cond(vrai)(1)(1/0)

non = lambda b: cond(b)(faux)(vrai)

tuple(booleen_en_bool(non(b)) for b in (vrai, faux))

et = lambda b1: lambda b2: cond(b1)(b2)(faux)

tuple(booleen_en_bool(et(b1)(b2)) for b1 in (vrai, faux) for b2 in (vrai, faux))

ou = lambda b1: lambda b2: cond(b1)(vrai)(b2)

tuple(booleen_en_bool(ou(b1)(b2)) for b1 in (vrai, faux) for b2 in (vrai, faux))

est_nul = lambda n : n(lambda x: faux)(vrai)

tuple(booleen_en_bool(est_nul(n)) for n in (zero, un, deux, trois, cinq, six, huit))

Les couples

cons = lambda x: lambda y: lambda z: z(x)(y)

un_deux = cons(un)(deux)

car = lambda c: c(vrai)
cdr = lambda c: c(faux)

entier_church_en_int(car(un_deux)), entier_church_en_int(cdr(un_deux))

pred = lambda n: car(n(lambda c: cons(cdr(c))(suc(cdr(c))))(cons(zero)(zero)))

tuple(entier_church_en_int(pred(int_en_entier_church(n))) for n in range(10))

sub = lambda n: lambda m: m(pred)(n)

entier_church_en_int(sub(huit)(trois))

est_inf_ou_egal = lambda n: lambda m: est_nul(sub(m)(n))

tuple(booleen_en_bool(est_inf_ou_egal(cinq)(int_en_entier_church(n))) for n in range(10))

est_egal = lambda n: lambda m: et(est_inf_ou_egal(n)(m))(est_inf_ou_egal(m)(n))

tuple(booleen_en_bool(est_egal(cinq)(int_en_entier_church(n))) for n in range(10))

Itération

fact = lambda n: cdr(n(lambda c: (cons(suc(car(c)))(mul(suc(car(c)))(cdr(c)))))(cons(zero)(un)))

tuple(entier_church_en_int(fact(int_en_entier_church(n))) for n in range(7))

Combinateur de point fixe

phi_fact = lambda f: lambda n: 1 if n == 0 else n*f(n-1)

bottom = lambda x: (lambda y: y(y))(lambda y:y(y))

f0 = phi_fact(bottom)
f1 = phi_fact(f0)
f2 = phi_fact(f1)
f3 = phi_fact(f2)
f4 = phi_fact(f3)

tuple(f4(n) for n in range(4))

def fact_rec(n):
    if n == 0:
        return 1
    else:
        return n * fact_rec(n - 1)

fact2 = phi_fact(fact_rec)

tuple(fact2(n) for n in range(7))

fix_curry = lambda f: (lambda x: lambda y: f(x(x))(y))(lambda x: lambda y: f(x(x))(y))

fact3 = fix_curry(phi_fact)

tuple(fact3(n) for n in range(7))

Un programme obscur

print((lambda x: (lambda y: lambda z: x(y(y))(z))(lambda y: lambda z: x(y(y))(z))) 
      (lambda x: lambda y: '' if y == [] else chr(y[0])+x(y[1:]))
      (((lambda x: (lambda y: lambda z: x(y(y))(z)) (lambda y: lambda z: x(y(y))(z)))
        (lambda x: lambda y: lambda z: [] if z == [] else [y(z[0])]+x(y)(z[1:])))      
       (lambda x: (lambda x: (lambda y: lambda z: x(y(y))(z))(lambda y: lambda z: x(y(y))(z)))
        (lambda x: lambda y: lambda z: lambda t: 1 if t == 0 else (lambda x: ((lambda u: 1 if u == 0 else z)(t % 2)) * x * x % y)
         (x(y)(z)(t // 2)))(989)(x)(761))
       ([377, 900, 27, 27, 182, 647, 163, 182, 390, 27, 726, 937])))

phiListEnChaine = lambda x: lambda y: '' if y == [] else chr(y[0]) + x(y[1:])

fix_curry(phiListEnChaine)([65+k for k in range(26)])

phiMap = lambda x: lambda y: lambda z: [] if z == [] else [y(z[0])] + x(y)(z[1:])

fix_curry(phiMap)(lambda x: x*x)([1, 2, 3, 4])

phiExpoMod = lambda x: lambda y: lambda z: lambda t: 1 if z == 0 else (lambda u: 1 if u == 0 else y)(z % 2) * x(y)(z//2)(t) ** 2 % t

fix_curry(phiExpoMod)(2)(10)(1000)

14 KiB Raw Blame History

$\lambda$-calcul

La classe Lambda_terme

Entiers, successeurs, addition, multiplication et exponentiation

Booléens, opérateurs logiques et conditionnelles

Couples

Itération

Et la récursivité ?

$\lambda$-calcul avec les lambda-expressions de Python

Les entiers de Church

Les booléens

Les couples

Itération

Combinateur de point fixe

Un programme obscur

14 KiB

Raw Blame History

La classe `Lambda_terme`