Section 2.0 2.0.

1
Chapter
ALGORITHMSand INTEGERS
2.1 Algorithms
2.2 Growth of Functions
2.3 Complexity of Algorithms
2.4 The Integers and Division
2.5 Integers and Algorithms
2.6 Applications of Number Theory
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.1 Algorithms 2.1.1
2.1 ALGORITHMS
def: An algorithm is a nite set of precise
instructions for performing a computation or for
solving a problem.
Example 2.1.1: A computer program is an
algorithm.
Remark: From a mathematical perspective, an
algorithm represents a function. The British
mathematician Alan Turing proved that some
functions cannot be represented by an algorithm.
CLASSROOM PERSPECTIVE
Every computable function can be repre-
sented by many dierent algorithms. Naive
algorithms are almost never optimal.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.1.2
terminology: A good pseudocoding of an
algorithm provides a clear prose representation of
the algorithm and also is transformable into one
or more target programming languages.
Algorithm 2.1.1: Find Maximum
Input: unsorted array of integers a , a , . . . , a
n
Output: largest integer in array
{Initialize} max := a
For i := 2 to n
If max < a
i
then max := a
i
Continue with next iteration of for-loop.
Return (max)
Remark: For a sorted array, there would be a
much faster algorithm to nd the maximum.
In general, the representation of the data pro-
foundly aects the choice of an algorithm and of
the execution time.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.1 Algorithms 2.1.3
Algorithm 2.1.2: Unsorted Sequential Search
Input: unsorted array of integers a , a , . . . , a
n
target value x
Output: subscript of entry equal to target value,
or 0 if not found
{Initialize} i := 1
While i n and x = a
i
i := i + 1
Continue with next iteration of while-loop.
If i n then loc := i else loc := 0
Return (loc)
Remark: If the array were presorted into
ascending (or descending) order, then faster
algorithms could be used.
(1) linear search could stop sooner
(2) 2-level search could avoid many comparisons
(3) binary search could divide-and-conquer
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.1.4
Algorithm 2.1.3: Sorted Sequential Search
Input: sorted array of integers a , a , . . . , a
n
target value x
Output: subscript of entry equal to target value,
or 0 if not found
{Initialize} i := 1
While i n and x < a
i
i := i + 1
Continue with next iteration of while-loop.
If (i n cand x = a
i
) then loc := i else loc := 0
Return (loc)
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.1 Algorithms 2.1.5
Algorithm 2.1.4: Two-level Search
Input: sorted array of integers a , a , . . . , a
n
target value x
Output: subscript of entry equal to target value,
or 0 if not found
{Initialize} i := 10
{Find target sublist of 10 entries}
While i n and x < a
i
i := i + 10
Continue with next iteration of while-loop.
{Linear search target sublist of 10 entries}
{Initialize} j := i 9
While j < i and x < a
j
j := j + 1
Continue with next iteration of while-loop.
If (j n cand x = a
j
) then loc := j else loc := 0
Return (loc)
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.1.6
Algorithm 2.1.5: Binary Search
Input: unsorted array of integers a , a , . . . , a
n
target value x
Output: subscript of entry equal to target value,
or 0 if not found
{Initialize} left := 1; right := n
While left < right
mid := (left + right)/2
If x > a
mid
then left := mid else right := mid
Continue with next iteration of while-loop.
If x = a
left
then loc := left else loc := 0
Return (loc)
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.2 Growth of Functions 2.2.1
2.2 GROWTH OF FUNCTIONS
def: Let f and g be functions R R. Then
f is asymptotically dominated by g if
(K R)(x > K)[f(x) g(x)]
notation: f g.
Remark: This means that eventually, there is
an location x = K, after which the graph of the
function g lies above the graph of the function f.
BIG OH CLASSES
def: Let f and g be functions R R. Then
f is in the class O(g) (big-oh of g) if
(C R)[f Cg]
notation: f O(g).
disambiguation: Properly understood, O(g) is
the class of all functions that are asymptotically
dominated by any multiple of g.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.2.2
terminology note: The phrase f is big-oh
of g makes sense if one imagines either that the
word in preceded the word big-oh, or that
big-oh of g is an adjective.
Example 2.2.1: 4n + 21n + 100 O(n )
Proof: First suppose that n 0. Then
4n + 21n + 100 4n + 24n + 100
4(n + 6n + 25)
8n which holds whenever
n 6n + 25, which holds whenever
n 6n + 9 34, which holds whenever
n 3

34, which holds whenever

n 9. Thus,
(n 9)[4n + 21n + 100 8n ].
Remark: We notice that n itself is asymptot-
ically dominated by 4n + 21n + 100. However,
we proved that 4n + 21n + 100 is asymptotically
dominated by 8n , a multiple of n .
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.2 Growth of Functions 2.2.3
WITNESSES
This operational denition of membership in a
big-oh class makes the denition of asymptotic
dominance explicit.
def: Let f and g be functions R R. Then
f is in the class O(g) (big-oh of g) if
(C R)(K R)(x > K)[Cg(x) f(x)]
def: In the denition above, a multiplier C and
a location K on the x-axis after which Cg(x)
dominates f(x) are called the witnesses to the
relationship f O(g).
Example 2.2.1, continued: The values C = 8
and M = 9 are witnesses to the relationship
4n + 21n + 100 O(n ).
Larger values of C and K could also serve as
witnesses. However, a value of C less than or
equal to 4 could not be a witness.
CLASSROOM EXERCISE
If one chooses the witness C = 5, then K = 30
could be a co-witness, but K = 9 could not.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.2.4
Lemma 2.2.1. (x + 1)
n
O(x
n
).
Proof: Let C be the largest coecient in the
(binomial) expansion of (x + 1)
n
, which has n + 1
terms. Then (x + 1)
n
C(n + 1)x
n
.
Example 2.2.2: The proof of Lemma 2.2.1
uses the witnesses
C =

and K = 0
Theorem 2.2.2. Let p(x) be a polynomial of
degree n. Then p(x) O(x
n
).
Proof: Informally, just generalize Example
2.2.1. Formally, just apply Lemma 2.2.1.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.2 Growth of Functions 2.2.5
Example 2.2.3: 100n O(e
n
). Observing
that n = e
n
inspires what follows.
Proof: Taking the upper Riemann sum with
unit-sized intervals for ln x =

n
dx
x
implies for
n > 1 that
ln(n) <
1
1
+
1
2
+ +
1
n

1
1
+ +
1
5

+
1
6
+ +
1
n

1
1
+ +
1
5

+
1
6
+ +
1
6
5 +
n 5
6
Therefore, 6 ln n n + 25, and accordingly,
100n = 100 e
n
< 100 e
n
< e e
n

We have used the witnesses C = e and K = 0.

Theorem 2.2.3. Powers dominate logs.
Proof: See Example 2.2.3.
Theorem 2.2.4. Exponentials dominate polyno-
mials.
Proof: See Example 2.2.3.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.2.6
Example 2.2.4: 2
n
O(n!).
Proof:
n

2 2 2 = 2 1
n

2 2 2
2 1 2 3 n = 2n!
We have used the witnesses C = 2 and K = 0.
BIG-THETA CLASSES
def: Let f and g be functions R R. Then
f is in the class (g) (big-theta of g)
if f O(g) and g O(f).
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.3 Complexity 2.3.1
2.3 COMPLEXITY
disambiguation: In the early 1960s, Chaitin
and Kolmogorov used complexity to mean
measures of complicatedness. However, most
theoretical computer scientists have used it in
a jargon sense that means measures of resource
consumption.
def: Algorithmic time-complexity measures
estimate the time or the number of computa-
tional steps required to execute an algorithm,
given as a function of the size of the input.
terminology: The resource for a complexity
measure is implicitly time, unless space or some-
thing else is specied.
def: A worst-case complexity measure
estimates the time required for the most time-
consuming input of each size.
def: An average-case complexity measure
estimates the average time required for input of
each size.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.3.2
Example 2.3.1: In searching and sorting,
complexity is commonly measures in terms of the
number of comparisons, since total computation
time is typically a multiple of that.
Algorithm 2.1.1: Find Maximum
Input: unsorted array of integers a , a , . . . , a
n
Output: largest integer in array
{Initialize} max := a
For i := 2 to n
If max < a
i
then max := a
i
Continue with next iteration of for-loop.
Return (max)
Big-Oh:
Always takes n 1 comparisons.
Time complexity is in O(n).
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.3 Complexity 2.3.3
Example 2.3.2:
Algorithm 2.1.2: Unsorted Sequential Search
Input: unsorted array of integers a , a , . . . , a
n
target value x
Output: subscript of entry equal to target value,
or 0 if not found
{Initialize} i := 1
While i 2 and x = a
i
i := i + 1
Continue with next iteration of while-loop.
If i n then loc := i else loc := 0
Return (loc)
Target in or not in Array:
Worst case takes n comparisons.
Average case takes n/2 comparisons.
Target not in Array:
Every case takes n comparisons.
Big-Oh:
Time complexity is in O(n).
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.3.4
Example 2.3.3:
Algorithm 2.1.3: Sorted Sequential Search
Input: sorted array of integers a , a , . . . , a
n
target value x
Output: subscript of entry equal to target value,
or 0 if not found
{Initialize} i := 1
While i n and x < a
i
i := i + 1
Continue with next iteration of while-loop.
If (i n cand x = a
i
) then loc := i else loc := 0
Return (loc)
Target in or not in Array:
Worst case takes n comparisons.
Average case takes n/2 comparisons.
Big-Oh:
Time complexity is in O(n).
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.3 Complexity 2.3.5
Example 2.3.4:
Algorithm 2.1.4: Two-level Search
Input: sorted array of integers a , a , . . . , a
n
target value x
Output: subscript of entry equal to target value,
or 0 if not found
{Initialize} i := 10
{Find target sublist of 10 entries}
While i 2 and x a
i
i := i + 10
Continue with next iteration of while-loop.
{Linear search target sublist of 10 entries}
{Initialize} j := i 9
While j i and x < a
j
j := j + 1
Continue with next iteration of while-loop.
If (j n cand x + a
j
) then loc := j else loc := 0
Return (loc)
Target in or not in Array:
Worst case takes (n/10) + 10 comparisons.
Big-Oh: Time complexity is in O(n).
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.3.6
To optimize the two-level search, minimize
n/x + x
as in dierential calculus.
n
x
+ 1 = 0 x =

n
Target in or not in Array:
Worst case takes 2

n comparisons.
Big-Oh: Time complexity is in O(

n).
Increasing to k levels further decreases the
execution time to O(
k

n),
provided that k is not too large.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.3 Complexity 2.3.7
Example 2.3.5:
Algorithm 2.1.5: Binary Search
Input: unsorted array of integers a , a , . . . , a
n
target value x
Output: subscript of entry equal to target value,
or 0 if not found
{Initialize} left := 1; right := n
While left < right
mid := (left + right)/2
If x > a
mid
then left := mid else right := mid
Continue with next iteration of while-loop.
If x = a
left
then loc := left else loc := 0
Return (loc)
Target in or not in Array:
Every case takes lg n comparisons.
Big-Oh: Time complexity is in O(lg n).
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.3.8
COMPLEXITY JARGON
def: A problem is solvable if it can be solved
by an algorithm.
Example 2.3.6: Alan Turing dened the
halting problem to be that of deciding whether
a computational procedure (e.g., a program)
halts for all possible input. He proved that the
halting problem is unsolvable.
def: A problem is in class P if it is solvable by
an algorithm that runs in polynomial time.
def: A problem is tractable if it is in class P.
def: A problem is in class NP if an algorithm
can decide in polynomial time whether a puta-
tive solution is really a solution.
Example 2.3.7: The problem of deciding
whether a graph is 3-colorable is in class NP.
It is believed not to be in class P.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.4 The Integers and Division 2.4.1
2.4 THE INTEGERS AND DIVISION
In mathematics, specifying an axiomatic model
for a system precedes all discussion of its proper-
ties. The number system serves as a foundation
for many other mathematical systems.
Elementary school students learn algorithms for
the arithmetic operations without ever seeing
a denition of a number or of the operations
that these algorithms are modeling.
These coursenotes precede discussion of division
by the construction of the number system and of
the usual arithmetic operations.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.4.2
AXIOMS for the NATURAL NUMBERS
def: The natural numbers are a mathematical
system
^ = N, 0 N, s : N N
in which the number 0 is called zero, and the
operation s : N N is called successor, such
that
(1) (,n)[0 = s(n)]. Zero is not the successor of
any number.
(2) (m, n N)[m ,= n s(m) ,= s(n)]. Two dif-
ferent numbers cannot have the same successor.
(3) (S N)

(0 S) (n S)[s(n) S] S = N

.
Given a subset S of the natural numbers, sup-
pose that it contains the number 0, and suppose
that whenever it contains a number, it also con-
tains the successor of that number. Then S = N.
Remark: Axiom (1) N has at least one other
number, namely, the successor of zero. Lets call
it one. Using Axioms (1) and (2) together, we
conclude that s(1) , 0, 1. Etc.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.4 The Integers and Division 2.4.3
ARITHMETIC OPERATIONS
def: The predecessor of a natural number n is
a number m such that s(m) = n.
notation: p(n).
def: Addition of natural numbers.
n + m =

n if m = 0
s(n) + p(m) otherwise
def: Ordering of natural numbers.
n m means

m = 0 or
p(n) p(m)
def: Multiplication of natural numbers.
n m =

0 if m = 0
n + n p(m) otherwise
OPTIONAL: (1) Dene exponentiation. (2)
Dene positional representation of numbers.
(3) Verify that the usual base-ten methods for
addition, subtraction, etc. produce correct an-
swers.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.4.4
DIVISION
def: Let n and d be integers with d ,= 0. Then
d divides n if there exists a number q such that
n = dq. notation: dn.
def: The integer d is a factor of n or a divisor
of n if dn.
def: A divisor d of n is proper if d ,= n.
def: The number one is called a trivial divisor.
def: An integer p 2 is prime if p has no non-
trivial proper divisors, and composite other-
wise.
Algorithm 2.4.1: Naive Primality Algorithm
Input: positive integer n
Output: smallest nontrivial divisor of n
For d := 2 to n
If dn then exit
Continue with next iteration of for-loop.
Return (d)
Time-Complexity: O(n).
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.4 The Integers and Division 2.4.5
Theorem 2.4.1. Let n be a composite number.
Then n has a divisor d such that 1 < d

n.
Proof: Straightforward.
Algorithm 2.4.2: Less Naive Primality Algorithm
Input: positive integer n
Output: smallest nontrivial divisor of n
For d := 2 to

n
If dn then exit
Continue with next iteration of for-loop.
Return (d)
Time-Complexity: O(

n).
Example 2.4.1: Primality Test 731.
Upper Limit:

731| = 27, since 729 = 27 .

(2731): leaves 3, 5, 7, 9, 11, . . . , 25, 27 13 cases
(3, 5, 7, 9, 11, 13, 15731): however, 17731
AHA: 731 = 17 43.
N.B. To accelerate testing, divide only by primes
2, 3, 5, 7 ,11, 13, 17.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.4.6
MERSENNE PRIMES
Prop 2.4.2. If m, n > 1 then 2
mn
1 is not
prime.
Proof:
2
m n
+ +2
m
+1
(times) 2
m
1
2
mn
+2
m n
+ +2
m
2
m n
2
m
1
2
mn
1
Example 2.4.2:
2 1 = 2

1
= (2

+ 1)(2 1) = 9 7 = 63
= 2

1
= (2

+ 2

+ 1)(2 1) = 21 3 = 63
Mersenne studied the CONVERSE of Prop 2.4.2:
Is 2
p
1 prime when p is prime?
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.4 The Integers and Division 2.4.7
def: A Mersenne prime is a prime number of
the form 2
p
1, where p is prime.
Example 2.4.3: primality of 2
p
1
prime p 2
p
1 Mersenne?
2 2 1 = 3 yes (1)
3 2 1 = 7 yes (2)
5 2 1 = 31 yes (3)
7 2 1 = 127 yes (4)
11 2 1 = 2047 = 23 89 no
11213 2 1 yes (23)
19937 2 1 yes (24)
3021377 2 1 yes (37) [late 1998]
Fundamental Theorem of Arithmetic
Theorem 2.4.3. Every positive integer can be
written uniquely as the product of nondecreasing
primes.
Proof: 2.5 proves this dicult lemma:
if a prime number p divides a product mn of
integers, then it must divide either m or n.
Example 2.4.4: 720 = 2 3 5 is written as a
prime power factorization.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.4.8
DIVISION THEOREM
Theorem 2.4.4. Let n and d be positive inte-
gers. Then there are unique nonnegative integers
q and r < d such that n = qd + r.
terminology: n = dividend, d =divisor,
q = quotient, and r = remainder.
Algorithm 2.4.3: Division Algorithm
Input: dividend n > 0 and divisor d > 0
Output: quotient q and remainder 0 r < d
q := 0
While n d
q := q + 1
n := n d
Continue with next iteration of while-loop.
Return (quotient: d; remainder: n)
Time-Complexity: O(n/d).
Remark: Positional representation uses only
(log n) digits to represent a number. This facil-
itates a faster algorithm to calculate division.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.4 The Integers and Division 2.4.9
Example 2.4.5: divide 7 into 19
n d q
19 7 0
12 7 1
5 7 2
GREATEST COMMON DIVISORS
def: The greatest common divisor of two in-
tegers m, n, not both zero, is the largest positive
integer d that divides both of them.
notation: gcd(m, n).
Algorithm 2.4.4: Naive GCD Algorithm
Input: integers m n not both zero
Output: gcd(m, n)
g := 1
For d := 1 to m
If dm and dn then g:=d
Continue with next iteration of for-loop.
Return (g)
Time-Complexity: (m).
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.4.10
Algorithm 2.4.5: Primepower GCD Algorithm
Input: integers m n not both zero
Output: gcd(m, n)
(1) Factor m = p
a
1
p
a
2
p
a
r
r
into prime powers.
(2) Factor n = p
b
1
p
b
2
p
b
r
r
into prime powers.
(3) g := p
a
1
,b
1
p
a
2
,b
2
p
a
r
,b
r
r
Return (g)
Time-Complexity:
depends on time needed for factoring
def: The least common multiple of two posi-
tive integers m, n is the smallest positive integer
d divisible by both m and n.
notation: lcm(m, n).
Theorem 2.4.5. Let m and n be positive inte-
gers. Then mn = gcd(m, n)lcm(m, n).
Proof: The Primepower LCM Algorithm uses
max instead of min.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.4 The Integers and Division 2.4.11
RELATIVE PRIMALITY
def: Two integers m and n, not both zero, are
relatively prime if gcd(m, n) = 1.
notation: m n.
Proposition 2.4.6. Two numbers are relatively
prime if no prime have positive exponent in both
their prime power factorizations.
Proof: Immediate from the denition above.
Remark: Proposition 2.4.6 is what motivates
the notation m n. Envision the integer n ex-
pressed as a tuple in which the kth entry is the
exponent (possibly zero) of the kth prime in the
prime power factorization of n. The dot prod-
uct of two such representations is zero i the
numbers represented are relatively prime. This
is analogous to orthogonality of vectors.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.4.12
MODULAR ARITHMETIC
def: Let n and m > 0 be integers. The residue
of dividing n by m is, if n 0, the remainder,
or otherwise, the smallest nonnegative number
obtainable by adding an integral multiple of m.
def: Let n and m > 0 be integers. Then
n mod m is the residue of dividing n by m.
Prop 2.4.7. Let n and m > 0 be integers. Then
n (n mod m) is a multiple of m.
Example 2.4.6: 19 mod 7 = 5; 17 mod 5 = 2;
17 mod 5 = 3.
def: Let b, c, and m > 0 be integers. Then b is
congruent to c modulo m if m divides b c.
notation: b c mod m.
Theorem 2.4.8. Let a, b, c, d, m > 0 be inte-
gers such that a b mod m and c d mod m.
Then
a + c b + d mod m and ac bd mod m.
Proof: Straightforward.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.4 The Integers and Division 2.4.13
CAESAR ENCRYPTION
def: Monographic substitution is enciphering
based on a permutation of an alphabet : A
A. Then ciphertest is obtained from plaintext
by replacing each occurrence of each letter by its
substitute.
letter A B C D E F X Y Z
subst Q W E R T Y B N M
def: A monographic substitution cipher is called
cyclic if the letters of the alphabet are repre-
sented by numbers 0, 1, ..., 25 and there is a
number m such that (n) = m + n mod 26.
An ancient Roman parchment is discovered with
the following words:
HW WX EUXWH
What can it possibly mean?
Hint: Julius Caesar encrypted military messages
by cyclic monographic substitution.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.5 Integers and Algorithms 2.5.1
2.5 INTEGERS AND ALGORITHMS
We accelerate evaluation of gcds, of arithmetic
operations, and of monomials and polynomials.
POSITIONAL REPRESENTATION of INTEGERS
Although arithmetic algorithms are much more
complicated for numbers in positional notation
than for numbers in monadic notation, they pay
benets in execution time.
(1) Addition algorithm execution time decreases
from O(n) to O(log n).
(2) Multiplication algorithm execution time de-
creases from O(nm) to O(log nlog m).
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.5.2
Theorem 2.5.1. Let b > 1 and n 0 be in-
tegers. Let k be the maximum integer such that
b
k
n. Then there is a unique set of nonnega-
tive integers a
k
, a
k1
, . . . , a
0
< b such that
n = a
k
b
k
+ a
k1
b
k1
+ + a
1
b
1
+ a
0
Proof: Apply the division algorithm to n and
b to obtain a quotient and remainder a
0
. Then
apply the division algorithm to that quotient and
b to obtain a new quotient and remainder a
1
.
Etc.
NUMBER BASE CONVERSION
The algorithm in the proof of Theorem 2.5.1
provides a method to convert any positive integer
from one base to another.
Example 2.5.1: Convert 1215
10
to base-7.
n d q r
1215 7 173 4
173 7 24 5
24 7 3 3
3 7 0 3
Solution: 3354
7
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.5 Integers and Algorithms 2.5.3
EVALUATION OF MONOMIALS
Example 2.5.2: Calculate 13
n
, e.g. 13
19
.
Usual method: 13 13 13 13
time = (n).
Better method:
13, 13
2
, 13
4
, 13
8
, 13
16
takes (log n) steps
13 13
2
13
16
takes (log n) steps
EVALUATION OF POLYNOMIALS
Evaluate f(x) = a
n
x
n
+a
n1
x
n1
+... +a
1
x +a
0
Usual method of evaluation takes (n):
n multiplications to calculate n powers of x
n multplications by coecients
n additions
Horners method (due to ):
a
n
x + a
n1
(a
n
x + a
n1
)x + a
n2
etc.
requires only n multiplications and n additions.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.5.4
EUCLIDEAN ALGORITHM
Lemma 2.5.2. Let d\m and d\n. Then d\mn
and d\m + n.
Proof: Suppose m = dp and n = dq. Then
mn = d(p q) and m + n = d(p + q).
Corollary 2.5.3. gcd(m, n) = gcd(mn, n).
Proof: In three steps.
A1. gcd(m, n) is a common div of m n and n,
and gcd(mn, n) is a common div of m and n.
Pf. Both parts by Lemma 1.
A2. gcd(m, n) gcd(mn, n)
and gcd(mn, n) gcd(m, n).
Pf. Both parts by A1 and def of gcd (great-
est).
A3. gcd(m, n) = gcd(mn, n).
Pf. Immediate from A2. Cor 2.5.3
Cor 2.5.4. gcd(m, n) = gcd(n, m mod n).
Proof: The number m mod n is obtained from
m by subtracting a multiple of n. Iteratively
apply Cor 2.5.3.
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.5 Integers and Algorithms 2.5.5
Algorithm 2.5.1: Euclidean Algorithm
Input: positive integers m 0, n > 0
Output: gcd(n, m)
If m = 0 then return(n)
else return gcd(m, n mod m)
Time-Complexity: O(log(min(n, m))).
Much better than Naive GCD algorithm.
Example 2.5.3: Euclidean Algorithm
gcd(210, 111) = gcd(111, 210 mod 111) =
gcd(111, 99) = gcd(99, 111 mod 99) =
gcd(99, 12) = gcd(12, 99 mod 12) =
gcd(12, 3) = gcd(3, 12 mod 3) =
gcd(3, 0) = 3
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.5.6
Example 2.5.4: Euclidean Algorithm
gcd(42, 26) = gcd(26, 42 mod 26) =
gcd(26, 16) = gcd(16, 26 mod 16) =
gcd(16, 10) = gcd(10, 16 mod 10) =
gcd(10, 6) = gcd(6, 10 mod 6) =
gcd(6, 4) = gcd(4, 6 mod 4) =
gcd(4, 2) = gcd(2, 4 mod 2) =
gcd(2, 0) = 2
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.6 Applications of Number Theory 2.6.1
2.6 APPLICATIONS OF NUMBER THE-
ORY
EXTENDED EUCLIDEAN ALGORITHM
Given two integers a and b, the extended
Euclidean algorithm produces numbers s and
t such that sa + tb = gcd(a, b). We describe it by
example.
Example 2.6.1: Euclidean Algorithm
312 = 2 111 + 90
111 = 1 90 + 21
90 = 4 21 + 6
21 = 3 6 + 3
6 = 2 3 + 0 now start back-substitution
3 = 21 3 6
= 21 3 [90 4 21] = 13 21 3 90
= 13 [111 90] 3 90 = 13 111 16 90
= 13 111 16 [312 2 111]
= 45 111 16 312 = 4995 4992 = 3
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Chapter 2 ALGORITHMS and INTEGERS 2.6.2
EXPONENTIATION MOD a PRIME
Problem: Evaluate x
k
mod p, with p prime.
FACT 1: x
k
mod n = (x mod n)
k
mod n.
Proof: If x = qn + (x mod n), then
x
k
mod n = (qn + (x mod n))
k
mod n
do a binomial expansion
= Bn + (x mod n)
k
mod n
= (x mod n)
k
mod n
Example 2.6.2: 12
3
mod 5 = 1728 mod 5 = 3
12
3
mod 5 = 2
3
mod 5 = 3
FACT 2. Fermats Little Theorem
Let p be prime. Then x
p1
= 1 mod p.
Proof: See Exercise 17 of 2.6.
Example 2.6.3: 2
6
mod 7 = 64 mod 7 = 1
7
4
mod 5 = 2401 mod 5 = 1
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.
Section 2.6 Applications of Number Theory 2.6.3
Example 2.6.4: Calculate 16
20
mod 7.
Using fast monomial evaluation, this looks like
lg n mults and 1 division. Not bad, unless you
want the answer by hand computation.
Pure Algebra to the Rescue
16
20
mod 7 = 2
20
mod 7 by FACT 1
= 2
2
mod 7 by FACT 2
= 4
Coursenotes by Prof. Jonathan L. Gross for use with Rosen: Discrete Math and Its Applic., 5th Ed.