How Computers Work. Computational Thinking for Everyone. Rex Page University of Oklahoma work supported by National Science Foundation Grant

Transcription

1 How Computers Work Computational Thinking for Everyone Rex Page University of Oklahoma work supported by National Science Foundation Grant Ruben Gamboa University of Wyoming Trends in Functional Programming in Education St Andrews UK, 11 June 2012

2 History Applied Logic for HW and SW present Boolean algebra, induction, rigorous proofs Reasoning about FP software and digital circuits Required course for CS students at OU Arts and Sciences students enroll occasionally Literature, Linguistics, Philosophy, Physics, Chemistry, Honors Program, University of Oklahoma Add-on for any discipline, requires 3.4 GPA (out of 4.0) Two perspectives courses required (over 20 offered) New in 2011: How Computers Work: Logic in Action AL + some FP + popular apps + term paper Karnaugh etc First technical course in perspectives classification June 2012 TFPIE Rex Page and Ruben Gamboa How Computers Work: Computational Thinking 2

3 Demographics HCW: Logic in Action, honors perspectives course 36 students so far (17 in 2011, 19 in 2012) Chemistry Biochemistry Physics Microbiology Meteorology Science 44% History Linguistics Economics Humanities Psychology Business 22% Philosophy Drama Letters Engineering 31% EE MechE ChemE CS CompE Highly motivated, talented Average Exam Scores 89% 91% 94% humanities science engineering all exam scores 90% except for 3 sci/engr and 3 humanities students June 2012 TFPIE Rex Page and Ruben Gamboa How Computers Work: Computational Thinking 3

4 Boolean Equations x False = x { identity} x True = True { null} x y = y x { commutative} (x y) z = x (y z) { associative} x (y z) = (x y) (x z) { distributive} x y = ( x) y {implication} (x y) = ( x) ( y) { demorgan} x x = x { idempotent} x x = True {self-implication} ( x) = x {double negation} Axioms x True = x { identity} x (y z) = (x y) (x z) { distributive} (x y) = ( x) ( y) { demorgan} x (y z) = (x y) z {Currying} (x y) y = y { absorption} False True { truth table entry} 50 + equations derived in lectures, homework, exams Derived Equations June 2012 TFPIE Rex Page and Ruben Gamboa How Computers Work: Computational Thinking 4

5 Boolean Formulas Circuits (x y) y= y { absorption} (x y) y = (x y) (y False) { identity} = (y x) (y False) { commutative} = y (x False) { distributive} = y False { null} = y { identity} Derivation x y ( x) ( y) physical representation of Boolean formula x y Computers = Logic Engines two domains, same methods How Computers Work (x y) June 2012 TFPIE Rex Page and Ruben Gamboa How Computers Work: Computational Thinking 5

6 Software Equations (first (cons x xs)) = x (rest (cons x xs)) = xs (cons x 0 [x 1 x 2 x n ]) = [x 0 x 1 x 2 x n ] (len nil) = 0 (len (cons x xs)) = (+ 1 (len xs)) (append nil ys) = ys (append (cons x xs) ys) = (cons x (append xs ys)) (append xs (append ys zs)) = (append (append xs ys) zs) (len(append xs ys)) = (+ (len xs) (len ys)) Testable Properties (defproperty append-is-associative (xs :value (random-list-of (random-integer)) ys :value (random-list-of (random-integer)) zs :value (random-list-of (random-integer))) (equal (append xs (append ys zs)) (append (append xs ys) zs)))) (defproperty append-preserves-lens (xs :value (random-list-of (random-integer)) ys :value (random-list-of (random-integer))) (= (len(append xs ys)) (+ (len xs) (len ys)))) Dracula Tests June 2012 TFPIE Rex Page and Ruben Gamboa How Computers Work: Computational Thinking 6

7 Reasoning about Software (first (cons x xs)) = x {first} (rest (cons x xs)) = xs {rest} (cons x 0 [x 1 x 2 x n ]) = [x 0 x 1 x 2 x n ] {cons} (len nil) = 0 {len0} (len (cons x xs)) = (+ 1 (len xs)) {len1} (append nil ys) = ys {app0} (append (cons x xs) ys) = (cons x (append xs ys)) {app1} many other assumed properties (definitional equations) Axioms (append xs (append ys zs)) = (append (append xs ys) zs) (len (append xs ys)) = (+ (len xs) (len ys)) many properties derived from definitional equations (len (append [x 1 x 2 x n+1 ] ys)) = (len (append (cons x 1 [x 2 x n+1 ]) ys)) {cons} = (len (cons x 1 (append [x 2 x n+1 ] ys))) {app1} = (+ 1 (len (append [x 2 x n+1 ] ys))) {len1} = (+ 1 (+ (len [x 2 x n+1 ]) (len ys))) {ind hyp} algebraic reasoning from axioms and derived equations = (+ (len [x 1 x 2 x n+1 ]) (len ys)) {cons} Derived Equations Derivation June 2012 TFPIE Rex Page and Ruben Gamboa How Computers Work: Computational Thinking 7

8 Mechanized Logic (first (cons x xs)) = x {first} (rest (cons x xs)) = xs {rest} (cons x 0 [x 1 x 2 x n ]) = [x 0 x 1 x 2 x n ] {cons} (len nil) = 0 {len0} (len (cons x xs)) = (+ 1 (len xs)) {len1} (append nil ys) = ys {app0} (append (cons x xs) ys) = (cons x (append xs ys)) {app1} Axioms (defproperty append-is-associative (xs :value (random-list-of (random-integer)) ys :value (random-list-of (random-integer)) zs :value (random-list-of (random-integer))) (equal (append xs (append ys zs)) (append (append xs ys) zs)))) (defproperty append-preserves-lens (xs :value (random-list-of (random-integer)) ys :value (random-list-of (random-integer))) (= (len (append xs ys)) (+ (len xs) (len ys)))) ACL2 Theorems Dracula employs ACL2 theorem prover to verify properties June 2012 TFPIE Rex Page and Ruben Gamboa How Computers Work: Computational Thinking 8

9 Programming (bits 0) = nil {b0} (bits (n+1) ) = (cons (mod (n+1) 2) (bits(floor (n+1) 2) {b1} (numb nil) = 0 {n0} (numb (cons x xs)) = x + 2 (numb xs) {n1} Properties (defun bits (n) ; (bits n) = binary numeral for n (if (zp n) ; (numb(bits n)) = n nil ; {b0} (cons (mod n 2) (bits (floor n 2))))) ; {b1} (defun numb (xs) ; xs = [x 0, x 1,... x w-1 ] (if (consp xs) ; (numb xs) = 2 0 x x w-1 x w-1 (numb (+ (first xs) ; {n1} (* 2 (numb(rest xs)))) 0)) ; {n0} ACL2 Notation (program) Properties that define functions Comprehensive cover all cases The 3 C s Consistent no conflicts in overlapping cases Computational circular references closer to non-circular case June 2012 TFPIE Rex Page and Ruben Gamboa How Computers Work: Computational Thinking 9

10 Ripple-Carry Adder Circuit x 0 y 0 x 1 y 1... x w-1 y w-1 c 0 full adder c 1 full adder c 2 c w-1 full adder c s 0 s 1 adder circuit... s w-1 c w-1... c 1 c 0 input carry c 0 = 0 + x w-1... x 1 x 0 y w-1... y 1 y 0 2 s complement numerals for x and y -2 w-1 x, y 2 w-1 1 c s w-1... s 1 s 0 2 s complement numeral for x + y 2 s complement arithmetic with w-bit words June 2012 TFPIE Rex Page and Ruben Gamboa How Computers Work: Computational Thinking 10

11 Expected Property of Circuit x 0 y 0 x 1 y 1... x w-1 y w-1 c 0 full adder c 1 full adder c 2 c w-1 full adder c s 0 s 1 adder circuit... s w-1 c w-1... c 1 c 0 Expected Property c c x w-1... x 1 x 0 y w-1... y 1 y 0 s w-1... s 1 s 0 + x w-1 2 w x x y w-1 2 w y y = c2 w + s w-1 2 w s s June 2012 TFPIE Rex Page and Ruben Gamboa How Computers Work: Computational Thinking 11

12 Algebraic Model Adder Circuit Expected Property c x w-1 2 w x x y w-1 2 w y y = c2 w + s w-1 2 w s s add([x 0, x 1, x w-1 ], [y 0, y 1, y w-1 ], c 0 ) = ([s 0, s 1, s w-1 ], c) {add, w 1} where (s 0, c 1 ) = full-adder(x 0, y 0, c 0 ) ([s 1, s w-1 ], c) = add([x 1, x w-1 ], [y 1, y w-1 ], c 1 ) add([ ], [ ], c 0 ) = ([ ], c 0 ) {add, w = 0} full-adder(x, y, c in ) = (s, c out ) {full-adder} where s = xor-gate(p, c in ) p = xor-gate(x, y) Derive property c out = or-gate(q, r) q = and-gate(c in, p) from algebraic model r = and-gate(x, y) full-adder circuit x y c in c in x y s c out June 2012 TFPIE Rex Page and Ruben Gamboa How Computers Work: Computational Thinking 12

13 Model in ACL2 Notation add([x 0, x 1, x w-1 ], [y 0, y 1, y w-1 ], c 0 ) = ([s 0, s 1, s w-1 ], c) {add, w 1} where (s 0, c 1 ) = full-adder(x 0, y 0, c 0 ) ([s 1, s w-1 ], c) = add([x 1, x w-1 ], [y 1, y w-1 ], c 1 ) add([ ], [ ], c 0 ) = ([ ], c 0 ) {add, w = 0} (defun add (x y c0) ; x = [x 0, x 1,... x w-1 ], y = [y 0, y 1,... y w-1 ] (if (consp x) ; (add x y c 0 ) = ([s 0, s 1,... s w-1 ], c) (let* ((x0 (first x)) (xs (rest x)) (y0 (first y)) (ys (rest y)) (a0 (full-adder x0 y0 c0)) (s0 (first a0)) (c1 (second a0)) (a (add xs ys c1)) (ss (first a)) (c (second a))) (list (cons s0 ss) c)) ; {add, w 1} (list nil c0))) ; {add, w = 0} Expected Property + x w-1 2 w x x y w-1 2 w y y June 2012 TFPIE Rex Page and Ruben Gamboa How Computers Work: Computational Thinking 13 c = c2 w + s w-1 2 w s s model in ACL2 notation

14 Verification by Mechanized Logic (defproperty expected-property-of-add (c0 :value (random-between 0 1) x :value (random-list-of (random-between 0 1)) y :value (random-list-of (random-between 0 1) :size (len x))) (implies (= (len x) (len y)) (let* ((a (add x y c0)) (s (first a)) (c (second a))) (= (+ (numb(list c0)) (numb x) (numb y)) (numb(append s (list c))))))) (defun numb (x) ; x= [x 0, x 1,... x w-1 ] (if (consp x) ; (numb x) = 2 0 x x w-1 x 0 (if (= (first x) 1) ; w 1 (+ 1 (* 2 (numb(rest x)))) ; x 0 = 1 (* 2 (numb(rest x)))) ; x 0 = 0 0)) ; w = 0 Expected Property + x w-1 2 w x x y w-1 2 w y y June 2012 TFPIE Rex Page and Ruben Gamboa How Computers Work: Computational Thinking 14 c = c2 w + s w-1 2 w s s expected property in ACL2 notation

15 Massive Scale Computing Google Search trees Map/reduce for distributed computing Facebook Sharding Cassandra NoSQL databases Massive scale makes engineering necessary Ideas described in terms of FP concepts June 2012 TFPIE Rex Page and Ruben Gamboa How Computers Work: Computational Thinking 15

16 Course Themes and Ideas Central themes Equations Algebraic models and reasoning Prerequisite: basic algebra (standard college prep) Big ideas Creativity (proofs) Abstraction (functions) Data (representations) Algorithms (binary arith, search trees, ) Programming (3 C s) Impact (Google, Facebook) June 2012 TFPIE Rex Page and Ruben Gamboa How Computers Work: Computational Thinking 16

17 Computational Thinking AP Course Central themes Equations Algebraic models Prerequisite: basic algebra (standard college prep) Big ideas Computational Thinking: CS Principles Creativity College-prep curriculum Abstraction General education elective Secondary school or early college Data College Board AP Course Algorithms Depth and substance Programming Challenging, even for good students Impact Accessible to all college-bound students Internet Positive Attributes of This Approach June 2012 TFPIE Rex Page and Ruben Gamboa How Computers Work: Computational Thinking 17

18 The End