to calculate Fib(N) very quickly 1 Task 1: High-school algebra helps to design your program

Transcription

1 University of New South Wales SENG 2011 Software Engineering Workshop 2A 2014 Session 1 Assignment 2 Using coupling invariants to calculate Fib(N) very quickly Due Friday of Week 7 (Good Friday) 1 18 April 2014 at 23:59 The instructions for completing and handing-in this assignment are the same as for Assignment 1 mutatis mutandis, i.e. that your file should be called Ass2.pdf (print-to-pdf an ASCII file) and that the deadline is 18 April at midnight minus one minute. Number your answers as indicated by Do this at right. There are no sentence-limits this time; but keep your answers short and precise nevertheless. 1 Task 1: High-school algebra helps to design your program In the lectures for Week 5 we carefully worked out a program, repeated in Fig. 1, that calculates the E th power B E of a base B and places it in a variable p. In that figure it turns out that there are four appeals to (three) elementary properties of multiplication: that 1 is a left- and a right identity of ( ) and that ( ) is associative. 2 Recall that to find out what assertion must be true before an assignment such as x,y,z:= X,Y,Z in order to make an assertion after (x, y, z) true after it, you simply make the substutitions into after that the assignment describes. In this case, what must hold before is therefore {after (X, Y, Z) Your first task is to answer these four questions about why we needed those arithmetic properties in the correctness argument for the program of Fig. 1. One answer is actually given for you, as an example: copy this answer into your own answers. 3 1 I know Good Friday is a holiday: the alternative is to make the deadline the day before... 2 Please excuse the unavoidable variation in notations for multiplication: there is ordinary mathematical usage where x times y is written xy; then there is primary-school usage x y for the same thing, when we want to be very explicit; and finally there is the programminglanguage usage x y, because is not an ASCII character. 3 You will receive marks for that, but only if you copy it neatly and exactly. 1

2 1. We say that 1 is a left identity of ( ) because 1 x = x for all x. Why does 1 have to be a left-identity in order for p, b, e:= 1, B, E to establish the invariant {B E = pb e? 2. We say that ( ) is associative because x (y z) = (x y) z for all x, y, z. Why does ( ) have to be associative in order for assignment b, e:= b 2, e 2 to (re-)establish the invariant {B E = p b e? (Note that associativity might not be the only property of arithmetic you need, and you can assume the others without mentioning them. But you must say where associativity is used.) Answer: For b, e:= b 2, e 2 to re-establish {B E = p b e after its execution, we need {B E = p(b 2 ) e 2 before its execution. We have the equality (b 2 ) e 2 = b 2 (e 2) from associativity, and then that 2 (e 2) = e because e is even at that point in the program. Do this (1). Do this (2). 3. Why does ( ) have to be associative in order for p, e:= pb, e 1 to (re-)establish the invariant {B E = pb e? Do this (3). 4. Why does 1 have to be a right-identity of ( ) in order for the postcondition {B E = p to be true at the end of the program? Do this (4). 2 Task 2: Transforming your program using a coupling invariant We now assume that p,b and B in Fig. 1 are 2 2 matrices rather than simply natural numbers. Because matrix multiplication is associative and has a left- and right identity, just as normal multiplication of numbers does, the correctness argument still holds! 4 We will transform the program in Fig. 1 in its matrix form into one that just uses ordinary natural numbers to represent those matrices. Introduce twelve natural-number variables B00, B01, B10, B11, b00, b01, b10, b11, p00, p01, p10 and p11. Then use the coupling invariant B = ( ) B00 B 01 B 10 B 11 and b = ( ) b00 b 01 b 10 b 11 and p = ( ) p00 p 01 p 10 p 11 to rewrite the program in Fig. 1 into Dafny-like syntax in the style of Fig. 2. You will of course need to know how matrix multiplication works in order to do this. (Matrix multiplication was covered in the lectures of Week 5, very briefly. There is abundant reference material available for elementary matrix algebra.) Coupling invariants were the subject of the lectures in Week 4. Do not hand in the steps you went through to do the transformation just give the program that the transformation produces. That is, your answer should Do this (5). 4 We also need rules like a(b+c) = ab+ac that hold for matrices as well. Commutativity as we saw in lectures is however not generally true for matrix multiplication. 2

3 One small detail for the matrix version is that the initialisation p:= 1 must be replaced by p:= the identity of matrix multiplication. Figure 1: The program from Week 5 s lectures, in which variables p, b, B were numbers but could also have been 2 2 matrices. be exactly as in Fig. 2 except for your having replaced the question marks with expressions: give it the same structure, and use the same indentation. 5 Also please remove the comments from your answer: they are there only to give you hints about the transformation. 5 This is not just to be fussy: it is to make the markers job easier. You can of course introduce linebreaks if necessary. But be neat! 3

4 // Variables B00,B01,B10,B11 and E are given. var b00,b01,b10,b11: nat; var p00,p01,p01,p11: nat; var e: nat; // Only B s should appear on the right here. b00,b01,b10,b11:=?,?,?,?; // Only constants should appear on the right here. p00,p01,p10,p11:=?,?,?,?; e:= E; while (e!=0) { if (e%2==0) { // Only b s should appear on the right here. b00,b01,b10,b11:=?,?,?,?; e:= e/2; else { // Both p s and b s will appear here. p00,p01,p10,p11:=?,?,?,?; e:= e-1; This program establishes ( ) ( ) E p00 p 01 B00 B = 01. p 10 p 11 B 10 B 11 Figure 2: Calculate the matrix-exponential very quickly. 4

5 3 Task 3: Massaging your program It turns out that we can use your matrix-exponentiation program from Task 2 to calculate Fib(N) very quickly and, when we do that, some of the program s variables can be removed. In this section we will discover which ones can be removed, and how to remove them. The key fact is that, as we saw in lectures, we have ( Fib(N+1) Fib(N) ) = ( ) N ( 1 0 and what our matrix-exponentiation program does is to calculate that N th power on the right. We just have to ( ) 1 1 Supply for B, 1 0 ), Use N for E and ( 1 Add a final assignment f:= the lower element of the 2 1 matrix p 0 ). Given our coupling invariant, the last of those three means adding a final assignment f:= p10; and the first of the three means we can replace the B s by constants. Now we remove some variables. 3.1 Two auxiliary variables can be removed In the final assignment to f proposed just above and to be added to your version of Fig. 2, only one of the four p s appears on the right-hand side. Explain why exactly two (but not all three) of the other p-variables are auxiliary in your program if f is to be the only output. Do this (6). Copy and paste your answer to Task 2 and then edit the new, pasted copy to remove the two auxiliary p-variables you have found: remove their declarations, and all references to them. Replace the B s by appropriate constants, and add Do this (7). the assignment to f at the end. Give your new, smaller program as your answer to this part. Don t forget to declare f and to replace E by N. (Please!) Do not reformat your program in any other way: aside from the removed auxiliary variables etc. it should look just like your answer to Task 2 only slightly smaller. 5

6 3.2 An extra invariant allows two more variables to be removed In our special case where the input B is set to ( ) 1 1 B = 1 0 (1) in order to calculate Fibonacci numbers, the b-variables you introduced in Task 2 will turn out to satisfy the (extra) invariants b 00 = b 10 + b 11 and b 01 = b 10 (2) during the program s execution. We say extra invariants because they are not necessary to prove the program is correct: but they are invariants nevertheless. By focussing only the the statements that assign to the b-variables in your program, prove that under our assumption (1) those two assertions (2) are indeed invariants in this program. Your proof should look like a small calculation Do this (8). in elementary algebra. It s not hard, but it is detailed: so do it carefully. Now use those invariants to remove variables b00 and b01 completely from your program. Using cut-paste-edit as before, give your new, smaller program. Do this (9). Its variables should be (only) b10, b11, p10, p11, e, f and N. 4 Task 4: Running your program The C-program in Fig. 3 uses the slow, obvious algorithm to calculate the six least-significant digits of fib(n) in time linear in N. It has been compiled and tested on CSE lab-machines. 6 It is strongly suggested that you test it out for yourselves; but do not hand-in your tests of this program. Get the program from the course website and put it in a file slowfib.c; compile that with cc -o slowfib slowfib.c; and run it with./slowfib NNN where NNN is some number. The idea here is simply to make sure you can run it, and that it gives the answers you expect. Now modify the C-program slowfib by using your answer to Task 3 7 to make a new C-program fastfib that produces the same output as slowfib does, but much more quickly: in time logarithmic in N. (You might like to run a few tests to see that the programs outputs indeed agree.) But do not hand in this modified program either. Instead, what you have to do is the following. Take your student number (say ) and retain only its last six digits (e.g ). Make a new number by repeating those last six digits 3 times (e.g ); if there are leading zeroes, include them. 8 Run 6 It might run on your own machine too; but, if not, then use a CSE machine. 7 It might be that you are not completely confident of the correctness of the program you produced in Sec. 3.2; in that case use the one you produced in Sec If you are not confident of that one either, use the one you produced in Task 2. You will lose no marks in this section for using those earlier versions: they all produce the same result, and run at the same speed. 8 Thus student z would make the number

7 your fast Fibonacci program fastfib with this large number as input, and cutand-paste the terminal output as your answer for this section. (For z we would expect to see %./fastfib The low-order digits of Fib( ) are % as the answer for this part.) Finally, give an estimate of how long slowfib would take to do the same calculation you just did with fastfib, and justify your estimate. Do this (10). Post script: In the Dafny file for this program (supplied on the course website) there is a verified matrix version of the Fibonacci calculator. Since Dafny handles integers of arbitrary size, the program is not restricted to only the last six digits: you can run it for quite large values of N. The example shown there calculates Fib(10000), and the answer has more than 2,000 digits. (In general Fib(N) has about N/5 decimal digits.) Try it on the Dafny website! Carroll Morgan 2 April 2014

8 // SENG2011 in 2014s1, CCM 1/4/14. // This code is related to Assignment 2. // If you have downloaded it already, you can // get a head start just by checking that // you can compile and run the code here. #include<stdio.h> #include<stdlib.h> #define DIGITS void errorexit(int e) { printf("usage: slowfib N "); printf("where N is a non-negative integer of 18-or-fewer digits (%d).\n",e); exit(e); int main(int argc, char *argv[]) { if (argc!=2) errorexit(1); // Not exactly one parameter. int i,c; for (i= 0;(c= argv[1][i]);i++) { if (i>=18) errorexit(2); // Parameter too long. if (c< 0 9 <c) errorexit(3); // Parameter not number. long long N= atoll(argv[1]); // 18-or-fewer fits into long long. // Parameters now OK. // To make fastfib.c, modify the code between here... long long this= 0; long long next= 1; long long n; for (n= 0; n!=n; n++) { long long thisn= next; next= (next+this) %DIGITS; this= thisn; //...and here. printf("the low-order digits of Fib(%lld) are %lld.\n",n,this); exit(0); Figure 3: Calculate the last six digits of Fib(N) quite slowly.