CS 5 Nightly Wrapup College Canceled

Transcription

1 CS 5 Nightly Wrapup College Canceled Claremont (The Student Life): The administrators of Harvey Mudd College announced today that the entire institution had been canceled. Classes will terminate immediately. We realized that there is a much better economic model, explained President G. Reedy. We will continue to accept students, and the tuition will remain the same. After four years of paying tuition, the students will be awarded a degree, just as in previous years. The only difference will be that we won t hold classes. That will give the students more time for the pursuits they love, like video gaming, dancing, partying, and setting things on fire, without harming their chances of getting a lucrative job after they get their degree. When asked what the faculty would be doing, President Reedy smiled. That s the best part! he exclaimed. We ll finally be rid of the pesky critters. No penguins could be reached for comment.

2 cmp hc cmp(5) == 17 hc(cs5) == True Two uncomputable functions these would be useful - if only they were possible PLAN! Friday: final project due (by 8pm) come to labs for f.p. help! 2: final exam

3 All known and imagined computers can compute only what Turing Machines can... Quantum computation Molecular computation Parallel computers Integrated circuits Electromechanical computation Water-based computation Tinkertoy computation Turing Machines! though some are faster than others

4 TM's can do everything though not fast but Useful, FMs + but TMs limited can ~ get unruly pretty fast! can't count Finite State Machines 0 s0 1 s1 0 1 Universal definition of what can be computed Turing Machines Extra #1!

5 TM's can do everything but only everything that can be computed! There are surprisingly many mathematical functions that no program, computer, or Turing Machine can compute! TM Now that's a frustrating program to debug! You can certainly write programs for them, but those programs provably have at least one bug! And, fixing the bug necessarily creates more!

6 (Many) more functions than programs! the Reals from 0 to 1 Positive integers Uncountably infinite > Countably infinite This is how many int-bool functions there are. This is how many programs there are.

7 Cantor and "friends" "Charlatan" "Renegade" "Corrupter of Youth" "Laughable and wrong" "Utter nonsense" No one shall expel us from the paradise that Cantor has created. And this was before 1900! Leopold Kronecker Lugwig Wittgenstein David Hilbert

8 Let's get real the reals (from 0 to 1) { 0.0 <= r <= 1.0 } Are these sets equal-sized? the integers (positive) { 1, 2, 3, 4, 5, } Why is this NOT a valid matching? Essence? Finite patterns!

9 Cantor Diagonalization From any list, there are always real #s missing! the Reals from 0 to 1 Positive integers real #s are always missing r = 0 4 if r i [i]!= 4 else 2 r = matching regardless of the 1 r = r = r = r =

10 more functions than programs uncountably many functions Well-defined mathematical functions (uncountable) Wow ~ I can't even describe the stuff out here! What's swimming around out here? Programs (countable) countably many programs

11 more functions than programs uncountably many functions Well-defined mathematical functions (uncountable) Wow ~ I can't even describe the stuff out here! What's swimming around out here? Programs (countable) countably many programs Humandescribable things

12 more functions than programs uncountably many functions Well-defined mathematical functions (uncountable) Wow ~ I can't even describe the stuff out here! What's swimming around out here? Programs (countable) countably many programs cmp hc Humandescribable things Next

13 But what's a specific function that can't be computed!? an example!? it's computable! anything expressed w/math it's programmable! any describable pattern the complexity of an integer

14 What is the complexity of an integer? 100 zeros total each of these integers has the same # of digits same number of total digits as above **105 Which "feels like" the more complex - or more compressible - number... Why?

15 What is the complexity of an integer? 100 zeros total each of these integers has the same # of digits Intuition: The complexity or compressibility of x is the length of the shortest description of x. same number of total digits as above Which "feels like" the more complex - or more compressible - number... Why?

16 Inputs a "googol" a "googolplex" total zeros googol total zeros 27 Outputs This green function seems alien!!!

17 Inputs a "googol" a "googolplex" total zeros googol total zeros Output s The complexity, cmp, of an integer x is the length of x's shortest description

18 The complexity of x, cmp(x), is the length of the shortest zero-input function that outputs x. "description" The complexity, cmp, of an integer x is the length of x's shortest description

19 The complexity of x, cmp(x), is the length of the shortest zero-input function that outputs x. "description" Kolmogorov Complexity cmp( 42 ) = 18 So, 42 has a complexity of 18. Why 18?

20 Thanks, Neel!

21

22 The complexity of x, cmp(x), is the length of the shortest zero-input function that outputs x. "description" Kolmogorov Complexity cmp( 42 ) = 18 def f(): return because, Python has 16 characters of overhead and 2 more are needed

23 5 17 Inputs Output (x) s cmp(x) def f(): return Python has 16 characters of overhead, so cmp(100) is 19

24 5 17 Inputs Output (x) s cmp(x) def f(): return Python has 16 characters of overhead, so cmp(1000) is 20

25 5 17 Inputs Output (x) s cmp(x) def f(): return Python has 16 characters of overhead, so cmp(10000) is 21

26 5 17 Inputs Output (x) s cmp(x) ? def f(): return Python has 16 characters of overhead, but we can do better here!

27 Inputs (x) Output s cmp(x) 10**5 def f(): return Python has 16 characters of overhead, and cmp(100000) is also 21

28 cmp(42) = = 18 cmp(9001) = 16 + = 20 cmp( )= 6 zeros a million 16 + Worksheet! What does cmp(x)return for each of these integers, x? cmp( )= a million and cmp( ) = 1 googol zeros a googolplex 16 + cmp( )= 9 zeros a billion 16 + cmp( ) = 1 billion digits of pi, as an integer 16 + just estimate this one cmp( )= 100 zeros a googol 16 + cmp( ) = 1 thousand patternless digits 16 + Extra: What's the largest x with cmp(x) == 20? Extra Extra: Are there any integers x with cmp(x) > 1,000,000? Extra Extra Extra! How big is the SMALLEST such integer?

29 cmp(42) = = 18 cmp(9001) = = 20 cmp( )= cmp( )= 10**6+42 cmp( )= 9 zeros a million and 42 a billion cmp( )= 100 zeros a googol Extra: What's the largest x with cmp(x) == 20? 9**9 6 zeros a million vs. 10** **9 10** = 21 whoa! 16 + = 21 = 23 = 23 What does cmp(x)return for each of these integers, x? cmp( ) = 1 googol zeros a googolplex 10**10**100 cmp( ) = 1 billion digits of pi, as an integer cmp( ) = 1 thousand patternless digits just estimate this one 16 + Extra Extra: Are there any integers x with cmp(x) > 1,000,000? yes! Extra Extra Extra! How big is the SMALLEST such integer? 100 for i in range(10**10**100): throwdart() [through all 1,000 digits] = 27

30 cmp(42) = = 18 cmp(9001) = = 20 cmp( )= cmp( )= 10** zeros a million vs. cmp( )= 9 zeros 10**6 a million and a billion 10**9 cmp( )= 100 zeros a googol 10** = 21 whoa! 16 + Try this on the back page first... = 21 = 23 = 23 What does cmp(x)return for each of these integers, x? cmp( ) = 1 googol zeros a googolplex 10**10**100 cmp( ) = 1 billion digits of pi, as an integer cmp( ) = 1 thousand patternless digits Quiz! just estimate this one for i in range(10**10**100): throwdart() [through all 1,000 digits] = 27 Extra: What's the largest x with cmp(x) == 20? 9**9 Extra Extra: Are there any integers x with cmp(x) > 1,000,000? Yes, a LOT! Extra Extra Extra! How big is the SMALLEST such integer? Sorry...

31 Although cmp(x) is a well-defined mathematical function, with an int output for each int input x, cmp(x) the complexity of x the compressability of x is not a programmable function. all of its programs have bugs! This is a function that we will prove can't be programmed How!?

32 Although cmp(x) is a well-defined mathematical function, with an int output for each int input x, cmp(x) is not a programmable function. the complexity of x the compressability of x all of its programs have bugs! You'll show every possible program for cmp has a bug! you This is a function that we will prove can't be programmed How!?

33 Although cmp(x) is a well-defined mathematical function, with an int output for each int input x, cmp(x) is not a computable function. the complexity of x the compressability of x all of its programs have bugs! You'll show every possible program for cmp has a bug! you This is a function that we will prove can't be programmed How!?

34 cmp version #1 We know cmp(5)==17, so we propose this: def cmp( x ) return x+12 Looks good to me! bug(s)?

35 cmp version #1 We know cmp(5)==17, so we propose this: def cmp( x ) return x+12 Aargh! No 42! cmp(42) should be 18. Find a bug: But our cmp(42) outputs 60. it's not colon-y! no docstring! This cmp has a bug! (actually, LOTS of bugs!)

36 cmp version #2 We know cmp(x) is 16+, so, let's try this: def cmp( x ): return 16 + len(str(x)) It works for 5, 42, and 47! bug(s)?

37 cmp version #2 We know cmp(x) is 16+, so, let's try this: def cmp( x ): return 16 + len(str(x)) It works for 5, 42, and 47! Find a bug: cmp(100000) is actually 21. But, this cmp(100000) isn't digits because 10**5 it's 22 So, this cmp also has a bug! (lots, in fact )

38 cmp ~ any version Aargh! Let's try this cmp(x): def cmp( x ): do stuff and then return answer I guess you'd call this part of the code a GRAY AREA

39 cmp ~ any version Aargh! Let's try this cmp(x): def cmp( x ): do stuff and then return answer I guess you'd call this part of the code a GRAY AREA The challenge: we have to find a bug in any possible version of cmp(x)!

40 def cmp( x ): do stuff and then return answer This version of cmp is 900,000 chars long and claims to return the complexity of x We need to prove that this cmp(x) function contains a bug. We're going to write a function to find and show that bug!

41 def BFF(): def cmp( x ): do stuff and then return answer x = 0 while cmp(x) < : x += 1 return x This version of cmp is 900,000 chars long and claims to return the complexity of x bug = BFF() BFF?

42 def BFF(): def cmp( x ): do stuff and then return answer x = 0 while cmp(x) < : x += 1 return x This version of cmp is 900,000 chars long and claims to return the complexity of x bug = BFF() BFF? Bug-Finding Function!

43 def BFF(): def cmp( x ): do stuff and then return answer x = 0 while cmp(x) < : x += 1 return x bug = BFF() This version of cmp is 900,000 chars long and claims to return the complexity of x Note that BFF is a zero-input function that is 900,058 characters long and it returns an integer, bug! yet...

44 def BFF(): def cmp( x ): do stuff and then return answer x = 0 while cmp(x) < : x += 1 return x bug = BFF() This version of cmp is 900,000 chars long and claims to return the complexity of x Note: this loop checks cmp(x), not x itself. (1) When does this while loop stop? [A] when cmp(x)< 1,000,000 or [B] when cmp(x)>= 1,000,000 or [C] it never stops (2) The while ensures the x BFF returns is [T] an int x with complexity < 1,000,000 [U] an int x with complexity >= 1,000,000 [V] nothing x is never returned at all (1) (2) Proof (3) Why does this mean cmp has a bug? [F] because x!= bug [G] BFF shows bug's complexity is 900,058 or less! [H] there were no three-eyed aliens involved -) (3)

45 def BFF(): def cmp( x ): do stuff and then return answer This version of cmp is 900,000 chars long and claims to return the complexity of x x = 0 while cmp(x) < : x += 1 return x bug = BFF() zero-input f'n of size less than a million Even this implementation of cmp(x) contains a bug! but, we allowed it to do anything at all! number with complexity ver a million! cmp failed! so, every implementation of cmp(x) contains a bug!

46 Although cmp(x) is a well-defined mathematical function, with an int output for each int input x, cmp(x) is not a computable function. cmp(x) can't be debugged! proven!

47 Compression connection? The best-compressed version of any data D is the shortest program that generates D.

48 Compression connection? The best-compressed version of any data D is the shortest program that generates D. An impressive compression result!

49 Compression connection? The best-compressed version of any data D is the shortest program that generates D. best-compressed version? Uncomputable!

50 XkcD Kolmogorov Complexity?

51 insight? Some infinite patterns/functions have finite descriptions. - they're all programmable/ computable More infinite patterns/functions do not have finite descriptions. - they're not programmable/computable

52 insight? not all infinities are created equal! Some infinite patterns/functions have finite descriptions. - they're all programmable/ computable More infinite patterns/functions do not have finite descriptions. - they're not programmable/computable

53 Two useful functions that provably can't be computed cmp( x ) Kolmogorov Complexity ~ the complexity of an integer x (compressibility) hc( f ) Halt Checking ~ does f() halt or loop forever?

54 Haltchecking is uncomputable. hc( f ) Halt Checking ~ returns whether f() halts or not hc always has a bug!

55 Haltchecking is uncomputable. any Python function def hc( f ): It is impossible to write a (bug-free) function hc(f) that determines if a function f halts when run: hc(f) returns True if f() halts and hc(f) returns False if f() loops infinitely

56 Suppose hc(f) worked for all f Create this BFF: def BFF(): if hc(bff) == True: while 1+1==2: print 'Ha!' else: return # halt! Is hc(bff) == True? Is hc(bff) == False? hc always has a bug Proven!

57 And this is important because

58 And this is important because loops are undetectable some are detectable, but some are not and there's no way to know!

59 And this is important because loops are undetectable some are detectable, but some are not and there's no way to know! bugs are inevitable infinite loops are just one type of bug In general, they're all undetectable ~ all behavioral, not syntactic, bugs Rice's Theorem: CS81

60 And this is important because loops are undetectable some are detectable, but some are not and there's no way to know! bugs are inevitable infinite loops are just one type of bug In general, they're all undetectable ~ all behavioral, not syntactic, bugs Rice's Theorem: CS81 programming is not automatable at least, not bug-free programming

61 xkcd's take is all too True, in fact. Good luck with final projects They will halt all too soon! Tutoring hours and labs through Friday...!

62 CS5 Black Worksheet Name: Date: