3hrs sharing for program derivation

1. Program Language
Program Derivation
郗昀彥 (代)

3. 3
Construction?
Derivation!
Program

4. 4
Algorithm

5. 5
Efficient Program
Specification
Algorithm

6. 6
Specification
Efficient Program
Algorithm
•Hard
•Depend on Tools
•Correctness by Testing

7. 7
Efficient Program
Specification
Algorithm
•Straightforward
•Math. or Logic

8. 8
Algorithm
Efficient Program
Specification
•Correctness by Verification
•Model Checking
•Automata

9. 9
Algorithm
Efficient Program
Specification •Program Construction
•Derivation
•Synthesis
•Hoare Logic

10. 10
Program
Derivation

11. 11
•fold
•fold fusion
•list homomorphism
•3rd list homomorphism theorem

12. foldr

13. 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

14. 1 2 3 4 5
1 2 3 4 5: : : : :
data List a = []
| a : (List a)

15. 1 2 3 4 5 [ ]: : : : :
foldr :: (a → b → b) → b →
[a] → b
foldr (◁) e [] = e
foldr (◁) e (x : xs) =
x ◁ (foldr (◁) e xs)

16. 1 2 3 4 5: : : : :
foldr :: (a → b → b) → b →
[a] → b
foldr (◁) e [] = e
foldr (◁) e (x : xs) =
x ◁ (foldr (◁) e xs)
[ ]

17. 1 2 3 4 5: : : : :
foldr :: (a → b → b) → b →
[a] → b
foldr (◁) e [] = e
foldr (◁) e (x : xs) =
x ◁ (foldr (◁) e xs)
[ ]

18. 1 2 3 4 5: : : : :
foldr :: (a → b → b) → b →
[a] → b
foldr (◁) e [] = e
foldr (◁) e (x : xs) =
x ◁ (foldr (◁) e xs)
[ ]

19. 1 2 3 4 5: : : : :
foldr :: (a → b → b) → b →
[a] → b
foldr (◁) e [] = e
foldr (◁) e (x : xs) =
x ◁ (foldr (◁) e xs)
[ ]

20. 1 2 3 4 5: : : : :
foldr :: (a → b → b) → b →
[a] → b
foldr (◁) e [] = e
foldr (◁) e (x : xs) =
x ◁ (foldr (◁) e xs)
[ ]

21. 1 2 3 4 5: : : : : e
foldr :: (a → b → b) → b →
[a] → b
foldr (◁) e [] = e
foldr (◁) e (x : xs) =
x ◁ (foldr (◁) e xs)

22. 1 2 3 4 5: : : : e◁
foldr :: (a → b → b) → b →
[a] → b
foldr (◁) e [] = e
foldr (◁) e (x : xs) =
x ◁ (foldr (◁) e xs)

23. 1 2 3 4 5: : : e◁◁
foldr :: (a → b → b) → b →
[a] → b
foldr (◁) e [] = e
foldr (◁) e (x : xs) =
x ◁ (foldr (◁) e xs)

24. 1 2 3 4 5: : e◁◁◁
foldr :: (a → b → b) → b →
[a] → b
foldr (◁) e [] = e
foldr (◁) e (x : xs) =
x ◁ (foldr (◁) e xs)

25. 1 2 3 4 5: e◁◁◁◁
foldr :: (a → b → b) → b →
[a] → b
foldr (◁) e [] = e
foldr (◁) e (x : xs) =
x ◁ (foldr (◁) e xs)

26. foldr :: (a → b → b) → b →
[a] → b
foldr (◁) e [] = e
foldr (◁) e (x : xs) =
x ◁ (foldr (◁) e xs)
1 2 3 4 5 e◁◁◁◁◁

27. 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

28. 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

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

30. length :: [a] → Int
sum :: (Num a) ⇒ [a] → a
map :: (a → b) → [a] → [b]
filter :: (a → Bool) → [a] → [a]
inits :: [a] → [[a]]
concat :: [[a]] → [a]
maximum :: (Ord a) ⇒ [a] → a
e ?
(◁) ?

31. foldl

32. 1 2 3 4 5 [ ]: : : : :
foldr :: (a → b → b) → b → [a] → b
foldl :: (b → a → b) → b → [a] → b
foldl (▷) e [] = e
foldl (▷) e (x : xs) =
foldl (▷) (e ▷ x) xs

33. 1 2 3 [ ]: : :
foldl (▷) Para0 Para1
{
{
e

34. 1 2 3 [ ]: : :
foldl (▷) Para0 Para1
{
{
e 1▷

35. 1 2 3 [ ]: : :
foldl (▷) Para0 Para1
{
{
e 1▷ 2▷

36. 1 2 3 [ ]: : :
foldl (▷) Para0 Para1
{
{
e 1▷ 2▷ 3▷

37. 13
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

38. 13
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

40. length :: [a] → Int
sum :: (Num a) ⇒ [a] → a
map :: (a → b) → [a] → [b]
filter :: (a → Bool) → [a] → [a]
concat :: [[a]] → [a]
maximum :: (Ord a) ⇒ [a] → a
e ?
(▷) ?

41. fusion

42. 42
map f ◦ map g

43. 42
map (f ◦ g)

44. 43
filter q ◦ filter p

45. 43
filter (q ∧ p)

46. 44
foldr-fusion
f ◦ foldr (◁) e

47. 44
foldr-fusion
⇐ f (x ◁ z) = x ≪ (f z)
foldr (≪) (f e)

48. 45
f $ foldr (◁) e []
= { definition of foldr }
f e
= { definition of foldr }
foldr (≪) (f e) []
foldr-fusion
f ◦ foldr (◁) e = foldr (≪) (f e)

49. 46
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
f ◦ foldr (◁) e = foldr (≪) (f e)

50. 47
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
f ◦ foldr (◁) e = foldr (≪) (f e)

51. 48
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
f ◦ foldr (◁) e = foldr (≪) (f e)

52. 49
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
f ◦ foldr (◁) e = foldr (≪) (f e)

53. 50
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
f ◦ foldr (◁) e = foldr (≪) (f e)

54. 51
http://www.openrice.com/restaurant/
commentdetail.htm?commentid=2106508
範例

55. 52
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

56. 53
inits :: [a] → [[a]]
inits [] = [[]]
inits (x:xs) = [] : map (x:) (inits xs)
filter (/=[])◦concat◦map tails◦inits
Suffixes of Prefixes

57. 54
inits :: [a] → [[a]]
inits [] = [[]]
inits (x:xs) = [] : map (x:) (inits xs)
inits’ =
foldr (x hs → [] : (map (x:) hs)) [[]]
filter (/=[])◦concat◦map tails◦inits
Suffixes of Prefixes

58. 55
filter (/=[])◦concat◦map tails◦inits
map tails ◦ inits
= f ◦ foldr (◁) [[]]
foldr-fusion
= foldr (≪) (map tails [[]])
= foldr (≪) [[[]]]
1. f = map tails
2. (◁) = x hs → [] : (map (x:) hs)
Suffixes of Prefixes

59. 56
filter (/=[])◦concat◦map tails◦inits
map tails ◦ inits
= f ◦ foldr (◁) [[]]
foldr-fusion
= foldr (≪) (map tails [[]])
= foldr (≪) [[[]]]
1. f = map tails
2. (◁) = x hs → [] : (map (x:) hs)
3. (≪) = x h → [[]] : map (hs → (x : (head hs)) : hs) h
Suffixes of Prefixes

60. 57
filter (/=[])◦concat◦foldr (≪) [[[]]]
filter (/=[]) ◦ concat
= g ◦ foldr (++) []
foldr-fusion
= foldr (⋆) []
1. g = filter (/=[])
2. (⋆) = x h → filter (/=[]) x) ++ h
Suffixes of Prefixes

61. 58
filter (/=[]) ◦ concat
= g ◦ foldr (++) []
foldr-fusion
= foldr (⋆) []
1. g = filter (/=[])
2. (⋆) = x h → filter (/=[]) x) ++ h
filter (/=[])◦concat◦foldr (≪) [[[]]]
Suffixes of Prefixes

62. 59
foldr (⋆) []◦foldr (≪) [[[]]]
= foldr (⊙) []
1. (≪) = x h → [[]] : map (hs → (x : (head hs)) : hs) h
2. (⋆) = x h → filter (/=[]) x) ++ h
Suffixes of Prefixes
if... foldr (⋆) [] (x ≪ z)
= x ⊙ (foldr (⋆) [] z)

63. 60
foldr (⋆) []◦foldr (≪) [[[]]]
= foldr (⊙) []
1. (≪) = x h → [[]] : map (hs → (x : (head hs)) : hs) h
2. (⋆) = x h → filter (/=[]) x) ++ h
Suffixes of Prefixes
if... foldr (⋆) [] (x ≪ z)
= x ⊙ (foldr (⋆) [] z)
... after 3 hours

64. 61
fusion
foldl
foldr

65. 62
1 2 3
1 2 3: : :
data ConsList a = []
| a : (ConsList a)

66. 63
1 2 3
1 2 3‡ ‡‡
data SnocList a = []
| (SnocList a) ‡ a

67. 64
1 2 3‡ ‡‡
f (▷) e
e 1▷ 2▷ 3▷

68. 65
1 2 3‡ ‡‡
e 1▷ 2▷ 3▷
folds (▷) e [] = e
folds (▷) e (ys ‡ y) =
(folds (▷) e ys) ▷ y
foldr (◁) e [] = e
foldr (◁) e (x : xs) =
x ◁ (foldr (◁) e xs)

69. 66
1 2 3‡ ‡‡
e 1▷ 2▷ 3▷
folds (▷) e [] = e
folds (▷) e (ys ‡ y) =
(folds (▷) e ys) ▷ y
1 2 3: : :
foldl (▷) e [] = e
foldl (▷) e (x : xs) =
foldl (▷) (e ▷ x) xs

70. 67
foldl (▷) e [] = e
foldl (▷) e (x : xs) =
foldl (▷) (e ▷ x) xs
foldl (▷) e (ys ‡ y) =
(foldl (▷) e ys) ▷ y
foldr (◁) e [] = e
foldr (◁) e (x : xs) =
x ◁ (foldr (◁) e xs)

71. 68
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
point free

72. 69
interesting...
h = foldr (◁) e = foldl (▷) e
if .... ?
thr 11

73. 70
別管 fold 了
你有聽過
List Homomorphism
嗎?!

74. List Homomorphism
71
•h (xs ++ ys) = (h xs) ⊕ (h ys)
•h ◦ (++ys) = (⊕ h ys) ◦ h
•... parallel
length :: [a] → Int
maximum :: (Ord a) ⇒ [a] → a

75. to prove h is homo...
thr 11
萬
全

76. 73
3rd List Homo.Theorem
h is a list homomorphism
if h can be
foldr (◁) e and
foldl (▷) e
for some (◁), (▷) and e

77. 74
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.

78. 75
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

79. h = foldr = foldl
h is list homo.
requirement 1
requirement 2
(◁), (▷)
(⊕)
the way to go

80. 77
(x ◁ y) ▷ z
=
=
=
=
=
=
=
x ◁ (y ▷ z)
z z
z
z
z
(x ◁ y) ▷ z = x ◁ (y ▷ z)

81. 78
(x ◁ y) ▷ z
=
=
=
=
=
=
=
x ◁ (y ▷ z)
(1) (▷ z) => (⊕ (h ys))
z z
z
z
z

82. 79
(x ◁ y) ⊕ (h ys)
=
=
=
=
=
=
=
x ◁ (y ⊕ (h ys))
(1) (▷ z) => (⊕ (h ys))
z z
z
z
z

83. 80
(x ◁ y) ⊕ (h ys)
=
=
=
=
=
=
=
x ◁ (y ⊕ (h ys))
(1) (▷ z) => (⊕ (h ys))
(2) z => free variables
z z
z
z
z

84. 81
(x ◁ y) ⊕ (h ys)
=
=
=
=
=
=
=
x ◁ (y ⊕ (h ys))
(1) (▷ z) => (⊕ (h ys))
(2) z => free variables
X1 X2
X2
X1
X1

85. 82
(x ◁ y) ⊕ (h ys)
=
=
=
=
=
=
=
x ◁ (y ⊕ (h ys))
X1 X2
X2
X1
X1
(x ◁ y) ⊕ (h ys) = x ◁ (y ⊕ (h ys))

86. 83
(x ◁ y) ⊕ (h ys)
=
=
=
=
=
=
=
x ◁ (y ⊕ (h ys))
X1 X2
X2
X1
X1
(x ◁ y) ⊕ (h ys) = x ◁ (y ⊕ (h ys))
h ys
= e ⊕ h ys
requirement 2
(base case)

87. 84
(x ◁ y) ⊕ (h ys)
=
=
=
=
=
=
=
x ◁ (y ⊕ (h ys))
(x ◁ y) ⊕ (h ys) = x ◁ (y ⊕ (h ys))

88. ಠ_ಠ
thr 11
必
死
tupling

89. 86
Algorithm
Efficient Program
Specification
• total functional
• fold
• fold-fusion
• 3rd list homo.
• hoard logic
• logic/type

90. Reference
87
• Constructing List Homomorphisms from
Proofs. [Yun-Yan Chi, Shin-Cheng Mu]
• Introduction to Funcional Programming
using Haskell [Richard Bird]