1 / 42

CSE15 Discrete Mathematics 04/12/17

CSE15 Discrete Mathematics 04/12/17. Ming-Hsuan Yang UC Merced. 5.4 Recursive algorithms. An algorithm is called recursive if it solves a problem by reducing it to an instance of the same problem with smaller input Give a recursive algorithm for computing n! where n is a non-negative integer

myt
Download Presentation

CSE15 Discrete Mathematics 04/12/17

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. CSE15 Discrete Mathematics04/12/17 Ming-Hsuan Yang UC Merced

  2. 5.4 Recursive algorithms • An algorithm is called recursive if it solves a problem by reducing it to an instance of the same problem with smaller input • Give a recursive algorithm for computing n! where n is a non-negative integer • We can compute n!=n∙(n-1)! where n is a positive integer, and that 0!=1 for a particular integer • We use the recursive step n times

  3. Recursive algorithm for n! • procedure factorial(n: non-negative integer) if n=0 then factorial(n):=1 else factorial(n):=n ∙ factorial(n-1)

  4. Recursive algorithm for an • procedure power(a: nonzero real number, n: non-negative integer) if n=0 then power(a,n):=1 else power(a,n):=a ∙ power(a, n-1)

  5. Example • Formulate a recursive algorithm for computing bn mod m, where b, n and m are integers with m≥2, n≥0, 1≤b<m • Let m be a positive integer and let a and b be integers, then (a+b) mod m=((a mod m) + (b mod m)) mod m ab mod m = ((a mod m)(b mod m)) mod m • Thus, bn mod m = (b (bn-1 mod m)) mod m, and b0 mod m = 1

  6. Example • However, we can have a more efficient recursive algorithm • procedure mpower(b, n, m: integers with m≥2, n≥0) if n=0 then mpower(b, n, m)=1 elseif n is even then mpower(b, n, m)=mpower(b, n/2, m)2 mod m else mpower(b, n, m)=(mpower(b, ⌞n/2⌟, m)2 mod m ∙ b mod m) mod m {mpower(b, n, m)=bn mod m}

  7. Example • procedure mpower(b, n, m: integers with m≥2, n≥0) if n=0 then mpower(b, n, m)=1 elseif n is even then mpower(b, n, m)=mpower(b, n/2, m)2 mod m else mpower(b, n, m)=mpower(b, ⌞n/2⌟, m)2 mod m ∙ b mod m) mod m {mpower(b, n, m)=bn mod m} • Trace the above algorithm with b=2, n=5, and m=3 (25 mod 3) • Since n is odd, we have mpower(2, 5, 3)=(mpower(2,2,3)2 mod 3 ∙ 2 mod 3) mod 3 • Next, mpower(2,2,3)=mpower(2,1,3)2 mod 3, and mpower(2,1,3)= (mpower(2,0,3)2 mod 3 ∙ 2 mod 3) mod 3, and mpower(2,0,3)=1 • So, mpower(2,1,3)=(12 mod 3 ∙ 2 mod 3) mod 3 = 2 • So, power(2, 2, 3)=22 mod 3 =1 and finally mpower(2, 5, 3)=(12 mod 3 ∙ 2 mod 3) mod 3 =2

  8. Example • Give a recursive algorithm for gcd(a, b) with a < b • A recursive version of Euclidean algorithm: b=aq+r, gcd(b,a)=gcd(a,r) • procedure gcd(a, b: non-negative integers with a < b) if a=0 then gcd(a, b):=b else gcd(a, b):=gcd(b mod a, a) [Recall r = b mod a] • Let a=5 and b=8. gcd(5, 8)=gcd(8 mod 5, 5)=gcd(3, 5) • Next, gcd(3, 5)=gcd(5 mod 3, 3)=gcd(2, 3), then gcd(2, 3)=gcd (3 mod 2, 2)=gcd(1, 2). Finally gcd(1,2)=gcd(2 mod 1, 2) = gcd(0, 1)=1. Thus, gcd(5,8)=1

  9. Binary search algorithm • procedure binary_search(i, j, x: integers, 1≤i≤n, 1 ≤j≤n) m= ⌞(i+j)/2⌟ if x=amthen location:=m elseif (x < am and i < m) then binary_search(x, i, m-1) else if (x > am and j > m) then binary_search(x, m+1, j) else location:=0

  10. Proving recursive algorithm • Prove that the recursive algorithm power(a, n) is correct using induction • procedure power(a: nonzero real number, n: non-negative integer) if n=0 then power(a,n):=1 else power(a,n):=a ∙ power(a, n-1)

  11. Proving recursive algorithm • Show the recursive algorithm for an • Basis step: n=0, power(a,0)=1 • Inductive step: The inductive hypothesis is power(a,k)=ak for a≠0 and non-negative k. To complete the proof, we need to show power(a,k+1)= ak+1 • As k+1 is a positive integer, the algorithms sets power(a, k+1)=a∙power(a, k)=a∙ak = ak+1 • This completes the inductive step

  12. Recursion and iteration • Often an iterative algorithm is more efficient than a recursive one (unless special-purpose machines are used) • procedure fibonacci(n: nonzero integer) if n=0 then fibonacci(n):=0 else if n=1 then fibonacci(1):=1 else fibonacci(n)=fibonacci(n-1)+fibonacci(n-2)

  13. Recursion and iteration • fibonacci(4) • For fn, it requires fn+1-1 additions

  14. Iterative algorithm for Fibonacci Number • procedure iterative_fibonacci(n: nonzero integer) if n=0 then y:=0 else begin x:=0 y:=1 for i:=1 to n-1 z:=x+y x:=y y:=z end end {y is the n-th Fibonacci number}

  15. Recursion and iteration • The algorithm initializes x as f0=0, and y as f1=1 • When the loop is traversed, the sum of x and y is assigned to the auxiliary variable z • Then x is assigned the value of y and y is assigned the value of the auxiliary variable z • Thus, after going through the loop the first time, it follows x equals f1 and y equals f0+f1=f2 • Next, f1+f2=f3, … • After going through the algorithm n-1 times, x equals fn-1 and y equals fn • Only n-1 additions have been used to find fn • procedure iterative_fibonacci(n: nonzero integer) if n=0 then y:=0 else begin x:=0 y:=1 for i:=1 to n-1 z:=x+y x:=y y:=z end end {y is the n-th Fibonacci number}

  16. Merge sort • Example: Sort the list 8, 2, 4, 6, 9, 7, 10, 1, 5, 3 • Merge sort: split the list into individual elements by successively splitting lists into two • Sorting is done by successively merging pairs of lists

  17. Merge sort • In general, a merge sort proceeds by iteratively splitting lists into two sbulists represented by a balanced binary tree • We can also describe the merge sort recursively • procedure mergesort(L=a1, …, an) if n>1 then m:= ⌞n/2⌟ L1=a1, a2, …, am L2=am+1, …, an L=merge(mergesort(L1), mergesort(L2)) {L is a sorted list in non-decreasing order}

  18. Merge sort • Merge two lists, 2, 3, 5, 6, and 1, 4

  19. Merging two lists • procedure merge(L1, L2: sorted lists) L:=empty set while L1and L2 are both non-empty begin remove smaller of first element of L1 and L2 from the list it is in and put it at the right end of L if removal of this element makes one list empty then remove all elements from the other list and append them to L end {L is a sorted list in non-decreasing order}

  20. Merge sort • Two sorted lists with m elements and n elements can be merged into a sorted list using no more than m+n-1 comparisons

  21. 5.5 Program correctness • Suppose we have designed an algorithm to solve a problem with a program • After debugging (i.e., syntactically correct), how can we be sure that the program always get the correct answer? • Need a proof to show that the program always gives the correct answer • Program verification: uses the rules of inference and proof techniques

  22. Program verification • One form of formal verification • It can be carried out using a computer • However, only limited progress has been made • Some mathematicians and theoretical computer scientists argue that it will never be realistic to mechanize the proof of correctness of complex programs

  23. Program verification • A program is said to be correct if it produces the correct output for every possible input • A proof that a program is correct consists of two parts • Partial correctness: Correct answer is obtained if the program terminates • Shows the program always terminates

  24. Partially correct • To specify a program produces the correct output • Initial assertion: the properties that the input values must have • Final assertion: the properties that output of the program should have, if the program did what was intended • A program or program segment, S is said to be partially correct with respect to the initial assertion p and the final assertion q if whenever p is true for the input values of S and S terminates, then q is true for the output values of S. • The notation p{S}q indicates that the program, or program segment, S is partially correct with respect to the initial assertion p and the final assertion q

  25. Hoare triple • The notation p{S}q is known as one Hoare triple • Show that the program segment y:=2 z:=x+y is correct w.r.t. the initial assertion p: x=1 and the final assertion q: z=3 • Suppose that p is true, so that x=1. Then y is assigned the value 2, and z is assigned the sum of the values of x and y, which is 3. • Hence, S is correct w.r.t the initial assertion p and the final assertion q. Thus p{S}q is true

  26. Rules of inference • Suppose the program S is split into subprograms S1 and S2, denote it by S=S1;S2 • Suppose the correctness of S1 w.r.t. the initial assertion p and final assertion q, the correctness of S2 w.r.t. the initial assertion q and the final assertion r • It follows if p is true and S1 is executed and terminates, then q is true; and if q is true and S2 executes and terminates, then r is true

  27. Rules of inference • Thus, if p is true and S=S1;S2 is executed and terminates, then r is true • This rule of inference, called the composition rule can be stated as

  28. Conditional statements • Consider a program statement if condition then S • To verify this segment is correct w.r.t. initial p and final assertion q, two things must be done • First, when p is true and condition is true, then q is true after S terminates • Second, when p is true and condition is false, then q is true (as S is not executed)

  29. Conditional statements • The rule of inference

  30. Conditional statements • Verify the program segment if x > y then y:=x is correct w.r.t the initial assertion T and the final assertion y≥x • When the initial assertion is true and x>y, then the assignment y:=x is carrier out. Thus, the final assertion is true • When the initial assertion is true and x>y is false, so x≤y, and the final assertion is true • Hence, using the rule of inference for conditional statements, this program is correct w.r.t. the given initial and final assertions

  31. Conditional statements • if condition then S1 else S2 • To verify this program segment is correct w.r.t. the initial assertion p and the final assertions q • First, show that when p is true and condition is true, then q is true after S1 terminates • Second, show that when p is true and condition is false, then q is true after S2 terminates

  32. Conditional statements • The rule of inference

  33. Conditional statements • Verify the program segment if x < 0 then abs:=-x else abs:=x is correct w.r.t. the initial assertion T and the final assertion abs=|x| • Two things must be demonstrated. First, it must be shown that if the initial condition is true and x<0, then abs=|x|. This is correct as when x<0, the assignment statement abs:=-x sets abs=-x, which is |x| by definition when x<0

  34. Conditional statements • Second, it must be shown that if the initial assertion is true and x<0 is false, so that x≥0, then abs=|x|. This is correct as in this case the program uses the assignment abs:=x, and x is |x| by definition when x≥0, so that abs:=x • Hence, using the rule of inference for program segments of this type, this segment is correct w.r.t. the given initial and final assertions

  35. Loop invariants • Proof of correctness of while loops while condition S • Note that S is repeatedly executed until condition becomes false • An assertion that remains true each time S is executed must be chosen • Such an assertion is called a loop invariant • That is, p is a loop invariant if (p∧condition){S}p is true

  36. Loop invariants • Suppose that p is a loop invariant, it follows that is p is true before the program segment is executed, p and ¬condition are true after terminates, if it occurs

  37. Example • A loop invariant is needed to verify the segment i:=1 factorial:=1 while i<n begin i:=i+1 factorial:=factorial∙i end terminates with factorial=n! when n is a positive integer

  38. Example • Let p be the assertion “factorial=i! and i≤n”. We first prove that p is a loop invariant • Suppose that at the beginning of one execution of the while loop, p is true and the condition holds, i.e., assume that factorial=i! that i<n • The new values inew and factorialnew of i and factorial are inew=i+1≤n and factorialnew=factorial ∙(i+1) = (i+1)! = inew! • Because i<n, we also have inew=i+1≤n • Thus p is true at the end of the execution of the loop • This shows that p is a loop invariant

  39. Example • Just before entering the loop, i=1≤n and factorial=1=1!=i! both hold, so p is true • As p is a loop invariant, the rule of inference implies that if the while loop terminates, it terminates with p true and with i<n false • In this case, at the end, factorial=i! and i≤n are true, but i<n is false; in other words, i=n and factorial=i!=n!, as desired • Finally, need to check that while loop actually terminates • At the beginning of the program i is assigned the value 1, so that after n-1 traversals of the loop, the new value of i will be n, and the loop terminates at that point

  40. Example • Verify the correctness of the program S procedure multiply(m, n: integers)

  41. Example • Example S=S1;S2;S3;S4 • Want to show p{S}t is true using p{S1}q, q{S2}r, r{S3}s, s{S4}t • p{S1}q:Let p be the initial assertion “m and n are integers” then it can be shown that p{S1}q is true when q is the proposition p∧(a=|n|) • q{S2}r: Next, let r be q∧(k=0)∧(x=0), it is easily to verify q{S2}r is true

  42. Example • r{S3}s: It can be shown that “x=mk and k≤a” is an invariant for the loop in S3 • Furthermore, it is easy to see that the loop terminates after a iterations, with k=a, so x=ma at this point • As r implies that x=m⋅0 and 0≤a, the loop invariant is true before the loop is entered • As the loop terminates with k=a, it follows that r{S3}s is true where s is the proposition “x=ma and a=|n|” • s{S4}t: Finally, it can be shown that S4 is correct w.r.t. the initial assertion s and final assertion t, where t is the proposition “product=mn” • As p{S1}q, q{S2}r, r{S3}s, s{S4}t are true, by the rule of composition, p{S}t is true

More Related