Discrete Maths: Invariant/2 1 Discrete Maths Objectives – –to show the use of induction for proving properties of code involving loops use induction to prove that functions work – –introduce pre- and post- conditions, loop termination , Semester Loop Invariants

Discrete Maths: Invariant/2 2 Overview 1. What is a Loop Invariant? 2. Three simple examples – –they involve while loops 3. Selection Sort 4. Further Information

Discrete Maths: Invariant/ What is a Loop Invariant? A loop invariant is an inductive statement which says something which is always true about a program loop. Loop invariants are useful for: – –code specification – –debugging continued

Discrete Maths: Invariant/2 4 A loop invariant is typically written as an inductive statement S(n), where n is some changing element of the loop. For example: – –the loop counter/index – –a loop variable which changes on each iteration

Discrete Maths: Invariant/ Example 1 int square(int val) { int result = 0; int counter = 0; while (counter < val) { result += val; counter++; } return result; } Problem: does this function work?

Discrete Maths: Invariant/2 6 We assume that val is a positive integer – –the precondition for this function square() always returns val 2 – –the postcondition – –we will use the loop invariant to show that this is true Pre- and Post-conditions

Discrete Maths: Invariant/2 7 The Loop Invariant To make the proof clearer, let counter n and result n be the values of counter and result after passing round the loop n times. Loop invariant S(n): result n = val * counter n – –is this true in the loop for all n >= 0?

Discrete Maths: Invariant/2 8 Basis S(0) is when the loop has not yet been executed. – –result 0 = counter 0 = 0 So: result 0 = val * counter 0 – –which means that S(0) is true.

Discrete Maths: Invariant/2 9 Induction We assume that S(k) is true for some k >= 0, which means that: result k = val * counter k (1) After one more pass through the loop: result k+1 = result k + val(2) counter k+1 = counter k + 1(3) continued

Discrete Maths: Invariant/2 10 Substitute the rhs of (1) for the 1st operand of the rhs of (2): result k+1 = (val * counter k ) + val = val * (counter k + 1) = val * counter k+1 (by using (3)) – –this is S(k+1), which is therefore true. continued

Discrete Maths: Invariant/2 11 For the loop, we now know: – –S(0) is true – –S(k) --> S(k+1) is true That means S(n) is true for all n >= 0 – –for all n >= 0, the loop invariant is true: result n = val * counter n

Discrete Maths: Invariant/2 12 Termination The loop does actually terminate, since counter is increasing, and will reach val. At loop termination (and function return): counter n = val So in S(n): result n = val * val = val 2 So the postcondition is true. The function works!!

Discrete Maths: Invariant/ Example 2 int exp(int b, int m) // return b m { int res = 1; while (m > 0) { res = res * b; m = m - 1; } return res; } Problem: does this function work?

Discrete Maths: Invariant/2 14 We assume b and m are non-negative integers – –the preconditions for this function exp() always returns b m – –the postcondition – –we will use the loop invariant to show that this is true Pre- and Post-conditions

Discrete Maths: Invariant/2 15 The Loop Invariant To clarify the proof, let res n and m n be the values of res and m after passing round the loop n times. Loop invariant S(n): res n * b m n = b m – –is this true in the loop for all n >= 0? Inventing this is the hardest part.

Discrete Maths: Invariant/2 16 Basis S(0) is when the loop has not yet been executed. – –res 0 = 1; m 0 = m So: 1 * b m = b m – –which means that S(0) is true.

Discrete Maths: Invariant/2 17 Induction We assume that S(k) is true for some k >= 0, which means that: res k * b m k = b m (1) After one more pass through the loop: res k+1 = res k * b(2) m k+1 = m k - 1(3) continued

Discrete Maths: Invariant/2 18 Rearrange the equations: res k = res k+1 / b(2’) m k = m k+1 + 1(3’) Substitute the right hand sides of (2’) and (3’) into (1): ( res k+1 / b ) * b (m k ) = b m which is res k+1 * b (m k ) = b m which is res k+1 * b m k+1 = b m continued

Discrete Maths: Invariant/2 19 S(k+1) is: res k+1 * b m k+1 = b m (4) So we have shown S(k+1) is true by using S(k). continued

Discrete Maths: Invariant/2 20 For the loop, we now know: – –S(0) is true – –S(k) --> S(k+1) is true That means S(n) is true for all n >= 0 – –for all n >= 0, the loop invariant is true: res n * b m n = b m

Discrete Maths: Invariant/2 21 Termination The loop does actually terminate, since m is decreasing, and will reach 0. At loop termination (and function return): m n = 0 So in S(n): res n * b 0 = b m so res n = b m So the postcondition is true. The function works!!

Discrete Maths: Invariant/ Example 3 int factorial(int num) { int i = 2; int fact = 1; while (i <= num) { fact = fact * i; i++; } return fact; } Problem: does this function work?

Discrete Maths: Invariant/2 23 We assume num is a positive integer – –the precondition for this function factorial() always returns num! – –the postcondition – –we will use the loop invariant to show that this is true Pre- and Post-conditions

Discrete Maths: Invariant/2 24 The Loop Invariant To clarify the proof, let fact n and i n be the values of fact and i after passing round the loop n times. Loop invariant S(n): fact n = (i n - 1)! – –is this true in the loop for all n >= 0?

Discrete Maths: Invariant/2 25 Basis S(0) is when the loop has not yet been executed. – –i 0 = 2; fact 0 = 1 So:fact 0 = (i 0 - 1)! 1 = (2 - 1)! 1 = 1 which means that S(0) is true.

Discrete Maths: Invariant/2 26 Induction We assume that S(k) is true for some k >= 0, which means that: fact k = (i k -1)!(1) After one more pass through the loop: fact k+1 = fact k * i k (2) i k+1 = i k + 1(3) continued

Discrete Maths: Invariant/2 27 Substitute the rhs of (1) for the 1st operand of the rhs of (2): fact k+1 = (i k - 1)! * i k = (i k )! = (i k+1 - 1)! (by using (3)) – –this is S(k+1), which is therefore true. continued

Discrete Maths: Invariant/2 28 For the loop, we now know: – –S(0) is true – –S(k) --> S(k+1) is true That means S(n) is true for all n >= 0 – –for all n >= 0, the loop invariant is true: fact n = (i n - 1)!

Discrete Maths: Invariant/2 29 Termination The loop does actually terminate, since i is increasing, and will reach num+1. At loop termination (and function return): i n = num+1 So in S(n): – –fact n = (i n - 1)! = (num )!= num! So the postcondition is true. The function works!!

Discrete Maths: Invariant/ Selection Sort void selectionSort(int A[], int num) { int i, j, small, temp; for (i=0; i < num-1; i++) { small = i; for( j= i+1; j < num; j++) if (A[j] < A[small]) small = j; temp = A[small]; A[small] = A[i]; A[i] = temp; } } swap A[small] and A[i] put index of smallest value in A[i.. num-1] into small

Discrete Maths: Invariant/2 31 Execution Highlights A Start 1st iteration: A sorted A sorted Start 4th iteration: A sorted Start 2nd iteration: Start 3rd iteration: selectionSort(A, 4);

Discrete Maths: Invariant/2 32 We assume num is a positive integer, which contains the number of elements in the array – –the precondition for this function selectionSort() sorts the array into ascending order – –the postcondition – –we will use the loop invariant to show that this is true Pre- and Post-conditions

Discrete Maths: Invariant/ Consider the Inner Loop small = i; for( j= i+1; j < num; j++) if (A[j] < A[small]) small = j; Put index of smallest value in A[i.. num-1] into small

Discrete Maths: Invariant/2 34 We assume i is a positive integer, which is an index into the array – –the precondition for this part of the code This code finds the index of the smallest value in A[i..num-1] – –the postcondition – –we will use the loop invariant to show that this is true Pre- and Post-conditions

Discrete Maths: Invariant/2 35 The Inner Loop Invariant To clarify the proof, let small n and j n be the values of small and j after passing round the loop n times. Loop invariant S(n): small n is the index of the smallest of A[i.. j n -1] – –is this true in the loop for all n >= 0?

Discrete Maths: Invariant/2 36 Execution Highlights A Start 1st pass:small 0 j A small 0 j A small 2 j A small 3 j Start 2nd pass: Start 3rd pass: Start 4th pass: loop ends

Discrete Maths: Invariant/2 37 Basis S(0) is when the loop has not yet been executed. – –small 0 = i; j 0 = i+1 So: small 0 is the index of the smallest of A[i.. j 0 -1] which is A[i..(i+1-1)], or A[i..i], or A[i] That means that S(0) is true.

Discrete Maths: Invariant/2 38 Induction We assume that S(k) is true for some k >= 0, which means that: small k is the index of the smallest of A[i.. j k -1] The pass through the loop involves two possible branches because of the if. continued

Discrete Maths: Invariant/2 39 Case 1. If A[j k ] is not smaller than the smallest of A[i.. j k -1] – –then small k+1 = small k (no change) Case 2. If A[j k ] is smaller than the smallest of A[i.. j k -1] – –then small k+1 = j k continued

Discrete Maths: Invariant/2 40 At the end of the pass: – –small k+1 is the index of the smallest of A[i..j k ] – –j k+1 = j k + 1 S(k+1) is: – –small k+1 is the index of the smallest of A[i.. j k+1 -1] So S(k+1) is true. continued

Discrete Maths: Invariant/2 41 For the inner loop, we now know: – –S(0) is true – –S(k) --> S(k+1) is true That means S(n) is true for all n >= 0 – –for all n >= 0, the inner loop invariant is true: small n is the index of the smallest of A[i.. j n -1]

Discrete Maths: Invariant/2 42 Termination The loop does actually terminate, since j is increasing, and will reach num. At loop termination: j n = num So in S(n): – –small n is the index of the smallest of A[i.. j n -1], or A[i..num-1] So the postcondition is true. The inner loop is proved.

Discrete Maths: Invariant/ The Outer Loop void selectionSort(int A[], int num) { int i, j, small, temp; for (i=0; i < num-1; i++) { small = i; for( j= i+1; j < num; j++) if (A[j] < A[small]) small = j; temp = A[small]; A[small] = A[i]; A[i] = temp; } } proved

Discrete Maths: Invariant/2 44 The Outer Loop Invariant To clarify the proof, let i m be the value of i after passing round the loop m times. Informal loop invariant T(m): i m indicates that we have selected m of the smallest elements and sorted them at the beginning of the array.

Discrete Maths: Invariant/2 45 Graphically A 0 Sorted < mm-1 current sort position i num-1 e.g i m smaller values in array larger values in array

Discrete Maths: Invariant/2 46 More Formally Loop invariant T(m): – –a) A[0..i m -1] are in sorted order; – –b) All of A[i m..num-1] are >= all of A[0..i m -1]

Discrete Maths: Invariant/2 47 Basis T(0) is when the loop has not yet been executed. i 0 =0 – –a) Range is A[0..-1], which means no elements. – –b) Range is A[0..num-1] which means everything > A[0..-1] So T(0) is true.

Discrete Maths: Invariant/2 48 Induction We assume that T(k) is true for some k >= 0, which means that: – –a) A[0..i k -1] are in sorted order; – –b) All of A[i k..num-1] are >= all of A[0..i k -1] continued

Discrete Maths: Invariant/2 49 By the end of the inner loop, we know that A[small] is the smallest element in A[i k..num-1] – –the postcondition of the inner loop The next three lines swap A[small] and A[i k ] – –now A[i k ] contains the smallest element continued

Discrete Maths: Invariant/2 50 Graphically A 0 Sorted < k k-1 current sort position i k num ikik k small swapped smalle.g. continued

Discrete Maths: Invariant/2 51 By the end of the outer loop, we know: – –a) A[0..i k ] are in sorted order; – –b) All of A[i k +1..num-1] are >= all of A[0..i k ] – –i k+1 = i k +1 This shows that T(k+1) is true. continued

Discrete Maths: Invariant/2 52 For the outer loop, we now know: – –T(0) is true – –T(k) --> T(k+1) is true That means T(m) is true for all m >= 0 – –a) A[0..i m -1] are in sorted order; – –b) All of A[i m..num-1] are >= all of A[0..i m -1]

Discrete Maths: Invariant/2 53 Termination The outer loop does actually terminate, since i is increasing, and will reach num-1. At loop termination (and function return): i m = num-1 continued

Discrete Maths: Invariant/2 54 So in T(m): – –a) A[0..i m -1] are in sorted order – –so A[0..num-1-1] is sorted – –so A[0..num-2] is sorted – –all the array up to the last element is sorted continued

Discrete Maths: Invariant/2 55 – –b) All of A[i m..num-1] are >= all of A[0..i m -1] – –so, A[num-1..num-1] >= all A[0..num-1-1] – –so, A[num-1] >= all A[0..num-2] – –so the last element is bigger than all the other array elements So the function does sort the array into ascending order: the postcondition is true

Discrete Maths: Invariant/ Further Information Discrete Mathematics Structures in Computer Science B. Kolman & R. C. Busby Prentice-Hall, 1987, 2nd ed. Section 1.6