Discrete Mathematics Review

Transcription

1 CS 1813 Discrete Mathematics Discrete Mathematics Review or Yes, the Final Will Be Comprehensive 1

2 Truth Tables for Logical Operators P Q P Q False False False P Q False P Q False P Q True P Q True P True False True False True True True False True False False True True False False True True True True False True True False 2

3 Predicates and Quantifiers Predicate Parameterized collection of propositions P(x) Typically a different proposition for each x Universe of discourse Values that x may take Quantifiers x.p(x) True iff the proposition P(x) is True for every x in the universe of discourse x.p(x) True iff there is at least one x in the universe of discourse for which the proposition P(x) is True 3

4 Fig 2.1, Hall/O Donnell Discrete Mathematics with a Computer Springer, 2000 Rules of Inference Propositional Calculus 4

5 Inference Rules of Predicate Calculus Renaming Variables F(x) {x arbitrary, y not in F(x)} {R} F(y) x. F(x) {y not in F(x)} { R} y. F(y) x. F(x) {y not in F(x)} { R} y. F(y) Introducing/Eliminating Quantifiers F(x) {x arbitrary} { I} x. F(x) F(x) { I} x. F(x) { E} rule triggers discharge x. F(x) {universe is not empty} { E} F(x) x. F(x) F(x) A {x not free in A} { E} A...plus the inference rules of propositional calculus 5

6 Induction Rules of Inference P(0) n.(p(n) P(n+1)) {Ind} n.p(n) Induction n.(( m<n.p(m)) P(n)) {StrInd} n.p(n) Strong Induction t. (( s t. P(s)) P(t)) {TrInd} t.p(t) Tree Induction {P(v) B(v)} s {P(v)} {LInd} {P(v)} (while B(v) do s) {P(v) B(v)} Loop Induction s t means s is a proper subtree of t v is a set v of variables P(v) and B(v) are predicates cannot alter values in v s is a command s may alter values in v 6

7 Some Theorems in Rule Form a b { Comm} b a And Commutes a b b c { Chain} a c Implication Chain Rule a b b {modtol} a {nomiddle} a ( a) Modus Tollens Law of Excluded Middle a a { +&- } False a b { Comm} b a NeverBoth Or Commutes (a b) { ( )Comm} (b a) Not Or Commutes a b {conpos F } ( b) ( a) Contrapositive Fwd a b { F } ( a) b Implication Fwd 7

8 More Theorems in Rule Form (a b) {DeM F } ( a) ( b) DeMorgan Or Fwd (a b) {DeM F } ( a) ( b) DeMorgan And Fwd ( a) ( b) {DeM B } (a b) DeMorgan Or Bkw ( a) ( b) {DeM B } (a b) DeMorgan And Bkw a b a {disjsyll} b Disjunctive Syllogism ( a) { F } a Double Negation Fwd a { B } ( a) Double Negation Bkw 8

9 From Fig 2.1, Hall & O Donnell, Discrete Math with a Computer, Springer, 2000 Some Laws of Boolean Algebra 9

10 More Laws of Boolean Algebra From Fig 2.1, Hall & O Donnell, Discrete Math with a Computer, Springer, 2000 (a b) b = b { absorption} (a b) b = b { absorption} (a b) c = (a c) (b c) { imp} ((a b) (a c) (b c)) c { Elim} 10

11 Algebraic Laws of Predicate Calculus x not free in q ( x. P(x)) ( y. Q(y)) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( x. f(x)) = ( y. f(y)) ( x. f(x)) = ( y. f(y)) ( ) ( ) y not in f(x) { R} { R} 11

12 x, y, z :: Integer xs, ys :: [Integer] or :: [Bool] -> Bool Haskell Type Specifications -- x, y, and z have type Integer -- sequences with Integer elements -- function with one argument argument is sequence with Bool elems delivers value of type Bool (++) :: [e] -> [e] -> [e] -- generic function with two arguments args are sequences with elems of same type type is not constrained (can be any type) delivers sequence with elements of same type as those in arguments sum :: Num n => [n] -> n -- generic function with one argument argument is a sequence with elems of type n n must a type of class Num Num is a set of types with +,, operations powerset :: (Eq e, Show e) => Set e -> Set(Set e) -- generic function with one argument argument is a set with elements of type e delivers set with elements of type (Set e) type e must be both class Eq and class Show Class Eq has == operator, Show displayable 12

13 Some Algebraic Laws of Software Algebraic law of sequence construction x : [x 1, x 2,, x n ] = [x, x 1, x 2,, x n ] -- (:) Algebraic laws of concatenation [ ] ++ ys = ys -- (++).[] (x : xs) ++ ys = x : (xs ++ ys) -- (++).: What is the type of (++)? (++) :: [a] -> [a] -> [a] Algebraic laws of foldr foldr ( ) z [ ] = z foldr ( ) z (x : xs) = x (foldr ( ) z xs) What is the type of foldr? foldr :: (a -> b -> b) -> b -> [a] -> b The big or -- (foldr).[] -- (foldr).: (\/) :: Bool -> Bool -> Bool -- little or satisfies Boolean laws for or = foldr (\/) False -- big or What is the type of or? or :: [Bool] -> Bool 13

14 More Algebraic Laws of Software sum(x: xs) = x + sum xs sum[ ] = 0 Theorem: sum = foldr (+) 0 Type: sum :: Num n => [n] -> n length(x: xs) = 1 + length xs length[ ] = 0 Theorem: length = foldr onemore 0 where onemore x n = 1 + n Type: length :: [a] -> Int (sum).: (sum).[] (length).: (length).[] (x: xs) ++ ys = x: (xs ++ ys) (++).: [ ] ++ ys = ys (++).[] Theorem: xs ++ ys = foldr (:) ys xs Type: (++) :: [a] -> [a] -> [a] concat(xs: xss) = xs ++ concat xss concat[ ] = [ ] Theorem: concat = foldr (++) [ ] Type: concat :: [[a]] -> [a] (concat).: (concat).[] 14

15 Still More Algebraic Laws of Software Pattern: foldr ( ) z [x 1, x 2,, x n-1, x n ] = x 1 (x 2 (x n-1 (x n z)) ) foldr ( ) z (x: xs) = x foldr ( ) z xs (foldr).: foldr ( ) z [ ] = z (foldr).[] Type: foldr :: (a -> b -> b) -> b -> [a] -> b Pattern: map f [x 1, x 2, x n ] = [f x 1, f x 2, f x n ] map f (x : xs) = (f x) : map f xs map f [ ] = [ ] Type: map :: (a -> b) -> [a] -> [b] (map).: (map).[] Pattern: zipwith b [x 1, x 2, x n ] [y 1, y 2, y n ] = [b x 1 y 1, b x 2 y 2, b x n y n ] Note: extra elements in either sequence are dropped zipwith b (x:xs) (y:ys) = (b x y): (zipwith xs ys) (zipw).: zipwith b [ ] ys = [ ] (zipw).[]-1 zipwith b xs [ ] = [ ] (zipw).[]-2 Type: zipwith :: (a -> b -> c) -> [a] -> [b] -> [c] 15

16 {2, 3, 5, 7, 11} 2 {2, 3, 5, 7, 11} Sets explicit enumeration stylized epsilon means element of = { } stylized Greek letter phi denotes empty set {x p x} set comprehension Denotes set with elements x, where (p x) is True {f x p x} set comprehension Denotes set with elements of form (f x), where (p x) is True A B x. (x A x B) subset A = B (A B) (B A) set equality A B = {x x A x B} union S = {x A S. x A} big union A B = {x x A x B} intersection S = {x A S. x A} big intersection A B = {x x A x B} set difference A = U A complement (U = universe) P(A) = {S S A} power set A B = {(a, b) a A b B} Cartesian product 16

17 Loop Induction for verifying properties of loops Loop precondition: P(x 1, x 2, x ξ ) proved True while B(x 1, x 2, x ξ ) body of loop Loop invariant: P(x 1, x 2, x ξ ) proved True P(x 1, x 2, x ξ ) B(x 1, x 2, x ξ ) is True Loop Induction Proof by Loop Induction Prove: P(x 1, x 2, x ξ ) is true when a loop begins Prove: same P(x 1, x 2, x ξ ) is true at end of each iteration Proof may assume P(x 1, x 2, x ξ ) was true on previous iterations Conclude: P(x 1, x 2, x ξ ) is True and B(x 1, x 2, x ξ ) is False if and when the loop terminates Requirement Computing B(x 1, x 2, x ξ ) does not affect values of x 1, x 2, x ξ 17

18 sum = foldr (+) 0 as a loop Function precondition: a[1..n] defined integer sum(integer a[ ]) integer n = length(a[ ]) integer k, s s = 0 k = 0 k Loop precondition: s = a[i] i=1 while (k < n) k = k+1 s = s + a[k] Loop invariant: s = a[i] i=1 return s Loop precondition True Subscript set for is empty and empty sums are 0, by convention Loop invariant True at end of loop if True at beginning κ+1 κ a[i] = a[κ+1] + i=1 k a[i] where κ denotes top-of-loop value of k i=1 Conclude s = a[i] i=1 at return (by loop induction) But what is k at return? Loop terminates with k = n by counting-loop theorem (coming up) k 18

19 The Counting-Loop Theorem A type, c, is a counting type if c includes operations suc::c -> c and (<), (=)::c -> c -> bool (suc m) n whenever (m < n) {Note: x y means (x < y) (x = y)} (m < n) (n iterate suc m) iterate f x = x : (iterate f (f x)) Computation pattern: iterate f x = [x, f x, f(f x), f(f(f x), ] Theorem (counting loop) If k, m, n :: c, and m n, and If neither cmd1 nor cmd2 affects the values of k, m, or n Then the following loop terminates and when it does, k = n k = m while (k < n) cmd1 k = suc k cmd2 19

20 What Is a Tree? Tree a diagram or graph that branches usually from a simple stem without forming loops or polygons Merriam-Webster a type of data structure in which each element is attached to one or more elements directly beneath it Webopedia a node, together with a sequence of trees inductive definition Tree terminology subtree a node in a tree, together with its sequence of trees root the node that, with its subtrees, comprises the entire tree interior node a node with a nonempty sequence of subtrees leaf a tree with an empty sequence of subtrees branch a line connecting a node to its subtrees (in tree diagram) binary tree a tree with no nodes having more than 2 subtrees 20

21 Binary Search Tree a formal representation data SearchTree key dat = Nub Cel key dat (SearchTree key dat) (SearchTree key dat) Key goes here Node data Left subtree (smaller keys) Type parameters key, dat Example key might be Int, for example (datatype with an ordering) dat could be any type, typically a tuple s :: SearchTree Int (String, Float, [String] ) s is a SearchTree key type Int (maybe a catalog order number) dat type tuple storing a String (product description), a Float (price), and a sequence of strings (inventory records) Nub leaf constructor Cel constructor, non-empty trees Right subtree (larger keys) 21

22 Big O Notation and Computation Time Bounding the rate of growth Given: functions f and g f is big-o of g, written f = O(g), means c, s. x > s. f(x) c g(x) Computation time for deal deal (x1: (x2: xs)) = ( x1: ys, x2: zs ) where (ys, zs) = deal xs deal [x] = ( [x], [ ] ) deal [ ] = ( [ ], [ ] ) T n = time required for to compute deal[x 1, x 2, x n ] Recurrence equations T 0 = T 1 = 3 T n =T n T n 4n, n > 0 3 ops: matching, []-build, pair-build 4 ops: matching, 2 insertions, pair-build plus deal sequence that is shorter by 2 that is, T n = O(n) prove by induction 22

23 What a Relation Is as a mathematical object Relation a definition A binary relation ( ) :: A B is a subset of the Cartesian product of A (the domain) and B (the codomain) Reflexive A B = {(a, b) a A, b B} a b means (a, b) Irreflexive Symmetric ::A A, a A. a a ::A A, a A. (a, a) ::A A, a, b A. a b b a Antisymmetric Transitive ::A A, a, b A. a b b a a = b ::A A, a, b, c A. a b b c a c Closure wrt P ::A A, {S S S has property P} 23

24 Partial Order Classes of Relations :: A A, reflexive, antisymmetric, transitive Total Order :: A A, partial order a, b A. (a, b) (b, a) Well Order :: A A, total order B, B A, B. b B. a A. (b, a) Equivalence Relation :: A A reflexive, symmetric, and transitive 24

25 What It All Means Completeness in Formal Systems If a = b, then a b (a, b arbitrary WFFs) If b is true whenever a is, there is a proof of a b Notions of Consistency in Formal Systems If a b, then a = b (a, b arbitrary WFFs) No WFF a such that both a and a Predicate Logic Consistent Inference preserves tautologies Inconsistency would make all WFFs tautologies Some WFFs aren t tautologies QED (consistency) Complete There is a proof for every tautology in predicate calculus More powerful formal systems (such as arithmetic or Haskell) are not complete 25

26 100s of inputs input signals Why Bother with Proofs? software output signals > 2 100s of possibilities Key presses Mouse gestures Files Databases computation Images Sounds Files Databases Software translates input signals to output signals A program is a constructive proof of a translation But what translation? Proofs can confirm that software works correctly Testing cannot confirm software correctness Practice with proofs improves software thinking 26

27 CS 1813 Discrete Mathematics Learning Goals Apply mathematical logic to prove software properties Predicate calculus and natural deduction Boolean algebra and equational reasoning Mathematical induction Understand fundamental data structures Sets Trees Functions and relations Additional topics Graphs Counting Algorithm Complexity proofs galore! proofs galore! proofs galore! proofs galore! proofs galore! proofs galore! 27

28 End of Lecture 28