1. CS 1813 – Discrete Mathematics
Lecture 27 - CS 1813 Discrete Math, University of Oklahoma
9/21/2018
CS 1813 – Discrete Mathematics
Discrete Mathematics Review or
Yes, the Final Will Be Comprehensive
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

2. Truth Tables for Logical Operators
P Q P  Q
False False False
False True False
True False False
True True True
P  Q
False
True
P  Q
PQ
PQ
 P
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

3. Predicates and Quantifiers
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
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

4. Rules of Inference Propositional Calculus
Lecture 27 - CS 1813 Discrete Math, University of Oklahoma
9/21/2018
Rules of Inference Propositional Calculus
Discrete Mathematics with a Computer Springer, 2000
Fig 2.1, Hall/O’Donnell
After presenting this slide, put up a copy on the overhead projector to refer to in upcoming proofs.
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

5. Inference Rules of Predicate Calculus
Lecture 27 - CS 1813 Discrete Math, University of Oklahoma
9/21/2018
Inference Rules of Predicate Calculus
x. F(x) {y not in F(x)}
{R}
y. F(y)
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)
Introducing/Eliminating Quantifiers
F(x) {x arbitrary}
{I}
x. F(x)
x. F(x) {universe is not empty}
{E}
F(x)
{E} rule triggers discharge
F(x)
{I}
x. F(x)
x. F(x) F(x) |– A {x not free in A}
{E} A
...plus the inference rules
of propositional calculus
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

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
s  t means
s is a proper subtree of t
{P(v)  B(v)} s {P(v)}
{LInd}
{P(v)} (while B(v) do s) {P(v)B(v)}
Loop Induction
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
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

7. Some Theorems in Rule Form
a  b
{Comm}
b  a
Or Commutes
a  b
{Comm}
b  a
And Commutes
ab bc
{Chain}
ac
Implication Chain Rule
(a  b)
{()Comm}
(b  a)
Not Or Commutes
a  b b
{modTol} a
Modus Tollens
a  b
{conPosF}
(b)(a)
Contrapositive Fwd
{noMiddle}
a  (a)
Law of Excluded Middle
a a
{ +&- }
False
NeverBoth
a  b
{F}
(a)  b
Implication Fwd
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

8. More Theorems in Rule Form
(a  b)
{DeMF}
(a)(b)
DeMorgan Or Fwd
(a)(b)
{DeMB}
(a  b)
DeMorgan Or Bkw
(a  b)
{DeMF}
(a)(b)
DeMorgan And Fwd
(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
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

9. Some Laws of Boolean Algebra
From Fig 2.1, Hall & O’Donnell, Discrete Math with a Computer, Springer, 2000
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

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}
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

11. Algebraic Laws of Predicate Calculus
Lecture 27 - CS 1813 Discrete Math, University of Oklahoma
9/21/2018
Algebraic Laws of Predicate Calculus
x not free in q
(x. P(x))  (y. Q(y))
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
y not in f(x)
(x. f(x)) = (y. f(y)) {R}
(x. f(x)) = (y. f(y)) {R}
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

12. Haskell Type Specifications
x, y, z :: Integer -- x, y, and z have type Integer
xs, ys :: [Integer] -- sequences with Integer elements
or :: [Bool] -> Bool -- 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
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

13. Some Algebraic Laws of Software
Algebraic law of sequence construction
x : [x1, x2, …, xn] = [x, x1, x2, …, xn] -- (:)
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).[]
foldr () z (x : xs) = x  (foldr () z xs) (foldr).:
What is the type of foldr ?
foldr :: (a -> b -> b) -> b -> [a] -> b
The big or
(\/) :: Bool -> Bool -> Bool -- “little or” – satisfies Boolean laws for 
or = foldr (\/) False “big or”
What is the type of or ?
or :: [Bool] -> Bool
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

14. More Algebraic Laws of Software
sum(x: xs) = x + sum xs (sum).:
sum[ ] = (sum).[]
Theorem: sum = foldr (+) 0
Type: sum :: Num n => [n] -> n
length(x: xs) = 1 + length xs (length).:
length[ ] = (length).[]
Theorem: length = foldr oneMore where oneMore x n = 1 + n
Type: length :: [a] -> Int
(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).:
concat[ ] = [ ] (concat).[]
Theorem: concat = foldr (++) [ ]
Type: concat :: [[a]] -> [a]
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

15. Still More Algebraic Laws of Software
Pattern: foldr () z [x1, x2, …, xn-1, xn ] = x1  ( x2  … (xn-1  ( xn  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 [x1, x2, … xn] = [f x1, f x2, … f xn]
map f (x : xs) = (f x) : map f xs (map).:
map f [ ] = [ ] (map).[]
Type: map :: (a -> b) -> [a] -> [b]
Pattern: zipWith b [x1, x2, … xn] [y1, y2, … yn] = [b x1 y1, b x2 y2, … b xn yn]
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]
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

16. CS 1813 Discrete Mathematics, Univ Oklahoma
Sets
{2, 3, 5, 7, 11} — explicit enumeration
2  {2, 3, 5, 7, 11} — 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
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

17. Loop Induction for verifying properties of loops
Loop precondition: P(x1, x2, … xx) proved True
while B(x1, x2, … xx)
… body of loop …
Loop invariant: P(x1, x2, … xx) proved True
P(x1, x2, … xx)  B(x1, x2, … xx) is True
Loop Induction
Proof by Loop Induction
Prove: P(x1, x2, … xx) is true when a loop begins
Prove: same P(x1, x2, … xx) is true at end of each iteration
Proof may assume P(x1, x2, … xx) was true on previous iterations
Conclude: P(x1, x2, … xx) is True and B(x1, x2, … xx) is False
if and when the loop terminates
Requirement
Computing B(x1, x2, … xx) does not affect values of x1, x2, … xx
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

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
while (k < n)
k = k+1
s = s + a[k]
return s
Conclude
at return
(by loop induction)
s = a[i]
i=1 k
Loop precondition: s = a[i]
i=1 k
But what is k at return?
Loop invariant: s = a[i]
i=1 k
Loop terminates with k = n
by counting-loop theorem
(coming up)
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
a[i] =
i=1
k+1
a[i] where k denotes top-of-loop value of k k
a[k+1] +
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

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
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

20. CS 1813 Discrete Mathematics, Univ Oklahoma
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
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

21. Binary Search Tree a formal representation
Nub – leaf constructor
data SearchTree key dat =
Nub |
Cel key dat (SearchTree key dat) (SearchTree key dat)
Cel – constructor, non-empty trees
Key goes here
Node data
Left subtree (smaller keys)
Right subtree (larger keys)
Type parameters — key, dat
key — might be Int, for example (datatype with an ordering)
dat — could be any type, typically a tuple
Example
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)
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

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)|
deal (x1: (x2: xs)) = ( x1: ys, x2: zs )
where (ys, zs) = deal xs
deal [x] = ( [x], [ ] )
deal [ ] = ( [ ], [ ] )
Computation time for deal
Tn = time required for to compute deal[x1, x2, … xn]
Recurrence equations
T0 = T1 = 3 3 ops: matching, []-build, pair-build
Tn = Tn ops: matching, 2 insertions, pair-build plus deal sequence that is shorter by 2
Tn  4n, n  0 that is, Tn = O(n) — prove by induction
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

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)
  A  B = {(a, b) | aA, bB}
a  b means (a, b)
Reflexive ::AA, aA. a  a
Irreflexive ::AA, aA. (a, a)
Symmetric ::AA, a, bA. ab  ba
Antisymmetric ::AA, a, bA. ab  ba  a = b
Transitive ::AA, a, b, c A. ab  bc  ac
Closure wrt P ::AA, {S | S  S has property P}
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

24. CS 1813 Discrete Mathematics, Univ Oklahoma
Classes of Relations
Partial Order
 :: 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
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

25. CS 1813 Discrete Mathematics, Univ Oklahoma
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
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

26. Lecture 27 - CS 1813 Discrete Math, University of Oklahoma
9/21/2018
Why Bother with Proofs?
100s of inputs
> 2100s of
possibilities
input signals
software
output signals
Key presses
Mouse gestures
Files
Databases …
computation
Images
Sounds
Software translates input signals to output signals
A program is a constructive proof of a translation
Responsible software developers are obligated specify what properties their software is guaranteed to have.
Proofs play a big role in this. Other methods of confirming software properties, especially testing, leave software riddled with errors.
Most systems have hundreds of input signals. Since each input signal must have at least two possible values, the number of different input states that must be checked to verify the operation of the software through testing is at least 2 to the power 100.
If you can generate, run, and examine one test case every minute, round the clock, you will not finish testing before you die.
Not even before the sun runs out of fuel. Not even if you do one test case every nanosecond.
Forget it. Testing can work only on very small pieces of software.
But what translation?
Proofs can confirm that software works correctly
Testing cannot confirm software correctness
Practice with proofs improves software thinking
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

27. CS 1813 Discrete Mathematics Learning Goals
Lecture 27 - CS 1813 Discrete Math, University of Oklahoma
9/21/2018
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!
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page

28. Lecture 27 - CS 1813 Discrete Math, University of Oklahoma
9/21/2018
End of Lecture
CS Discrete Mathematics, Univ Oklahoma
Copyright © 2000 by Rex Page