1 / 26

Today

Today. - Limits of computation - Complexity analysis examples. The “Hello” Assignment. Suppose I gave you an assignment to write a computer program which returns “Hello!” and stops. (Assume this is a procedure with no parameters).

griffith-torres
Télécharger la présentation

Today

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. Today - Limits of computation - Complexity analysis examples

  2. The “Hello” Assignment • Suppose I gave you an assignment to write a computer program which returns “Hello!” and stops. (Assume this is a procedure with no parameters). • Suppose I promised you full credit for ANY working program which returns “Hello!” and halts, and no credit if it didn’t work.

  3. The “Hello” Assignment • Can I write a program that automatically grades your homework?

  4. The “Hello” Assignment • Can I write a program that automatically grades your homework? • Sure, right? (define (GradeHello P) (let ((out (P))) (if (eq? out ‘Hello!) 100 0)))

  5. The “Hello” Assignment • No! What if a student submits: (define (p) (define (q n) (cond ((> n 0) (q n)) (else 'Hello))) (q 10)) • Student’s program runs forever! • This means the grading program would run forever. • It would never tell me that the student should fail… • Maybe we can stop the Program after 1 hour and fail the student if the program hasn’t stopped yet.

  6. The “Hello” Assignment • Well, in that case lets submit: (define (p) (hanoi 1 2 3 50);; hanoi with 50 pegs 'Hello) • My grading program would say to fail you. • But technically you deserve to Pass.

  7. The “Hello” Assignment • We keep running in to problems… • Could it be that writing a computer program to grade such a simple assignment is impossible? • YES! We’ll prove it…

  8. Is there a limit to the power of computers? Q: Is there any problem a computer cannot solve? We need some definition to start with: What is a “problem”? And what is a “computer”?

  9. What is a “computer”? A1: Fortran program running on PDP 11. A2: Java program running on a PC with Pentium V under Windows XP at 3GHz. A3: C++ program running on MAC G4 under OSX at 800MHz. A4: All of the above A5: None of the above

  10. Church-Turing Thesis All “reasonable” models of programming languages and computers are equivalent. Each can emulate the other. There is nothing essential in Java, C+ + , Cobol, Lambda Calculus, Mathematica, (or even Scheme).

  11. Is there a limit to the power of computers? Q: Is there any problem a computer cannot solve? We still have to define what a “problem” means. We will restrict ourselves to well posed problems with a yes/no answer. A solution will be a scheme procedure.

  12. The halting problem • The halting problem H: • Given a pair of expressions x and y. • x is viewed as a Scheme procedure. • H(x,y) is true iff xis a valid procedure • and it stops on the input y. Example x = (define (f z) (if (= z 1) 1 (+ z (f z)))) , y = 1 H(x,y) is true x = (define (f z) (if (= z 1) 1 (+ z (f z)))) , y = 2 H(x,y) is false

  13. The halting problem is not solvable Proof: By contradiction. • Suppose there is a Scheme procedure halt that solves the halting problem. This means that • for all x,y (halt x y) always terminates • for all x,y (halt x y) returns true if and only if the procedure xstops when applied to argument y. Now consider the following program D: (define (D x) (define (loopy) (loopy)) (if (halt x x) (loopy) #t))

  14. The halting problem is not solvable (define (D x) (define (loopy) (loopy)) (if (halt x x) (loopy) #t)) Now we run D giving it as argument D: (D D) If D stops on D, then by def of halt procedure (halt D D) returns #t . then from the code of D, D enters an infite loop on D, a contradiction. If D does not stop on D, then by def of halt procedure (halt D D) returns #f . then from the code of D, D stops on D, a contradiction. Conclusion: Both possibilities lead to a contradiction. Therefore a procedure halt that solves the halting problem does not exist.

  15. In fact there are many well posed problems a computer cannot solve! A counting argument: The number of computer programs is countable (since each is a finite string). The number of problems/languages is uncountable. So most problems are not solvable. But we did not just showed existence, but pointed out a specific non-computable problem. Is there a limit to the power of computers? Q: Is there any problem a computer cannot solve? A: YES. There are well posed problems a computer cannot solve!

  16. Final Exam ~4 Questions • 3 Hours • You may bring any written or printed material (no laptops..) • You can use every function studied in class \ recitation \ exercise • All covered material except for computability (first part of this lecture) and parallel computation (previous lecture) • Good Luck and have a nice vacation!

  17. Complexity Analysis Examples

  18. Common Recurrences T(n) = T(n-1) + (1)  (n) T(n) = T(n-1) + (n)  (n2) T(n) = T(n/2) + (1)  (logn) T(n) = T(n/2) + (n)  (n) T(n) = 2T(n-1) + (1)  (2n) T(n) = 2T(n/2) + (1)  (n) T(n) = 2T(n/2) + (n) (nlogn) 19

  19. (filter (lambda (positions) (safe? positions)) (accumulate append null (map (lambda (rest-of-queens) (map (lambda (new-row) (adjoin-position new-row rest-of-queens)) (enumerate-interval 1 board-size))) (queen-cols (- k 1))))) 20

  20. (define (mean-record ds) (let ((records ds)) (let ((n (length records))) (map (lambda (x) (/ x n)) (accumulate (lambda (x y) (map + x y)) (car records) (cdr records)))))

  21. (define (onto? n m f) (define (rem-dup s) (if (null? s) s (cons (car s) (filter (lambda(x) (not (eq? (car s) x))) (rem-dup (cdr s)))))) (define (image f n) (rem-dup (map f (integers-between 1 n)))) (eq? m (length (image f n)))

  22. Mobile weight (define (total-weight mobile) (if (atom? mobile) mobile (+ (total-weight ) (total-weight ) ))) (define (atom? x) (and (not (pair? x)) (not (null? x)))) (branch-structure (left-branch mobile)) (branch-structure (right-branch mobile)) 23

  23. balanced? (define (balanced? mobile) (or (atom? mobile) (let ((l (left-branch mobile)) (r (right-branch mobile))) (and (= ) (balanced? ) (balanced? ))))) (* (branch-length l) (total-weight (branch-structure l))) (* (branch-length r) (total-weight (branch-structure r))) (branch-structure l) (branch-structure r) 24

  24. Complexity Worst case scenario for size n Need to test all rods May depend on mobile structure Upper bound Apply total-weight on each sub-mobile O(n2) Lower bound 25

  25. Mobile structures n n-1 n-2 n-3 . . . T(n) = T(n-1) + (n) (for this family of mobiles) T(n) = (n2) 26

  26. Mobile structures n/2 n/2 n/4 n/4 n/4 n/4 n/8 n/8 n/8 n/8 n/8 n/8 n/8 n/8 T(n) = 2T(n/2) + (n) (for this family of mobiles) T(n) = (nlogn) 27

More Related