Program Language - Fall 2013

Program LanguageProgram Derivation

郗昀彥 (代)

Construction?

Derivation!

Program

Algorithm

Efficient Program

Specification

Algorithm

Specification

Efficient Program

Algorithm

•Hard•Depend on Tools•Correctness by Testing

Efficient Program

Specification

Algorithm

• Straightforward•Math. or Logic

Algorithm

Efficient Program

Specification

•Correctness by Verification•Model Checking•Automata

Algorithm

Efficient Program

Specification • Program Construction•Derivation• Synthesis•Hoare Logic

ProgramDerivation

• fold

• fold fusion

• list homomorphism

• 3rd list homomorphism theorem

In computer science, a list or sequence is an abstract data type that implements a finite ordered collection of values, where the same value may occur more than once.

- wikipedia

1 2 3 4 5

1 2 3 4 5: : : : :

data List a = [] | a : (List a)

1 2 3 4 5 [ ]: : : : :

foldr :: (a → b → b) → b → [a] → bfoldr (◁) e [] = efoldr (◁) e (x : xs) = x ◁ (foldr (◁) e xs)

1 2 3 4 5: : : : :

1 2 3 4 5: : : : : e

1 2 3 4 5: : : : e◁

1 2 3 4 5: : : e◁◁

1 2 3 4 5: : e◁◁◁

1 2 3 4 5: e◁◁◁◁

1 2 3 4 5 e◁◁◁◁◁

sum [1..1000]=>foldr (+) 0 [1..1000]1 + (foldr (+) 0 [2..1000])1 + (2 + (foldr (+) 0 [3..1000]))...1 + (2 + (... + (1000 + (foldr (+) 0 []))...))1 + (2 + (... + (1000 + 0)...)))...1 + (2 + 500497) 1 + 500499 500500

1 + (2 + (... + (1000 + 0)...)))

length :: [a] → Intsum :: (Num a) ⇒ [a] → amap :: (a → b) → [a] → [b]filter :: (a → Bool) → [a] → [a]inits :: [a] → [[a]]concat :: [[a]] → [a]maximum :: (Ord a) ⇒ [a] → a

e ?(◁) ?

1 2 3 4 5 [ ]: : : : :

foldr :: (a → b → b) → b → [a] → bfoldl :: (b → a → b) → b → [a] → bfoldl (▷) e [] = efoldl (▷) e (x : xs) = foldl (▷) (e ▷ x) xs

1 2 3 [ ]: : :

foldl (▷) Para0 Para1

1 2 3 [ ]: : :

e 1▷

1 2 3 [ ]: : :

e 1▷ 2▷

1 2 3 [ ]: : :

e 1▷ 2▷ 3▷

sum [1..1000]=>foldl (+) 0 [1..1000]foldl (+) (0 + 1) [2..1000]foldr (+) (1 + 2) [3..1000]foldr (+) (3 + 3) [4..1000]...foldr (+) (498501 + 999) [1000]foldr (+) (499500 + 1000) []foldr (+) 500500 []500500

length :: [a] → Intsum :: (Num a) ⇒ [a] → amap :: (a → b) → [a] → [b]filter :: (a → Bool) → [a] → [a]concat :: [[a]] → [a]maximum :: (Ord a) ⇒ [a] → a

e ?(▷) ?

fusion

map f ◦ map g

map (f ◦ g)

filter q ◦ filter p

filter (q ∧ p)

foldr-fusion

f ◦ foldr (◁) e

foldr-fusion

⇐ f (x ◁ z) = x ≪ (f z)

foldr (≪) (f e)

f $ foldr (◁) e []= { definition of foldr } f e= { definition of foldr } foldr (≪) (f e) []

foldr-fusion

f ◦ foldr (◁) e = foldr (≪) (f e)

f $ foldr (◁) e (x:xs)= f (x ◁ (foldr (◁) e xs))= { f (x ◁ z) = x ≪ (f z) } x ≪ (f (foldr (◁) e xs))= x ≪ (foldr (≪) (f e) xs)= foldr (≪) (f e) (x:xs)

foldr-fusion

http://www.openrice.com/restaurant/commentdetail.htm?commentid=2106508

範例

inits :: [a] → [[a]]tails :: [a] → [[a]]concat :: [[a]] → [a]filter :: (a → Bool) → [a] → [a]power :: [a] → [[a]]

filter (/=[])◦concat◦map tails◦inits

Suffixes of Prefixes

inits :: [a] → [[a]]inits [] = [[]]inits (x:xs) = [] : map (x:) (inits xs)

inits’ = foldr (\x hs → [] : (map (x:) hs)) [[]]

map tails ◦ inits = f ◦ foldr (◁) [[]] foldr-fusion= foldr (≪) (map tails [[]])= foldr (≪) [[[]]]

1. f = map tails2. (◁) = \x hs → [] : (map (x:) hs)

map tails ◦ inits = f ◦ foldr (◁) [[]] foldr-fusion= foldr (≪) (map tails [[]])= foldr (≪) [[[]]]

1. f = map tails2. (◁) = \x hs → [] : (map (x:) hs)3. (≪) = \x h → [[]] : map (\hs → (x : (head hs)) : hs) h

filter (/=[])◦concat◦foldr (≪) [[[]]]

filter (/=[]) ◦ concat= g ◦ foldr (++) [] foldr-fusion= foldr (⋆) []

1. g = filter (/=[])2. (⋆) = \x h → filter (/=[]) x) ++ h

filter (/=[]) ◦ concat= g ◦ foldr (++) [] foldr-fusion= foldr (⋆) []

1. g = filter (/=[])2. (⋆) = \x h → filter (/=[]) x) ++ h

filter (/=[])◦concat◦foldr (≪) [[[]]]

foldr (⋆) []◦foldr (≪) [[[]]]= foldr (⊙) []

1. (≪) = \x h → [[]] : map (\hs → (x : (head hs)) : hs) h2. (⋆) = \x h → filter (/=[]) x) ++ h

if... foldr (⋆) [] (x ≪ z) = x ⊙ (foldr (⋆) [] z)

foldr (⋆) []◦foldr (≪) [[[]]]= foldr (⊙) []

1. (≪) = \x h → [[]] : map (\hs → (x : (head hs)) : hs) h2. (⋆) = \x h → filter (/=[]) x) ++ h

if... foldr (⋆) [] (x ≪ z) = x ⊙ (foldr (⋆) [] z)

... after 3 hours

fusion

1 2 3: : :

data ConsList a = [] | a : (ConsList a)

1 2 3‡ ‡‡

data SnocList a = [] | (SnocList a) ‡ a

1 2 3‡ ‡‡

f (▷) ee 1▷ 2▷ 3▷

1 2 3‡ ‡‡

e 1▷ 2▷ 3▷

folds (▷) e [] = efolds (▷) e (ys ‡ y) = (folds (▷) e ys) ▷ y

foldr (◁) e [] = efoldr (◁) e (x : xs) = x ◁ (foldr (◁) e xs)

1 2 3‡ ‡‡

e 1▷ 2▷ 3▷

folds (▷) e [] = efolds (▷) e (ys ‡ y) = (folds (▷) e ys) ▷ y

1 2 3: : :

foldl (▷) e [] = efoldl (▷) e (x : xs) = foldl (▷) (e ▷ x) xs

foldl (▷) e [] = efoldl (▷) e (x : xs) = foldl (▷) (e ▷ x) xsfoldl (▷) e (ys ‡ y) = (foldl (▷) e ys) ▷ y

foldr (◁) e [] = efoldr (◁) e (x : xs) = x ◁ (foldr (◁) e xs)

h is foldl with (▷) e: h [] = e h (ys‡y) = (h ys) ▷ y h ◦ (‡y) = (▷ y) ◦ h

h is foldr with (◁) e: h [] = e h (x:xs) = x ◁ (h xs) h ◦ (x:) = (x ◁) ◦ h

interesting... h = foldr (◁) e = foldl (▷) e

if .... ?

thr 11

別管 fold 了你有聽過

List Homomorphism 嗎?!

List Homomorphism

•h (xs ++ ys) = (h xs) ⊕ (h ys)

•h ◦ (++ys) = (⊕ h ys) ◦ h

•... parallel

length :: [a] → Intmaximum :: (Ord a) ⇒ [a] → a

to prove h is homo... thr 11

萬全

3rd List Homo. Theorem

h is a list homomorphism if h can be foldr (◁) e and foldl (▷) efor some (◁), (▷) and e

h ◦ (++ys)={ foldr-fusion, since (++ys) = foldr (∶) ys } foldr (◁) (h ys )={ foldr-fusion (backwards) } (⊕ h ys) ◦ foldr (◁) e = (⊕ h ys) ◦ h

For the second foldr-fusion h ys = e ⊕ h ys and (x ◁ y) ⊕ h ys = x ◁ (y ⊕ h ys)

h ◦ (‡z)={ foldr-fusion, since (‡z) = foldr (∶) [z]} foldr (◁) (h [z])={ foldr-fusion (backwards) } (▷ z) ◦ foldr (◁) e = (▷ z) ◦ h

For the second foldr-fusion z ◁ e = e ▷ z and (x ◁ y) ▷ z = x ◁ (y ▷ z)

h = foldr = foldl

h is homo.

h ys = e ⊕ h ys and (x ◁ y) ⊕ h ys = x ◁ (y ⊕ h ys)

z ◁ e = e ▷ z and (x ◁ y) ▷ z = x ◁ (y ▷ z)

h = foldr = foldl

h is homo.

Requirement 1

Requirement 2

h = foldr = foldl

h is list homo.

requirement 1

requirement 2(◁), (▷)

the way to go

(x ◁ y) ▷ z = = = = == = x ◁ (y ▷ z)

(x ◁ y) ▷ z = x ◁ (y ▷ z)

(x ◁ y) ▷ z = = = = == = x ◁ (y ▷ z)

(1) (▷ z) => (⊕ (h ys))