-calculus.

-calculus

C. Functionele talen basisidee: programmeren = functies bouwen
Het uitrekenen van expressies gebeurt door substitutie een programma definieert een functie (input  output) samenstellen van complexer functies uit eenvoudiger delen: opbouwen van functionele termen eenvoudige datastructuren: lijsten (2 + 3) * ( )  5 * ( )  5 * 6  30 Niet meer verder te “reduceren”: normaalvorm

Haskell: quicksort f [] = [] f (x:xs) = f ys ++ [x] ++ f zs where
ys = [a | a  xs, a  x] zs = [b | b  xs, b > x] Bevat variabelen, lijsten, operators, pattern matching, list comprehension, … 3

-calculus Ingevoerd door Alonzo Church en Stephen Kleene, begin 30-er jaren, als algemeen berekeningsmodel In 1936 gebruikt om een negatief antwoord te geven op het Entscheidungsprobleem: Equivalentie van willekeurige -expressies (equivalent = zelfde functie) is onbeslisbaar Formele basis voor functioneel programmeren: de mechanismen van “echte” functionele talen, zoals Haskell, zijn er “bovenop” gebouwd

-calculus Basis voor denotationele semantiek van programmeertalen (Scott - Strachey): definieer de precieze betekenis (semantiek) van programma’s en programmadelen door middel van een partiële functie die het input-output gedrag beschrijft. Naïeve, ongetypeerde -calculus leidt tot inconsistenties, net zoals de naïeve verzamelingenleer. Dat werd opgelost door de getypeerde -calculus, waarbij elke term een type krijgt. Dit legde de basis voor de studie van typesystemen in het algemeen.

-calculus Syntax: variabelen, -abstractie, functie-applicatie
De fundamentele stap:  - reductie Gebonden en vrije variabelen,  - conversie Combinators, gesloten termen Booleans in de - calculus Integers in de - calculus Recursie, de fixpunt - combinator Y Reductiestrategieën, normal order en applicative order

Syntax De syntax van een -expressie is extreem eenvoudig: er
zijn enkel namen (variabelen), functies (abstracties) en applicaties. < expression > ::= < name > | < function > | < application > < name > ::= x | y | z | ... < function > ::=  < name > . < body > < body > ::= < expression > < application > ::= ( < expression > < expression > )

Expressies De algemene idee is dat een < function> een functiedefinitie voorstelt, met < name > als (enige) formele parameter, en dat in een < application > een functie wordt toegepast op een argument. voorbeelden: x.x (de identiteitsfunctie ) fun.arg.(fun arg) (apply) x.y.y (select second, false) y.(x.(y (x x)) x.(y (x x))) (Y combinator)

Opmerkingen Strict genomen moeten we ook constanten invoeren.
Formeel kunnen we ze behandelen als namen die niet onder een  mogen voorkomen. Voorlopig laten we constanten gewoon buiten beschouwing. Elke expressie (-term) stelt een functie voor.

Opmerkingen Elke expressie (-term) stelt een functie voor.
De kijk op functies is extensioneel: twee functies worden beschouwd als gelijk als ze dezelfde extensie hebben, m.a.w. als ze voor elk argument dezelfde waarde geven. Over de manier waarop die waarde berekend wordt, dus met welk algoritme, zegt dat niets. In de context van programmatransformaties speekt men ook van semantische equivalentie. De vraag of twee termen (extensioneel) met dezeldde functie overeenkomen, is onbeslisbaar (cfr. equivalentieprobleem voor Turing machines).

 - reductie Idee: applicatie van functie x. <body> op
<argument-expressie> = De variabele x speelt dus de rol van formele parameter. Een -expressie wordt uitgewerkt (geëvalueerd) door dit herhaaldelijk te doen, tot er niets meer uit te werken valt: dus tot er geen "redex" (<name>. <body> <arg>) meer te vinden is. expressie bekomen door in <body> de naam x te vervangen door <argument-expressie>.

 - converteerbaarheid
Een expressie M is -converteerbaar (gelijk) aan een expressie N, N = M, als N -congruent (zie verder) is met M, of M  N, of N  M, of er is een -expressie E zodat M = E en E = N. De zo verkregen relatie = is uiteraard een equivalentierelatie.

 - reductie: voorbeelden
( (x.y.x z.z) t)  ( y.z.z t )  z.z (select first) (x.( (f. arg.(f arg) z.z) x) t)  ( (f. arg.(f arg) z.z) t)  ( arg.(z.z arg) t)  ( z.z t)  t (identity_2) Normal order: eerst de functiedefinitie uitwerken

Opmerkingen Er is dus in principe maar één reductieregel nodig!
Expressies worden uitgewerkt door deze reductieregel toe te passen tot er geen geschikt deel van de vorm (x.<body> <argument>) meer gevonden kan worden; de expressie is dan in normaalvorm gebracht. Je zou kunnen verwachten dat het resultaat van een -reductie korter is dan de expressie waarvan je vertrekt, zoals in ( y.( z.w y ) ( x.(x x) x.(x x) ) )  ( z.w ( x.(x x) x.(x x) ) )  w

maar dat hoeft niet zo te zijn:
( x.(x x) x.(x x) )  ( x.(x x) x.(x x) )  … Er zijn dus oneindige reducties mogelijk. We willen dat twee expressies die enkel verschillen doordat de namen na de  verschillen, als gelijk beschouwd worden.

-calculus en concurrency
Het zal blijken dat de volgorde waarin delen van een term (redexes) vervangen worden, er niet toe doet. I.h.b. kunnen verschillende, disjuncte delen van een term dus tegelijk, onafhankelijk van elkaar vervangen worden. Dit berekeningsmodel is daarom geschikt voor het invoeren van parallellisme. Het is mogelijk speciale hardware te bouwen om dit exploiteren, en dat is ook gebeurd (LISP - machine).

 - conversie: het probleem
Bekijk de functie apply == fun.arg.(fun arg). Bedoeling is dat die het eerste argument toepast op het tweede. De namen van de "formele parameters" fun en arg hebben geen belang, dus ook x.y.(x y) stelt apply voor. Maar: ( (apply arg) z) == ( (fun.arg.(fun arg) arg) z)  (arg.(arg arg) z)  (z z) wat niet de bedoeling is

 (y.(arg y) z)  (arg z) . wel goed gaat:
( (apply arg) z) == ( (x.y.(x y) arg) z)  (y.(arg y) z)  (arg z) . De reden waarom het bij ( (fun.arg.(fun arg) arg) z) fout gaat is dat in de eerste stap, waarin arg (de "actuele parameter") gesubstitueerd wordt voor fun, die arg verward wordt met de arg van arg. Als we apply definiëren als x.y.(x y) doet die moeilijkheid zich niet voor. Besluit: we moeten, voor we een functie toepassen, de "formele parameters" eerst vervangen door nieuwe, onschadelijke namen. Deze operatie noemt men een -conversie.

Vrije en gebonden namen
Op een bepaalde plaats in een expressie is een naam x gebonden als hij daar voorkomt in een subterm van de vorm x.P. Anders is x daar vrij. y.(x.(x y) y.(y x)) gebonden ((x y.(y (x y.(y x.(y x))))) x) vrij x. ((x y.(y (x y.(y x.(y x))))) x)

 - congruentie -regel:
x.E  z.{z/x}E, voor elke z die niet voorkomt in E. {z/x}E stelt hier het resultaat voor van de substitutie van z voor x in E. -congruentie: Twee expressies M en N zijn -congruent als ofwel M  N, of M  N, of N wordt verkregen uit M door een subexpressie S ervan te vervangen door een expressie T zo dat S  T, of er is een expressie R zo dat M -congruent is met R en R is -congruent met N.

Reductie, met  - conversie
Bij het uitwerken van een functie-applicatie (x.P Q): voor elke naam y die vrij voorkomt in Q, en die gebonden voorkomt in P, vervang voor het uitwerken de gebonden occurrences van y overal in P door een nieuwe naam y'. bv. in ( (fun.arg.(fun arg) arg) z) : vervang arg door een nieuwe, "ongevaarlijke" naam. Resultaat: ( (fun.arg'.(fun arg') arg) z)

Rekenen in de  - calculus: combinators
Een combinator is een -expressie met enkel gebonden variabelen. Het gedrag van een combinator is daarom onafhankelijk van de context waarin hij optreedt. Constanten (True, 5, AND, +, ...) kunnen voorgesteld worden door combinatoren. x.y.x select_first e1. e2. c.((c e1) e2) cond

 (y.<exp1> <exp2>)  <exp1>
Booleans true == x.y.x select_first false == x.y.y select_second cond == e1. e2. c.((c e1) e2) toegepast op <exp1> en <exp2> geeft: wat, toegepast op true == x.y.x geeft: ((e1. e2. c.((c e1) e2) <exp1>) <exp2>)  (e2. c.((c <exp1>) e2) <exp2>)  c.((c <exp1>) <exp2>) (c.((c <exp1>) <exp2>) x.y.x)  ((x.y.x <exp1>) <exp2>)  (y.<exp1> <exp2>)  <exp1>

Booleans x.(((cond false) true) x) kan vereenvoudigd worden:
en analoog leidt een toepassing op false tot <exp2>. not kan nu gedefinieerd worden als: not == x.((cond false) true) x) want als het derde argument van cond (hier x dus) true is, selecteert cond het eerste van zijn twee argumenten, dus false. Analoog, als het derde argument false is, selecteert het true. x.(((cond false) true) x) kan vereenvoudigd worden: en dus kunnen we gebruiken: not == x.((x false) true) (((e1. e2. c.((c e1) e2) false) true) x)  ((e2. c.((c false) e2) false) true) x)  (c.((c false) true) x)  ((x false) true)

AND de functie X and Y kan gedefinieerd worden als
and == x.y.(((cond y) false) x) want als x true is, dan neemt men de waarde van y over, en als x false is, dan selecteert men false. Het deel (((cond y) false) x) kan weer vereenvoudigd worden, nu tot ((x y) false). We gebruiken dus: and == x.y. ((x y) false) (en or == x.y. ((x true) y) ). bv. voor true and false: ((and true) false) == ((x.y. ((x y) false) true) false)  (y. ((true y) false) false)  ((true false) false)  ...  false

Gehele getallen: Church numerals
We definieren combinatoren die 0,1,2, ... voorstellen: 0 == f.x.x 1 == f.x.(f x) 2 == f.x.(f (f x)) 3 == f.x.(f (f (f x))) enzovoort. De successor-functie kan dan worden: succ == n.f.x.(f ((n f) x)) bv: (succ 1) == (n.f.x.(f ((n f) x)) f.x.(f x))  f.x.(f ((f.x.(f x) f) x))  f.x.(f (x.(f x) x))  f.x.(f (f x)) == 2

Andere bewerkingen plus == m.n.f.x.((m f) ((n f) x))
mult == m.n.f.(m (n f))

Andere bewerkingen plus == m.n.f.x.((m f) ((n f) x))
mult == m.n.f.(m (n f)) sommige zijn behoorlijk complex - ook Church zelf raakte ervan overtuigd dat de predecessor - functie niet voorgesteld kon worden, tot Kleene vond: pred == n.(((n p.z.((z (succ (p true))) (p true))) z.((z 0) 0)) false) In gewone notatie: pred(n) = n -1, als n > 0 0, als n = 0

predecessor - vervolg Deze definitie is gebaseerd op het volgende.
z.((z a) b) stelt het geordende paar [a,b] voor, en heeft de eigenschap (z.((z a) b) true)  a en (z.((z a) b) ) false)  b Dus stelt next == p. z.((z (succ (p true))) (p true)) de functie voor die [n+1,n] berekent uit [n,n-1]: als we voor p het paar [n,n-1] invullen, selecteert (p true) daaruit het eerste element n, en vervolgens vormt men een paar met (succ (p true)) en (p true). De predecessor-functie verkrijgt men door next n keer toe te passen, vertrekkend van het paar [0,0]: z.((z 0) 0) en dan het tweede element te selecteren door de verkregen functie op false toe te passen.

-calculus.

Verwante presentaties

Presentatie over: "-calculus."— Transcript van de presentatie:

Verwante presentaties

Over het project

Feedback

Inloggen

Inloggen via een sociaal netwerk:

-calculus.

Verwante presentaties

Presentatie over: "-calculus."— Transcript van de presentatie:

Verwante presentaties

Over het project

Feedback