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

2. Review: Recursive Process
(define (exp-R a b) ; computes ab
(if (= b 0) 1
(* a (exp-R a (- b 1))))) ; ab = a * ab-1
(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
Space b <= R(b) <= b which is Q(b)
Time b <= R(b) <= 2b which is Q(b)
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))
(exp-I 3 4)
(exp-iter 3 4 1)
(exp-iter 3 3 3)
(exp-iter 3 2 9)
(exp-iter )
(exp-iter ) 81
Space Q(1)
Time Q(b)
Linear Iterative Process
מבוא מורחב

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

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

6. (exp-fast 3 56) (define (exp-fast a b)
(cond ((= b 0) 1) ((even? b) (exp-fast (* a a) (/ b 2))) (else (* a (exp-fast a (- b 1)))))))
(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 * *
מבוא מורחב

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

8. Comparing the three exponentiation procedures
Assume a,b are integers, written in binary with 400 digits.
a = ….
b = ….
2400 <= a,b <= 2401
Time
Space
exp-R (recursive)
Q(b)
exp-I (iterative)
Q(1)
exp-fast
Q(log b)
מבוא מורחב

9. Is exp-R feasible? exp-R takes Q(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
Sorry, that’s more the number of particles
in the universe…..
Absolutely infeasible !!!!
מבוא מורחב

10. Is exp-I feasible? exp-I takes at least 2400 operations.
We can run 1 billion (109 ) 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 (1018 ) 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 (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))))
(define (one-move from to)
(display "Move top disk from ")
(display from)
(display " To ")
(display to)
(newline))
מבוא מורחב

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 3 to 2
Move top disk from 3 to 1
(move-tower )
(move-tower ) 2 1 3 2 1 3 2 1 3 2 1 3 2 1 3 2 1 3 2 1 3 2 1 3
מבוא מורחב

18. Tree Recursion (mt 3 2 1 3) (mt 2 2 3 1) (mt 2 3 1 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) = 2n 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. n is a prime iff its only divisors are 1 and n
Primality Testing
n is a prime iff its only divisors are 1 and 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))
(define (prime? n)
(= n (smallest-divisor n)))
מבוא מורחב

22. (= 7 (smallest-divisor 7))
(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 n is a prime iff its only divisors are 1 and n
Iff it has no divisors between 2 and (sqrt 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))
(define (prime? n)
(= n (smallest-divisor 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:
an = a (mod n) for every 0 < a < n, integer
The Fermat Test:
Do 1000 times:
Pick a random a < n and compute an (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 ab (mod m) fast.
(define (expmod a b m) ; computes ab (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
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, an = a (mod n)
A fact: If n is not a Carmichael number then for at least half of the choices of a, an <> a (mod n).
מבוא מורחב

31. Correctness Suppose we do the test t=100 times.
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.
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.
מבוא מורחב