מבוא מורחב 1 Lecture 4 Material in the textbook on Pages 44-46, of 2nd Edition Sections and Hanoy towers

מבוא מורחב 2 Review: Recursive Process (define (exp-R a b) ; computes a b (if (= b 0) 1 (* a (exp-R a (- b 1))))) ; a b = a * a b-1 Space b <= R( b ) <= b which is  b  Time b <= R( b ) <= 2 b which is  b  (exp-R 3 4) (* 3 (exp-R 3 3)) (* 3 (* 3 (exp-R 3 2))) (* 3 (* 3 (* 3 (exp-R 3 1)))) (* 3 (* 3 (* 3 (* 3 (exp-R 3 0))))) (* 3 (* 3 (* 3 (* 3 1)))) (* 3 (* 3 (* 3 3))) (* 3 (* 3 9)) (* 3 27) 81 Linear Recursive Process

מבוא מורחב 3 Review – Iterative process (define (exp-iter a b product) (if (= b 0) product (exp-iter a (- b 1) (* a product)))) (define (exp-I a b) (exp-iter a b 1)) Space  1  Time  b  Linear Iterative Process (exp-I 3 4) (exp-iter 3 4 1) (exp-iter 3 3 3) (exp-iter 3 2 9) (exp-iter ) (exp-iter ) 81

מבוא מורחב 4 Another algorithm for computing a b If b is even, then a b = (a 2 ) (b/2) If b is odd, then a b = a*a (b-1) Note that here, we reduce the problem in half in one step. (define (exp-fast a b) ; computes a b (cond ((= b 0) 1) ((even? b) (exp-fast (* a a) (/ b 2))) (else (* a (exp-fast a (- b 1)))))))

מבוא מורחב 5 The conditional form (cond ( ) ( ) …. ( ) (else )) (define (abs x) (cond ((> x 0) x) ((= x 0) 0) ((< x 0) (- x)))) (else (- x))))

מבוא מורחב 6 (exp-fast 3 56) (exp-fast 3 56) ; compute 3^56 (exp-fast 9 28) (exp-fast 81 14) (exp-fast ) 6561 * (exp-fast ) 6561 * (exp-fast ) 6561 * * (exp-fast ) 6561 * * (exp-fast ) 6561 * * * (exp-fast.. 0) 6561 * * (define (exp-fast a b) (cond ((= b 0) 1) ((even? b) (exp-fast (* a a) (/ b 2))) (else (* a (exp-fast a (- b 1)))))))

מבוא מורחב 7 How much time does exp-fast take? The analysis is tight. The order of growth in time and space is  (log b) -- logarithmic. Denote T(b) the number of arithmetic operations it takes to compute ( exp-fast a b). T(b) <= T(b/2)+O(1) T(1) = O(1) Conclusion: T(b)=O(log b) If b is even: T(b) = T(b/2)+2 and if b is odd then: T(b) = T((b-1)/2)+3

מבוא מורחב 8 Comparing the three exponentiation procedures Assume a,b are integers, written in binary with 400 digits. a = …. b = … <= a,b <= TimeSpace exp-R (recursive)  b  exp-I (iterative)  b  1  exp-fast  log  b 

מבוא מורחב 9 Is exp-R feasible? exp-R takes  b  space. We need at least storage bits. That’s about giga bits. Each gigabit costs a dollar… Never mind. Let’s go to the dealer Absolutely infeasible !!!! Sorry, that’s more the number of particles in the universe…..

מבוא מורחב 10 Is exp-I feasible? exp-I takes at least operations. We can run 1 billion (10 9 ) operations a second. We need about seconds. That’s about years. That’s about millenniums. Might be longer then the universe age…. Might be longer than the time our plant will last…. Infeasible !!!!

מבוא מורחב 11 Let’s buy a faster computer and make exp-I feasible. Our new computer can run giga billion (10 18 ) operations a second. Absolutely the last word in the field of computing. We need about seconds. That’s about years. That’s about millenniums. Does not help much. Infeasible !!!!

מבוא מורחב 12 Exp-fast is feasible. We use a first generation pc, manufactured at 1977 and executing one operation a second. We need about 1200 operations. That’s about 20 minutes. We need 1200 storage bits. Feasible !!!!

מבוא מורחב 13 Let’s buy a faster computer.. We use a second generation pc, manufactured at 1987 and executing one million operations a second. We need about 1200 operations. That’s so much less than a second that we do not bother counting it. We still need 1200 storage bits. Very feasible !!!!

מבוא מורחב 14 Towers of Hanoi Three posts, and a set of different size disks A disk can be only on a larger size disk. At the beginning all the disks are on the left post. The goal is to move the disks one at a time, while preserving these conditions, until the entire stack has moved from one post to another

מבוא מורחב 15 Use our paradigm Wishful thinking: Smaller problem: A problem with one disk less How do we use it ? Move n-1 disks from peg A to peg B Move the largest from peg A to peg C Move n-1 disks from peg B to peg C We solve 2 smaller problems !

מבוא מורחב 16 Towers of Hanoi (define (one-move from to) (display "Move top disk from ") (display from) (display " To ") (display to) (newline)) (define (move-tower size from to aux) (cond ((= size 1) (one-move from to)) (else (move-tower (- size 1) from aux to) (one-move from to) (move-tower (- size 1) aux to from))))

מבוא מורחב 17 Towers of Hanoi -- trace (move-tower ) Move top disk from 2 to 1 Move top disk from 2 to 3 Move top disk from 1 to 3 Move top disk from 2 to 1 Move top disk from 3 to 2 Move top disk from 3 to 1 Move top disk from 2 to (move-tower ) (move-tower )

מבוא מורחב 18 Tree Recursion (mt ) (mt ) (mt ) (move-one 2 1) (mt ) (move-one 3 1) (mt ) (move-one 2 3) (mt ) (move-one 1 3)(move-one 3 2)(move-one 2 1)

מבוא מורחב 19 Orders of growth for towers of Hanoi Denote by T(n) be the number of steps that we need to take to solve the case for n disks. T(n) = 2T(n-1) + 1 T(1) = 1 This solves to: T(n) = 2 n - 1 exponential For the space complexity we have S(n) = S(n-1) + O(1) S(n) = O(n)

מבוא מורחב 20 Moral If you wish to see the result Of your programming efforts Better think ahead What your algorithm Is

מבוא מורחב 21 Primality Testing (define (prime? n) (= n (smallest-divisor n))) (define (divides? a b) (= (remainder b a) 0)) (define (smallest-divisor n) (define (find-divisor n i) (cond ((divides? i n) i) (else (find-divisor n (+ i 1))))) (find-divisor n 2)) n is a prime iff its only divisors are 1 and n

מבוא מורחב 22 (Prime? 7) (= 7 (smallest-divisor 7)) (= 7 (find-divisor 7 2)) (= 7 (cond (divides? 2 7) 2) (else (find-divisor 7 3)))) (= 7 (find-divisor 7 3)) (= 7 (cond (divides? 3 7) 3) (else (find-divisor 7 4)))) (= 7 (find-divisor 7 4)) (= 7 (find-divisor 7 5)) (= 7 (find-divisor 7 6)) (= 7 (find-divisor 7 7)) (= 7 7) #t

מבוא מורחב 23 Analysis Time complexity: T(n) = T(n-1) + O(1) T(n)=  (n) – linear in n In fact, for every prime n, the running time is n. If n is a 400 digit number, that’s very bad. Absolutely infeasible.

מבוא מורחב 24 Primality Testing - II (define (prime? n) (= n (smallest-divisor n))) (define (divides? a b) (= (remainder b a) 0)) (define (smallest-divisor n) (define (find-divisor n i) (cond ((> i (sqrt n)) n) ((divides? i n) i) (else (find-divisor n (+ i 1))))) (find-divisor n 2)) n is a prime iff its only divisors are 1 and n Iff it has no divisors between 2 and (sqrt n)

מבוא מורחב 25 Analysis Correctness: If n is not a prime, then n=a * b for a,b>1. Then at least one of them is  n. So n must have a divisor smaller then  n. Time complexity:  (  n). For a number n, we test at most  n numbers to see if they divide n. If n is a 800 digit number, that’s very bad. Absolutely infeasible.

מבוא מורחב 26 The Fermat Primality Test Fermat’s little theorem: If n is a prime number then: a n = a (mod n) for every 0 < a < n, integer The Fermat Test: Do 1000 times: Pick a random a < n and compute a n (mod n) If  a then for sure n is not a prime. If all 1000 tests passed, declare that n is a prime.

27 Computing a b (mod m) fast. (define (expmod a b m) ; computes a b (mod m) (cond ((= b 0) 1) ((even? b) (remainder (expmod (remainder (* a a) m) (/ b 2) m) m)) (else (remainder (* a (expmod a (- b 1) m)) m))))

מבוא מורחב 28 Implementing Fermat test (define (one-test n) (define (test a)(= (expmod a n n) a)) (test (+ 1 (random (- n 1))))) (define (many-tests n t); calls one-test t times (cond ((= t 0) true) ((one-test n) (many-test n (- t 1))) (else false)))

מבוא מורחב 29 Time complexity To test if n is a prime. We run 100 tests. Each takes about log(n) multiplcations. T(n) = O(log n)

מבוא מורחב 30 Some mathematical facts A fact: If n is not a Carmichael number then for at least half of the choices of a, a n <> a (mod n). Fermat’s theorem: Every prime will always pass the test. Definition: A Carmichael number, is a number such that n is Composite, and n always passes the test. For every a, a n = a (mod n)

מבוא מורחב 31 Correctness If n is a prime we are never wrong. If n is a composite and not a Carmichael number we are wrong with probability at most Error probability smaller than the chance the hardware is faulty. Suppose we do the test t=100 times. If n is a Carmichael number, we are always wrong

מבוא מורחב 32 A probabilistic algorithm An algorithm that uses random coins, and for every input gives the right answer with a good probability. Even though Carmichael numbers are very rare Fermat test is not good enough. There are inputs on which it is wrong. There are modifications of Fermat’s test, that for every input give the right answer, with a high probability.