Program Calculus Calculational Programming

Transcription

1 Program Calculus Calculational Programming National Institute of Informatics June 21 / June 28 / July 5, 2010 Program Calculus Calculational Programming

2 What we will learn? Discussing the mathematical structures in programs, and Program Calculus Calculational Programming

3 What we will learn? Discussing the mathematical structures in programs, and explaining how mathematical reasoning plays an important role in designing efficient and correct algorithms (programs). Program Calculus Calculational Programming

4 What we will learn? Discussing the mathematical structures in programs, and explaining how mathematical reasoning plays an important role in designing efficient and correct algorithms (programs). A new programming style: calculational programming Program Calculus Calculational Programming

5 Calculation is widely used in solving our daily problems, but its importance in programming has not been fully recognized. Program Calculus Calculational Programming

6 Tsuru-Kame-Zan An Overview The Tsuru-Kame Problem Some cranes (tsuru) and tortoises (kame) are mixed in a cage. Known is that there are 5 heads and 14 legs. Find out the numbers of cranes and tortoises. Program Calculus Calculational Programming

7 Tsuru-Kame-Zan An Overview The Tsuru-Kame Problem Some cranes (tsuru) and tortoises (kame) are mixed in a cage. Known is that there are 5 heads and 14 legs. Find out the numbers of cranes and tortoises. The kindergarten approach: plain simple enumeration! Crane 0, Tortoise 5... No. Crane 1, Tortoise 4... No. Crane 2, Tortoise 3... No. Crane 3, Tortoise 2... Yes! Crane 4, Tortoise 1... No. Crane 5, Tortoise 0... No. Program Calculus Calculational Programming

8 Tsuru-Kame-Zan An Overview The Tsuru-Kame Problem Some cranes (tsuru) and tortoises (kame) are mixed in a cage. Known is that there are 5 heads and 14 legs. Find out the numbers of cranes and tortoises. Elementary school: let s do some reasoning... If all 5 animals were cranes, there ought to be 5 2 = 10 legs. However, there are in fact 14 legs. The extra 4 legs must belong to some tortoises. There must be (14 10)/2 = 2 tortoises. So there must be 5 2 = 3 cranes. It generalises to larger numbers of heads and legs. Program Calculus Calculational Programming

9 Tsuru-Kame-Zan An Overview The Tsuru-Kame Problem Some cranes (tsuru) and tortoises (kame) are mixed in a cage. Known is that there are 5 heads and 14 legs. Find out the numbers of cranes and tortoises. Junior high school: algebra (theory of equation)! x + y = 5 2x + 4y = 14 It s a general approach applicable to many other problems and perhaps easier. Program Calculus Calculational Programming

10 Tsuru-Kame-Zan An Overview The Tsuru-Kame Problem Some cranes (tsuru) and tortoises (kame) are mixed in a cage. Known is that there are 5 heads and 14 legs. Find out the numbers of cranes and tortoises. rules and theories are useful for solving problems easily and systematically. Problems are declaratively specified. Implementation is hidden. Program Calculus Calculational Programming

11 Can we have a set of useful rules and theories in programming for developing correct and efficient algorithms (programs)? Program Calculus Calculational Programming

12 A Programming Problem Can you develop a correct linear-time program for solving the following problem? Maximum Segment Sum Problem Given a list of numbers, find the maximum of sums of all consecutive sublists. [ 1, 3, 3, 4, 1, 4, 2, 1] = 7 [ 1, 3, 1, 4, 1, 4, 2, 1] = 6 [ 1, 3, 1, 4, 1, 1, 2, 1] = 4 Program Calculus Calculational Programming

13 A Simple Solution An Overview 1 Enumerating all segments (segs); Program Calculus Calculational Programming

14 A Simple Solution An Overview 1 Enumerating all segments (segs); 2 Computing sum for each segment(sums); Program Calculus Calculational Programming

15 A Simple Solution An Overview 1 Enumerating all segments (segs); 2 Computing sum for each segment(sums); 3 Calculating the maximum of all the sums (max). Program Calculus Calculational Programming

16 A Simple Solution An Overview 1 Enumerating all segments (segs); 2 Computing sum for each segment(sums); 3 Calculating the maximum of all the sums (max). Program Calculus Calculational Programming

17 A Simple Solution An Overview 1 Enumerating all segments (segs); 2 Computing sum for each segment(sums); 3 Calculating the maximum of all the sums (max). Exercise How many segments does a list of length n have? Program Calculus Calculational Programming

18 A Simple Solution An Overview 1 Enumerating all segments (segs); 2 Computing sum for each segment(sums); 3 Calculating the maximum of all the sums (max). Exercise How many segments does a list of length n have? Exercise What is the time complexity of this simple solution? Program Calculus Calculational Programming

19 There indeed exists a clever solution! mss=0; s=0; for(i=0;i<n;i++){ s += x[i]; if(s<0) s=0; if(mss<s) mss= s; } x[i] s mss Program Calculus Calculational Programming

20 There is a big gap between the simple and clever solutions! Program Calculus Calculational Programming

21 There is a big gap between the simple and clever solutions! Can we calculate the clever solution from the simple solution? Program Calculus Calculational Programming

22 There is a big gap between the simple and clever solutions! Can we calculate the clever solution from the simple solution? What rules and theorems are necessary to do so? Program Calculus Calculational Programming

23 There is a big gap between the simple and clever solutions! Can we calculate the clever solution from the simple solution? What rules and theorems are necessary to do so? How to apply the rules and theorems to do so? Program Calculus Calculational Programming

24 There is a big gap between the simple and clever solutions! Can we calculate the clever solution from the simple solution? What rules and theorems are necessary to do so? How to apply the rules and theorems to do so? Program Calculus Calculational Programming

25 Transformational Programming One starts by writing clean and correct programs, and then use program transformation techniques to transform them step-by-step to more efficient equivalents. Specificaiton: Clean and Correct programs Folding/Unfolding Program Transformation Efficient Programs Program Calculus Calculational Programming

26 Program Calculation Program calculation is a kind of program transformation based on Constructive Algorithmics, a framework for developing laws/rules/theories for manipulating programs. Program Calculus Calculational Programming

27 Program Calculation Program calculation is a kind of program transformation based on Constructive Algorithmics, a framework for developing laws/rules/theories for manipulating programs. Specificaiton: Clean and Correct programs Folding-free Program Transformation Efficient Programs Program Calculus Calculational Programming

28 References Richard Bird, Lecture Notes on Constructive Functional Programming, Technical Monograph PRG-69, Oxford University, Anne Kaldewaij, Programming: The Derivation of Algorithms, Prentice Hall, Richard Bird and Oege de Moor, The Algebra of Programming, Prentice-Hall, Roland Backhouse, Program Construction: Calculating Implementation from Specification, Wiley, Program Calculus Calculational Programming

29 National Institute of Informatics June 21 / June 28 / July 5, 2010

30 A specification describes what task an algorithm is to perform, expresses the programmers intent, should be as clear as possible.

31 A specification describes what task an algorithm is to perform, expresses the programmers intent, should be as clear as possible. An implementation describes how task is to perform, expresses an algorithm (an execution), should be efficiently done within the time and space available.

32 A specification describes what task an algorithm is to perform, expresses the programmers intent, should be as clear as possible. An implementation describes how task is to perform, expresses an algorithm (an execution), should be efficiently done within the time and space available. The link is that the implementation should be proved to satisfy the specification.

33 How to write a specification? By predicates: describing intended relationship between input and output of an algorithm.

34 How to write a specification? By predicates: describing intended relationship between input and output of an algorithm. By functions: describing straightforward functional mapping from input to output of an algorithm, which is executable but could be terribly inefficient.

35 Specifying Algorithms by Predicates (1/3) Specification: describing intended relationship between input and output of an algorithm.

36 Specifying Algorithms by Predicates (1/3) Specification: describing intended relationship between input and output of an algorithm. Example: increase The specification increase :: Int Int increase x > square x says that the result of increase should be strictly greater than the square of its input, where square x = x x.

37 Specifying Algorithms by Predicates (2/3) In this case, an Implementation is first given and then proved to satisfy the specification.

38 Specifying Algorithms by Predicates (2/3) In this case, an Implementation is first given and then proved to satisfy the specification. Example: increase (continue) One implementation is increase x = square x + 1 which can be proved by the following simple calculation. increase x = { definition of increase } square x + 1 > { arithmetic property } square x

39 Specifying Algorithms by Predicates (3/3) Exercise S1 Give another implementation of increase and prove that your implementation meets its specification.

40 Specifying Algorithms by Functions (1/3) Specification: describing straightforward functional mapping from input to output of an algorithm, which is executable but could be terribly inefficient.

41 Specifying Algorithms by Functions (1/3) Specification: describing straightforward functional mapping from input to output of an algorithm, which is executable but could be terribly inefficient. Example: quad The specification for computing quadruple of a number can be described straightforwardly by quad x = x x x x which is not efficient in the sense that multiplications are used three times.

42 Specifying Algorithms by Functions (2/3) With functional specification, we do not need to invent the implementation; just to improve specification via calculation.

43 Specifying Algorithms by Functions (2/3) With functional specification, we do not need to invent the implementation; just to improve specification via calculation. Example: quad (continue) We derive (develop) an efficient algorithm with only two multiplications by the following calcualtion. quad x = { specification } x x x x = { since x is associative } (x x) (x x) = { definition of square } square x square x = { definition of square } square (aquare x)

44 Specifying Algorithms by Functions (3/3) Exercise S2 Extend the idea in the derivation of efficient quad to develop an efficient algorithm for computing exp defined by exp(x, n) = x n.

45 Advantages of Functional Specification Functional specification is executable.

46 Advantages of Functional Specification Functional specification is executable. Functional specification is powerful to express intended mappings directly by functions or through their composition.

47 Advantages of Functional Specification Functional specification is executable. Functional specification is powerful to express intended mappings directly by functions or through their composition. Functional specification is suitable for reasoning, when functions used are well-structured with good algebraic properties.

48 Advantages of Functional Specification Functional specification is executable. Functional specification is powerful to express intended mappings directly by functions or through their composition. Functional specification is suitable for reasoning, when functions used are well-structured with good algebraic properties. In this course, we will consider functional specification.

49 Introduction to Bird Meertens Formalisms National Institute of Informatics June 21 / June 28 / July 5, 2010 Introduction to Bird Meertens Formalisms

50 Bird Meentens Formalisms (BMF) Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition BMF is a calculus of functions for people to derive programs from specifications: a range of concepts and notations for defining functions over lists; a set of algebraic laws for manipulating functions. Introduction to Bird Meertens Formalisms

51 A Problem An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition Consider the following simple identity: (a 1 a 2 a 3 ) + (a 2 a 3 ) + a = ((1 a 1 + 1) a 2 + 1) a This equation generalizes in the obvious way to n variables a 1, a 2,..., a n, and we will refer to it as Horner e rule. Introduction to Bird Meertens Formalisms

52 A Problem An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition Consider the following simple identity: (a 1 a 2 a 3 ) + (a 2 a 3 ) + a = ((1 a 1 + 1) a 2 + 1) a This equation generalizes in the obvious way to n variables a 1, a 2,..., a n, and we will refer to it as Horner e rule. How many are used in each side? Introduction to Bird Meertens Formalisms

53 A Problem An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition Consider the following simple identity: (a 1 a 2 a 3 ) + (a 2 a 3 ) + a = ((1 a 1 + 1) a 2 + 1) a This equation generalizes in the obvious way to n variables a 1, a 2,..., a n, and we will refer to it as Horner e rule. How many are used in each side? Can we generalize to, + to? What are the essential constraints for and? Introduction to Bird Meertens Formalisms

54 A Problem An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition Consider the following simple identity: (a 1 a 2 a 3 ) + (a 2 a 3 ) + a = ((1 a 1 + 1) a 2 + 1) a This equation generalizes in the obvious way to n variables a 1, a 2,..., a n, and we will refer to it as Horner e rule. How many are used in each side? Can we generalize to, + to? What are the essential constraints for and? Do you have suitable notation for expressing the Horner s rule concisely? Introduction to Bird Meertens Formalisms

55 Functions An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition A function f that has source type α and target type β is denoted by f : α β We shall say that f takes arguments in α and returns results in β. Function application is written without brackets; thus f a means f (a). Function application is more binding than any other operation, so f a b means (f a) b. Functions are curried and applications associates to the left, so f a b means (f a) b (sometimes written as f a b. Introduction to Bird Meertens Formalisms

56 Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition Function composition is denoted by a centralized dot ( ). We have (f g) x = f (g x) Exercise: Show the following equation state that functional compositon is associative. (f ) (g ) = ((f g) ) Introduction to Bird Meertens Formalisms

57 Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition Binary operators will be denoted by,,, etc. Binary operators can be sectioned. This means that ( ), (a ) and ( a) all denote functions. The definitions are: ( ) a b = a b (a ) b = a b ( b) a = a b Exercise: If has type : α β γ, then what are the types for ( ), (a ) and ( b) for all a in α and b in β? Introduction to Bird Meertens Formalisms

58 Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition The identity element of : α α α, if it exists, will be denoted by id. Thus, a id = id a = a Exericise: What is the identity element of functional composition? The constant values function K : α β α is defined by the equation K a b = a Introduction to Bird Meertens Formalisms

59 Lists An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition Lists are finite sequence of values of the same type. We use the notation [α] to describe the type of lists whose elements have type α. Examples: [1, 2, 1] : [Int] [[1], [1, 2], [1, 2, 1]] : [[Int]] [ ] : [α] Introduction to Bird Meertens Formalisms

60 List Data Constructors Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition [ ] : [α] constructs an empty list. [.] : α [α] maps elements of α into singleton lists. [.] a = [a] The primitive operator on lists is concatenation, denoted by +. [1] ++ [2] ++ [1] = [1, 2, 1] Concatenation is associative: x ++ (y ++ z) = (x ++ y) ++ z Exercise: What is the identity for concatenation? Introduction to Bird Meertens Formalisms

61 Algebraic View of Lists Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition ([α], +, [ ]) is a monoid. ([α], +, [ ]) is a free monoid generated by α under the assignment [.] : α [α]. ([α] +, + ) is a semigroup. Introduction to Bird Meertens Formalisms

62 List Functions: s Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition A function h defined in the following form is called homomorphism: h [ ] = id h [a] = f a h (x ++ y) = h x h y It defines a map from the monoid ([α], +, [ ]) to the monoid (β, : β β β, id : β). Introduction to Bird Meertens Formalisms

63 List Functions: s Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition A function h defined in the following form is called homomorphism: h [ ] = id h [a] = f a h (x ++ y) = h x h y It defines a map from the monoid ([α], +, [ ]) to the monoid (β, : β β β, id : β). Property: h is uniquely determined by f and. Introduction to Bird Meertens Formalisms

64 Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition An Example: the function returning the length of a list. # [ ] = 0 # [a] = 1 # (x ++ y) = # x + # y Note that (Int, +, 0) is a monoid. Introduction to Bird Meertens Formalisms

65 Bags and Sets An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition A bag is a list in which the order of the elements is ignored. Bags are constructed by adding the rule that + is commutative (as well as associative): x ++ y = y ++ x A set is a bag in which repetitions of elements are ignored. Sets are constructed by adding the rule that + is idempotent (as well as commutative and associative): x ++ x = x Introduction to Bird Meertens Formalisms

66 Map An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition The operator (pronounced map) takes a function on lts left and a list on its right. Informally, we have f [a 1, a 2,..., a n ] = [f a 1, f a 2,..., f a n ] Formally, (f ) (or sometimes simply written as f ) is a homomorphism: f [ ] = [ ] f [a] = [f a] f (x ++ y) = (f x) ++ (f y) Map Distributivity: (f g) = (f ) (g ) Introduction to Bird Meertens Formalisms

67 Reduce An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition The operator / (pronounced reduce) takes an associative binary operator on lts left and a list on its right. Informally, we have /[a 1, a 2,..., a n ] = a 1 a 2 a n Formally, / is a homomorphism: /[ ] = id { if id exists } /[a] = a /(x ++ y) = ( /x) ( /y) Introduction to Bird Meertens Formalisms

68 Examples: An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition max : [Int] Int max = / where a b = if a b then b else a head : [α] + α head = / where a b = a last : [α] + α last = / where a b = b Introduction to Bird Meertens Formalisms

69 Promotion An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition f and / can be expressed as identities between functions. Empty Rules One-Point Rules Join Rules f K [ ] = K [ ] / K [ ] = id f [ ] = [ ] f / [ ] = id f ++ / = ++ / (f ) / ++ / = /.( /) Introduction to Bird Meertens Formalisms

70 An Example of Calculation Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition / f ++ / g = { map promotion } / ++ / f g = { reduce promotion } / ( /) f g = { map distribution } / ( / f g) Introduction to Bird Meertens Formalisms

71 Directed Reductions Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition We introduce two more computation patterns / (pronounced left-to-right reduce) and / (right-to-left reduce) which are closely related to /. Informally, we have / e [a 1, a 2,..., a n ] = ((e a 1 ) ) a n / e [a 1, a 2,..., a n ] = a 1 (a 2 (a n e)) Formally, we can define / e on lists by two equations. / e [ ] = e / e (x ++ [a]) = ( / e x) a Exercise: Give a formal definition for / e. Introduction to Bird Meertens Formalisms

72 Directed Reductions without Seeds Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition / [a 1, a 2,..., a n ] = ((a 1 a 2 ) ) a n / [a 1, a 2,..., a n ] = a 1 (a 2 (a n 1 a n )) Properties: ( / ) ([a] ++ ) = / a ( / ) (++ [a]) = / a Introduction to Bird Meertens Formalisms

73 An Example Use of Left-Reduce Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition Consider the right-hand side of Horner s rule: (((1 a 1 + 1) a 2 + 1) + 1) a n + 1 This expression can be written using a left-reduce: / 1 [a 1, a 2,..., a n ] where a b = (a b) + 1 Exercise: Give the definition of such that the following holds. / [a 1, a 2,..., a n ] = (((a 1 a 2 +a 2 ) a 3 +a 3 ) +a n 1 ) a n +a n Introduction to Bird Meertens Formalisms

74 Accumulations An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition With each form of directed reduction over lists there corresponds a form of computation called an accumulation. These forms are expressed with the operators / (pronounced left-accumualte) and / (right-accumulate) and are defined informally by / e [a 1, a 2,..., a n ] = [e, e a 1,..., ((e a 1 ) ) a n ] / e [a 1, a 2,..., a n ] = [a 1 (a 2 (a n e)),..., a n e, e] Introduction to Bird Meertens Formalisms

75 Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition Formally, we can define / e on lists by two equations by / e [ ] = [e] / e ([a] ++ x) = [e] ++ ( / e a x), or / e [ ] = [e] / e (x ++ [a]) = ( / e x) ++ [b a] where b = last( / e x). Introduction to Bird Meertens Formalisms

76 Efficiency in Accumulate Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition / e [a 1, a 2,..., a n ]: can be evaluated with n 1 calculations of. Exercise: Consider computation of first n + 1 factorial numbers: [0!, 1!,..., n!]. How many calculations of are required for the following two programs? 1 / 1 [1, 2,..., n] 2 fact [0, 1, 2,, n] where fact 0 = 1 and fact k = 1 2 k. Introduction to Bird Meertens Formalisms

77 Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition Relation between Reduce and Accumulate / e = last / e / e = / [e] where x a = x ++ [last x a] Introduction to Bird Meertens Formalisms

78 Segments An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition A list y is a segment of x if there exists u and v such that x = u ++ y ++ v. If u = [], then y is called an initial segment. If v = [], then y is called an final segment. An Example: segs [1, 2, 3] = [[], [1], [1, 2], [2], [1, 2, 3], [2, 3], [3]] Exercise: How many segments for a list [a 1, a 2,..., a n ]? Introduction to Bird Meertens Formalisms

79 inits An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition The function inits returns the list of initial segments of a list, in increasing order of a list. inits [a 1, a 2,..., a n ] = [[ ], [a 1 ], [a 1, a 2 ],..., [a 1, a 2,..., a n ]] inits = ( + / [] ) [ ] Introduction to Bird Meertens Formalisms

80 tails An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition The function tails returns the list of final segments of a list, in decreasing order of a list. tails [a 1, a 2,..., a n ] = [[a 1, a 2,..., a n ], [a 2,..., a n ],..., [a n ], [ ]] tails = ( + / [] ) [ ] Introduction to Bird Meertens Formalisms

81 segs An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition segs = ++ / tails inits Exercise: Show the result of segs [1, 2]. Introduction to Bird Meertens Formalisms

82 Accumulation Lemma Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition ( / e ) = ( / e ) inits ( / ) = ( / ) inits + The accumulation lemma is used frequently in the derivation of efficient algorithms for problems about segments. On lists of length n, evaluation of the LHS requires O(n) computations involving, while the RHS requires O(n 2 ) computations. Introduction to Bird Meertens Formalisms

83 The Problem: Revisit Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition Consider the following simple identity: (a 1 a 2 a 3 ) + (a 2 a 3 ) + a = ((1 a 1 + 1) a 2 + 1) a This equation generalizes in the obvious way to n variables a 1, a 2,..., a 2, and we will refer to it as Horner e rule. Can we generalize to, + to? What are the essential constraints for and? Do you have suitable notation for expressing the Horner s rule concisely? Introduction to Bird Meertens Formalisms

84 Horner s Rule An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition The following equation / / tails = / e where e = id a b = (a b) e holds, provided that distributes (backwards) over : for all a, b, and c. (a b) c = (a c) (b c) Introduction to Bird Meertens Formalisms

85 Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition Exercise: Prove the correctness of the Horner s rule. Hints: Show that is equivalent to Show that satisfies the equations (a b) c = (a c) (b c) ( c) / = / ( c). f = / / tails f [ ] = e f (x ++ [a]) = f x a Introduction to Bird Meertens Formalisms

86 Generalizations of Horner s Rule Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition Generalization 1: / / tails + = / where a b = (a b) b Introduction to Bird Meertens Formalisms

87 Generalizations of Horner s Rule Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition Generalization 1: / / tails + = / where a b = (a b) b Generalization 2: / ( / f ) tails = / e where e = id a b = (a f b) e Introduction to Bird Meertens Formalisms

88 Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition The Maximum Segment Sum (mss) Problem Compute the maximum of the sums of all segments of a given sequence of numbers, positive, negative, or zero. mss [3, 1, 4, 1, 5, 9, 2] = 6 Introduction to Bird Meertens Formalisms

89 A Direct Solution An Overview Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition mss = / +/ segs Introduction to Bird Meertens Formalisms

90 Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition Calculating a Linear Algorithm using Horner s Rule mss = { definition of mss } / +/ segs = { definition of segs } / +/ ++ / tails inits = { map and reduce promotion } / ( / +/ tails) inits = { Horner s rule with a b = (a + b) 0 } / / 0 inits = { accumulation lemma } / / 0 Introduction to Bird Meertens Formalisms

91 A Program in Haskell Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition Exercise: Code the derived linear algorithm for mss in your favorite programming language. Introduction to Bird Meertens Formalisms

92 Segment Decomposition Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition The sequence of calculation steps given in the derivation of the mss problem arises frequently. The essential idea can be summarized as a general theorem. Theorem (Segment Decomposition) Suppose S and T are defined by S = / f segs T = / f tails If T can be expressed in the form T = h / e, then we have S = / h / e Introduction to Bird Meertens Formalisms

93 Functions Lists Structured Recursive Computation Patterns Segments Horner s Rule Application Segment Decomposition National Institute of Informatics June 21 / June 28 / July 5, 2010

94 Longest Even Segment Problem Given is a sequence x and a predicate p. Required is an efficient algorithm for computing some longest segment of x, all of whose elements satisfy p. lsp even [3, 1, 4, 1, 5, 9, 2, 6, 5] = [2, 6]

95 s An Overview A homomorphism from a monoid (α,, id ) to a monoid (β,, id ) is a function h satisfying the two equations: h id = id h (x y) = h x h y

96 Lemma (Promotion) h is a homomorphism if and only if the following holds. h / = / h

97 Lemma (Promotion) h is a homomorphism if and only if the following holds. h / = / h Proof Sketch. : simple. : by induction.

98 Lemma (Promotion) h is a homomorphism if and only if the following holds. h / = / h Proof Sketch. : simple. : by induction. So we have f ++ / = ++ / f / ++ / = / ( /)

99 Characterization of s Lemma h is a homomorphism from the list monoid if and only if there exists f and such that h = / f

100 Proof : h = { definition of id } h id = { identity lemma (can you prove it?) } h ++ / [ ] = { h is a homomorphism } / h [ ] = { map distributivity } / (h [ ]) = { definition of h on singleton } / f

101 Proof (Cont.) An Overview : We reason that h = / f is a homomorphism by calculating h ++ / = { given form for h } / f ++ / = { map and reduce promotion } / ( / f ) = { hypothesis } / h

102 Examples of s #: compute the length of a list. # = +/ K 1

103 Examples of s #: compute the length of a list. # = +/ K 1 reverse: reverses the order of the elements in a list. Here, x y = y x. reverse = + / [ ]

104 sort: reorders the elements of a list into ascending order. sort = / [ ] Here, (pronounced merge) is defined by the equations: x [ ] = x [ ] y = y ([a] ++ x) ([b] ++ y) = [a] ++ (x ([b] ++ y)), if a b = [b] ++ (([a] ++ x) y), otherwise

105 all p: returns True if every element of the input list satisfies the predicate p. all p = / p

106 all p: returns True if every element of the input list satisfies the predicate p. all p = / p some p: returns True if at least one element of the input list satisfies the predicate p. some p = / p

107 split: splits a non-empty list into its last element and the remainder. split : [α] + ([α], α) split [a] = ([ ], a) split (x ++ y) = split x split y where (x, a) (y, b) = (x ++ [a] ++ y, b)

108 split: splits a non-empty list into its last element and the remainder. split : [α] + ([α], α) split [a] = ([ ], a) split (x ++ y) = split x split y where (x, a) (y, b) = (x ++ [a] ++ y, b) Note: split is a homomorphism on the semigroup ([α] +, + ).

109 split: splits a non-empty list into its last element and the remainder. split : [α] + ([α], α) split [a] = ([ ], a) split (x ++ y) = split x split y where (x, a) (y, b) = (x ++ [a] ++ y, b) Note: split is a homomorphism on the semigroup ([α] +, + ). Exercise: Let init = π 1 split, where π 1 (a, b) = a. Show that init is not a homomorphism.

110 All applied to An Overview The operator o (pronounced all applied to) takes a sequence of functions and a value and returns the result of applying each function to the value. Formally, we have [f, g,..., h] o a = [f a, g a,..., h a] [ ] o a = [ ] [f ] o a = [f a] (fs ++ gs) o a = (fs o a) ++ (gs o a) so, ( o a) is a homomorphism. Exercise: Show that [ ] = [id] o.

111 Conditional Expressions The conditional notation h x = f x, if p x = g x, otherwise will be written by the McCarthy conditional form: h = (p f, g)

112 Conditional Expressions The conditional notation h x = f x, if p x = g x, otherwise will be written by the McCarthy conditional form: h = (p f, g) Laws on Conditional Forms h (p f, g) = (p h f, h g) (p f, g) h = (p h f h, g h) (p f, f ) = f (Note: all functions are assumed to be total.)

113 Filter The operator (pronounced filter) takes a predicate p and a list x and returns the sublist of x consisting, in order, of all those elements of x that satisfy p. p = ++ / (p [id] o, [ ] o )

114 Filter The operator (pronounced filter) takes a predicate p and a list x and returns the sublist of x consisting, in order, of all those elements of x that satisfy p. p = ++ / (p [id] o, [ ] o ) Exercise: Prove that the filter satisfies the filter promotion property: (p ) ++ / = ++ / (p )

115 Filter The operator (pronounced filter) takes a predicate p and a list x and returns the sublist of x consisting, in order, of all those elements of x that satisfy p. p = ++ / (p [id] o, [ ] o ) Exercise: Prove that the filter satisfies the filter promotion property: (p ) ++ / = ++ / (p ) Exercise: Prove that the filter satisfies the map-filter swap property: (p ) f = f (p f )

116 Cross-product An Overview X is a binary operator that takes two lists x and y and returns a list of values of the form a b for all a in x and b in y. [a, b]x [c, d, e] = [a c, b c, a d, b d, a e, b e] Formally, we define X by three equations: xx [ ] = [ ] xx [a] = ( a) x xx (y ++ z) = (xx y) ++ (xx z) Thus xx is a homomorphism.

117 Properties [ ] is the zero element of X : We have cross promotion rules: [ ]X x = xx [ ] = [ ] f X + / = X + / f / X + / = X / (X /)

118 Example Uses of Cross-product cp: takes a list of lists and returns a list of lists of elements, one from each component. cp [[a, b], [c], [d, e]] = [[a, c, d], [b, c, d], [a, c, e], [b, c, e]] cp = X + / ([id] o )

119 subs: computes all subsequences of a list. subs [a, b, c] = [[], [a], [b], [a, b], [c], [a, c], [b, c], [a, b, c]] subs = X + / [[ ] o, [id] o ] o

120 subs: computes all subsequences of a list. subs [a, b, c] = [[], [a], [b], [a, b], [c], [a, c], [b, c], [a, b, c]] subs = X + / [[ ] o, [id] o ] o Note: subs = cp [[] o, [id] o ].

121 (all p) : (all even) [[1, 3], [2, 4], [1, 2, 3]] = [[2, 4]] (all p) = ++ / (X + / (p [[id] o ] o, [ ] o ) )

122 Selection Operators An Overview Suppose f is a numeric valued function. We want to define an operator f such that 1 f is associative, commutative and idempotent; 2 f is selective in that 3 f is maximizing in that x f y = x or x f y = y f (x f y) = f x f y

123 Selection Operators An Overview Suppose f is a numeric valued function. We want to define an operator f such that 1 f is associative, commutative and idempotent; 2 f is selective in that 3 f is maximizing in that x f y = x or x f y = y f (x f y) = f x f y Condition: f should be injective.

124 An Example: # But if f is not injective, then x f y is not specified when x y but f x = f y. [1, 2] # [3, 4]

125 An Example: # But if f is not injective, then x f y is not specified when x y but f x = f y. [1, 2] # [3, 4] To solve this problem, we may refine f to an injective function f such that f x < f y f x < f y.

126 An Example: # But if f is not injective, then x f y is not specified when x y but f x = f y. [1, 2] # [3, 4] To solve this problem, we may refine f to an injective function f such that f x < f y f x < f y. So we may select the lexicographically least sequence as the value of x # y when #x = #y.

127 In this case, + distributes through # : x ++ (y # z) = (x ++ y) # (x ++ z) (x # y) ++ z = (x ++ z) # (y ++ z) That is, (x ++ ) # / = # / (x ++ ) (++ x) # / = # / (++ x). We assume ω = # /[ ], satisfying #ω =. (ω is the zero element of + )

128 A short calculation An Overview # / (all p) = { definition before } # / ++ / (X + / (p [[id] o ] o, [ ] o ) ) = { reduce promotion } # / ( # / X + / (p [[id] o ] o, [ ] o ) ) = { + distributes over # } # / (++ / ( # /) (p [[id] o ] o, [ ] o ) ) = { many steps... } # / (++ / (p [id] o, K ω ) )

129 Existence of Existence Lemma The list function h is a homomorphism iff the implication h v = h x h w = h y h (v ++ w) = h (x ++ y) holds for all lists v, w, x, y.

130 Existence of Existence Lemma The list function h is a homomorphism iff the implication h v = h x h w = h y h (v ++ w) = h (x ++ y) holds for all lists v, w, x, y. Proof Sketch. : obvious by assuming h = / f.

131 Existence of Existence Lemma The list function h is a homomorphism iff the implication h v = h x h w = h y h (v ++ w) = h (x ++ y) holds for all lists v, w, x, y. Proof Sketch. : obvious by assuming h = / f. : Define by t u = h (g t ++ g u). for some g such that h = h g h (such a g exisits!). Thus h (x ++ y) = h x h y.

132 Reference Lemma For every computatble total function h with enumerable domain, there is a computatble (but possibly partial) function g such that h g h = h.

133 Reference Lemma For every computatble total function h with enumerable domain, there is a computatble (but possibly partial) function g such that h g h = h. Proof. Here is one suitable definition of g. g t = head [x h x = t] If t is in the range of h then this process terminates.

134 Specification of the Problem Recall the problem of computing the longest segment of a list, all of whose elements satisfied some given property p. lsp = # / (all p) segs

135 Specification of the Problem Recall the problem of computing the longest segment of a list, all of whose elements satisfied some given property p. lsp = # / (all p) segs Property: lsp is not a homomorphism.

136 Specification of the Problem Recall the problem of computing the longest segment of a list, all of whose elements satisfied some given property p. lsp = # / (all p) segs Property: lsp is not a homomorphism. This is because: does not imply lsp [2, 1] = lsp [2] = [2] lsp [4] = lsp[4] = [4] lsp ([2, 1] ++ [4]) = lsp ([2] ++ [4]).

137 Calculating a Solution to the Problem # / (all p) segs = { segment decomposition } # / ( # / (all p) tails) inits = { result before } # / ( # / (++ / (p [id] o, K ω ) ) tails) inits = { Horner s rule with x a = (x ++ (p a [a], ω) # [ ] } # / [ ] inits = { accumulation lemma } # / [ ]

138 Calculating a Solution to the Problem # / (all p) segs = { segment decomposition } # / ( # / (all p) tails) inits = { result before } # / ( # / (++ / (p [id] o, K ω ) ) tails) inits = { Horner s rule with x a = (x ++ (p a [a], ω) # [ ] } # / [ ] inits = { accumulation lemma } # / [ ] Exercise: Show the final program is linear in the number of calculation of p.

139 National Institute of Informatics June 21 / June 28 / July 5, 2010

140 The Minimax Problem Given is a list of lists of numbers. Required is an efficient algorithm for computing the minimum of the maximum numbers in each list. More succinctly, we want to compute as efficiently as possible. minimax = / /

141 Three Views of Lists Monoid View: every list is either (i) the empty list; (ii) a singleton list; or (iii) the concatenation of two (non-empty) lists. Snoc View: every list is either (i) the empty list; or (ii) of the form x ++ [a] for some list x and value a. Cons View: every list is either (i) the empty list; or (ii) of the form [a] ++ [x] for some list x and value a.

142 Three General Computation Forms Monoid View: homomorphism Snoc View: left reduction (foldl) / e [ ] = e / e (x ++ [a]) = ( / e x) a Cons View: right reduction (foldr) / e [ ] = e / e ([a] ++ x) = a ( / e x)

143 Loops and Left Reductions A left reduction / e x can be translated into the following program in a conventional imperative language. [ var a; a := e; for b in x do a := a oplus b; return a ]

144 Left Zeros Left reductions require that the argument list be traversed in its entirety. Such a traversal can be cut short if we recognize the possibility that an operator may have left zeros. ω is a left zero of if ω a = ω for all a.

145 Left Zeros Left reductions require that the argument list be traversed in its entirety. Such a traversal can be cut short if we recognize the possibility that an operator may have left zeros. ω is a left zero of if ω a = ω for all a. Exercise: Prove that if ω is a zero left of then / ω x = ω for all x. (by induction on snoc list x.)

146 Specialization Lemma Lemma Specialization Every homomorphism on lists can be expressed as a left (or also a right) reduction. More precisely, / f = / e where e = id a b = a f b

147 Specialization Lemma Lemma Specialization Every homomorphism on lists can be expressed as a left (or also a right) reduction. More precisely, / f = / e where e = id a b = a f b Exercise: Prove the specialization lemma.

148 Specialization Lemma Every homomorphism on lists can be expressed as a left (or also a right) reduction. More precisely, / f = / e where e = id a b = a f b Exercise: Prove the specialization lemma.

149 Minimax Let us return to the problem of computing minimax = / / efficiently. Using the specialization lemma, we can write minimax = / where is the identity element of /, and a x = a ( /x)

150 Since distributes through we have a x = / ((a ) x) Using the specialization lemma a second time, we have a x = a / x where b a c = b (a c)

151 Since distributes through we have a x = / ((a ) x) Using the specialization lemma a second time, we have a x = a / x where b a c = b (a c) Exercise: What are left zeros for a and?

152 An Efficient Implementation of minimax xs [ var a; a := infinity; for x in xs while a <> \infinity do a := a odot x; return a ] where the assignment a := a odot x can be implemented by the loop: [ var b; b := -infinity; for c in x while c <> a do b := b max (a min c); a := b ]