Reguliere talen nReguliere grammatica: versimpelde Contextvrije grammatica nFinite-state Automaton: andere manier om een taal te beschrijven nReguliere Expressie nog een andere manier Alle drie kunnen ze dezelfde talen beschrijven

Reguliere talen: overzicht RG Definitie 8 +9 DFA Definitie 1 +3 NFA Definitie 4 +6 RE Definitie Stelling 13 Stelling 12 Stelling 7 triviaal ZRG Definitie (11) Stelling 11 triviaal CFG Definitie triviaal onmogelijk Stelling 16 Stelling 17

Drie reguliere talen S  a X |  X  c X | Y Y  b S |  L1 X Y b a c a S c L2 (a (c*) b)* L3 Publieksvraag: welke talen zijn gelijk aan elkaar?

Drie reguliere talen X Y b a c a S c L2 (a (c*) b)* L3 ac zit in L1, maar niet in L2 of L3 L2 en L3 beschrijven dezelfde taal (gebruik stelling 7+17) Geef een DFA en een reguliere expressie voor L1 Geef een reguliere grammatica voor L2 en L3 S  a X |  X  c X | Y Y  b S |  L1

Abu Ja'far Muhammad ibn Musa al-Khwarizmi al-Kitab al-mukhtasar fi Hisab al-jabr w’al-muqabala

Abu Ja'far Muhammad ibn Musa al-Khwarizmi al-Kitab al-mukhtasar fi Hisab al-jabr w’al-muqabala Liber algebrae et almucabala 1140 Algoritmi de numero Indorum uit Khiva het boekuitgebreidover rekenen herstellen vergelijken over het getal van de Indiërs boek

Recursieve functies op lijsten product :: [Int]  Int product [ ]= product (x:xs)= 1 product xs x * and :: [Bool]  Bool and [ ]= and (x:xs)= True and xs x && sum :: [Int]  Int sum [ ]= sum (x:xs)= 0 sum xs x +

Generalisatie: “lijst-totalisator” foldr :: [a]  a foldr (#) e [ ] = foldr (#) e (x:xs)= e foldr (#) e xs x # (a  a  a)  a  zo combineren neutrale waarde

Specialisatie van de generalisatie nAls foldr de generalisatie is van sum, product, en and.... n.... dan zijn sum, product, en and speciale gevallen van foldr product= foldr (*) 1 and= foldr (&&) True sum= foldr (+) 0 or= foldr (||) False concat= foldr (++) [ ]

Zelfgemaakt datatype voor lijsten nMet functies data List a = Cons a (List a) | Nil som :: List Int  Int som (Cons x xs) = x + som xs som Nil = 0 and :: List Bool  Bool and (Cons x xs) = x && and xs and Nil = True length :: List a  Int length (Cons x xs) = 1 + length xs length Nil = 0 foldList :: List a  b foldList (c,n) (Cons x xs) = c x (foldList (c,n) xs) foldList (c,n) Nil = n abbabb (, )  b

Zelfgemaakt datatype voor bomen nMet functies data Tree a = Bin (Tree a) (Tree a) | Leaf a foldTree :: Tree a  b foldTree (b,lf) (Bin le ri) = b (foldTree (b,lf) le) (foldTree (b,lf) ri) foldTree (b,lf) (Leaf x) = lf x bbbbbb (, )  abab foldTree :: (b  b  b, a  b)  Tree a  b foldTree (b,lf) = f where f (Bin le ri) = b (f le) (f ri) f (Leaf x) = lf x

Functies op bomen nSpecialisaties: foldTree :: ( b  b  b, a  b )  Tree a  b countLeafs :: Tree a  Int countLeafs = foldTree ( (+), \x  1 ) sumLeafs :: Tree Int  Int sumLeafs = foldTree ( (+), \x  x ) listLeafs :: Tree a  [a] listLeafs = foldTree ( (++), \x  [x] )

De essentie van Tree-functies countLeafs :: Tree a  Int countLeafs = foldTree ( (+), \x  1 ) countLeafs :: Tree a  Int countLeafs = foldTree countLeafsFuns countLeafsFuns = ( (+), \x  1 ) countLeafsFuns :: ( Int  Int  Int, a  Int ) countLeafsFuns :: TreeAlgebra a Int type TreeAlgebra a b = ( b  b  b, a  b )

Tree, TreeAlgebra en functie foldTree data Tree a = Bin (Tree a) (Tree a) | Leaf a type TreeAlgebra a b = ( b  b  b, a  b ) foldTree :: TreeAlgebra a b  Tree a  b foldTree (b,lf) = f where f (Bin le ri) = b (f le) (f ri) f (Leaf x) = lf x

Voorbeelden van TreeAlgebra type TreeAlgebra a b = ( b  b  b, a  b ) countLeafsFuns :: TreeAlgebra a Int countLeafsFuns = ( (+), \x  1 ) sumLeafsFuns :: TreeAlgebra a Int sumLeafsFuns = ( (+), \x  x ) listLeafsFuns :: TreeAlgebra a [a] listLeafsFuns = ( (++), \x  [x] )

Definitie “een algebra” nEen algebra bestaat uit ueen type ufuncties in een tupel countLeafsFuns :: TreeAlgebra a Int countLeafsFuns = ( (+), \x  1 ) nEen algebra bestaat uit ueen type dat het resultaat is van een fold, die ufuncties in een tupel neerzet in plaats van constructorfuncties nEen algebra voor een datatype bestaat uit ueen type dat het resultaat is van een fold, die ufuncties in een tupel neerzet in plaats van constructorfuncties van dat datatype “carrier set” “semantiek”

Voorbeelden van algebras data Tree a = Bin (Tree a) (Tree a) | Leaf a type TreeAlgebra a b = ( b  b  b, a  b ) data List a = Cons a (List a) | Nil type ListAlgebra a b = ( a  b  b, b ) data Par = Match Par Par | Empty type ParAlgebra b = ( b  b  b, b )

Voorbeelden van algebras data Tree a = Bin (Tree a) (Tree a) | Leaf a type TreeAlgebra a b = ( b  b  b, a  b ) data Expr = Add Expr Expr | Mul Expr Expr | Con Int type ExprAlgebra b = ( b  b  b, b  b  b, Int  b ) data Expr = Add Expr Expr | Mul Expr Expr | Con Int | Var String type ExprAlgebra b = ( b  b  b, b  b  b, Int  b, String  b )

Gebruik van ExprAlgebra data Expr = Add Expr Expr | Mul Expr Expr | Con Int type ExprAlgebra b = ( b  b  b, b  b  b, Int  b ) evalExpr :: Expr  Int evalExpr = foldExpr evalExprAlgebra evalExprAlgebra :: ExprAlgebra Int evalExprAlgebra = ( (+), (*), id )

Definitie van foldExpr data Expr = Add Expr Expr | Mul Expr Expr | Con Int type ExprAlgebra b = ( b  b  b, b  b  b, Int  b ) foldExpr :: ExprAlgebra b  Expr  b foldExpr (a,m,c)= f where f (Add e1 e2)= a(f e1) (f e2) f (Mul e1 e2)= m(f e1) (f e2) f (Con n)= c n

Taal: syntax en semantiek “ * 5 ” Add (Con 3) (Mul (Con 4) (Con 5)) parseExpr evalExpr 23 = start p where p = … … … = fold a where a = (…,…,…,…)

Syntax en semantiek van expressies data Expr = Add Expr Expr | Mul Expr Expr | Con Int type ExprAlgebra b = ( b  b  b, b  b  b, Int  b ) data Expr = Add Expr Expr | Mul Expr Expr | Con Int | Var String type ExprAlgebra b = ( b  b  b, b  b  b, Int  b, String  b ) met variabelen “ * 5 ” “ * x ” Add (Con 3) (Mul (Con 4) (Con 5)) Add (Con 3) (Mul (Con 4) (Var “x”))

Uitrekenen van expressies met variabelen data Expr = Add Expr Expr | Mul Expr Expr | Con Int type ExprAlgebra b = ( b  b  b, b  b  b, Int  b ) evalExpr :: Expr  Int evalExpr = foldExpr evalExprAlgebra where evalExprAlgebra :: ExprAlgebra Int evalExprAlgebra = ( (+), (*), id ) data Expr = Add Expr Expr | Mul Expr Expr | Con Int | Var String type ExprAlgebra b = ( b  b  b, b  b  b, Int  b, String  b ), ???? ) evalExpr :: [(String,Int)]  Expr  Int evalExpr env = foldExpr evalExprAlgebra where evalExprAlgebra :: ExprAlgebra Int evalExprAlgebra = ( (+), (*), id, ???? ), (env ?) ) ((v,w):vws) ? q | v==q = w | otherwise = vws ? q

Syntax en semantiek van expressies data Expr = Add Expr Expr | Mul Expr Expr | Con Int | Var String type ExprAlgebra b = ( b  b  b, b  b  b, Int  b, String  b ) met definities “ * x ” “ * x where x=5*2 ” Add (Con 3) (Mul (Con 4) (Var “x”)) Def “x” (Mul (Con 5) (Con 2)) ( Add (Con 3) (Mul (Con 4) (Var “x”))) data Expr = Add Expr Expr | Mul Expr Expr | Con Int | Var String | Def String Expr Expr type ExprAlgebra b = ( b  b  b, b  b  b, Int  b, String  b, String  b  b  b ) “ let x=5*2 in * x ”

Uitrekenen van expressies met definities evalExpr :: Env  Expr  Int evalExpr env = foldExpr evalExprAlgebra where evalExprAlgebra :: ExprAlgebra Int evalExprAlgebra = ( (+), (*), id, (env?) ) bind x d e = e data Expr = Add Expr Expr | Mul Expr Expr | Con Int | Var String type ExprAlgebra b = ( b  b  b, b  b  b, Int  b, String  b ), bind ) data Expr = Add Expr Expr | Mul Expr Expr | Con Int | Var String | Def String Expr Expr type ExprAlgebra b = ( b  b  b, b  b  b, Int  b, String  b, String  b  b  b ) maar dan in een environment waarin x aan d gebonden is…

Uitrekenen van expressies, poging #2 data Expr = Add Expr Expr | Mul Expr Expr | Con Int | Var String type ExprAlgebra b = ( b  b  b, b  b  b, Int  b, String  b ) evalExpr :: Env  Expr  Int evalExpr env = foldExpr eAlgebra where eAlgebra :: ExprAlgebra Int eAlgebra = ( (+), (*), id, (env?) ) evalExpr :: Env  Expr  Int evalExpr env exp = foldExpr eAlgebra exp where eAlgebra :: ExprAlgebra Int eAlgebra = ( (+), (*), id, (env?) ) evalExpr :: Env  Expr  Int evalExpr env exp = foldExpr eAlgebra exp where eAlgebra :: ExprAlgebra Int eAlgebra = ( add, mul, con, var ) evalExpr :: Env  Expr  Int evalExpr env exp = foldExpr eAlgebra exp env where eAlgebra :: ExprAlgebra (Expr  Int) eAlgebra = ( add, mul, con, var ) evalExpr :: Expr  Env  Int evalExpr exp env = foldExpr eAlgebra exp env where eAlgebra :: ExprAlgebra (Expr  Int) eAlgebra = ( add, mul, con, var ) evalExpr :: Expr  Env  Int evalExpr = foldExpr eAlgebra where eAlgebra :: ExprAlgebra (Expr  Int) eAlgebra = ( add, mul, con, var ) (Env  Int)

Uitrekenen van expressies, poging #2 evalExpr :: Expr  Env  Int evalExpr = foldExpr evalExprAlgebra where evalExprAlgebra :: ExprAlgebra Int evalExprAlgebra = data Expr = Add Expr Expr | Mul Expr Expr | Con Int | Var String | Def String Expr Expr type ExprAlgebra b = ( b  b  b, b  b  b, Int  b, String  b, String  b  b  b ) (Env  Int) ( add, mul, con, var, def ) add :: b  b  b (Env  Int) Env  Int add f g e =f e + g e

Uitrekenen van expressies, poging #2 add :: b  b  b add f g e = f e + g e (Env  Int) Env  Int mul :: b  b  b (Env  Int) Env  Int con :: Int  b Env  Int var :: String  b Env  Int def :: String  b  b  b (Env  Int) Env  Int mul f g e =f e * g e con n e =n var x e =e ? x def x f g e =g e(x, )( : )f e con = const var = flip (?) def = ( )

Compositionaliteit nEen semantiek is compositioneel als de betekenis van een geheel een functie is van de betekenissen van de delen eval (Add x y) = add (eval x) (eval y)

Compositionaliteit nEen compositionele semantiek kun je schrijven als fold over de expressie waarbij een algebra vervangingen geeft voor de constructoren data Expr = … | … | … | … eval:: Expr  Int eval= foldExpr alg alg:: ExprAlgebra Int alg= ( …, …, …, … )