CS70 - Lecture 9 - Feb 7, 2011 - 10 Evans
Goal for Note 5:
Modular arithmetic
How computers do integer arithmetic
computing gcds
Theorem (division algorithm) given integers a, d>0 (divisor), there is a
unique q (quotient) and r (remainder) such that 0<=r<d, a=q*d+r
DEF if a and d>0 are integers as above, then a mod d = r,
remainder after dividing a by d
Application of Division Algorithm: Modular Arithmetic
DEF We say "a is congruent to b mod d" (or "a == b mod d") if d|(a-b)
Otherwise we say "a !== b mod d"
EX: 3 == 17 mod 7 because 7 | (17-3)
Thm 1: a == b mod d if and only if there is an integer k such that
a = b + k*d
proof (=>) a == b mod d -> d|(a-b) -> exists k: a-b=k*d -> a=b+k*d
proof (<=) a=b+k*d -> a-b = k*d -> d|(a-b) -> a == b mod d
EX: 3 == 17 mod 7 <=> 7 | (17-3) <=> 17=3+2*7
Thm 2: a == b mod d if and only if a mod d = b mod d:
proof (<=) a mod d = b mod d -> a=qa*d+r, b=qb*d+r, ->
(a-b)=(qa-qb)*d, -> d|(a-b) -> a == b mod d
proof (=>) a == b mod d -> a = b + k*d by Thm 1, so when dividing
a = qa*d+ra, b=qb*d+rb, with 0 <= ra,rb < d, we get
ra-rb = (a-qa*d)-(b-qb*d) = (a-b)+qb*d-qa*d = (k+qb-qa)*d
now -d < ra-rb < d and ra-rb is also a multiple of d,
so ra-rb=0
EX: 3 == 17 mod 7 <=> 3 mod 7 = 17 mod 7
ASK&WAIT: is 111 == 63 mod 3? is 123 == 6789 mod 2?
Thm 3: a==b mod d and c==e mod d => a+c == b+e mod d
proof: a = qa*d+r1 and b = qb*d+r1 and c = qc*d+r2 and e = qe*d+r2 ->
(a+c)=(qa+qc)*d+r1+r2 and b+e=(qb+qe)*d+r1+r2 ->
(a+c)-(b+e) = d*(qa+qc-qb-qe) -> d|(a+c-b-e) -> a+c == b+e mod d
EX: 3==17 mod 7 and 11==4 mod 7 => 3+11 == 17+4 mod 7 (7|(21-14), i.e. 7|7)
ASK&WAIT: Is 112+227 == 31+65 mod 3?
Thm 4: a==b mod d and c==e mod d => a*c == b*e mod d
(try to prove this yourself)
EX: 3==17 mod 7 and 11==4 mod 7 => 3*11 == 17*4 mod 7 (7|(68-33), i.e. 7|35)
ASK&WAIT: Is 112*227 == 31*65 mod 3?
DEF: "arithmetic modulo d" or "modular arithmetic with modulus d" means
doing integer arithmetic (+,-,*) where any two a,b satisfying
a == b mod d are considered the same, because we only care what
the answer equals mod d
Thm 3 means that if we want to add and subtract numbers mod d, we can
take any number or intermediate result and add a multiple of d to it
(replace it by its value mod d) without changing the final answer.
Thm 4 says the same thing about multiplication
Ex: (13+15)*(2+8) mod 8 can be computed the following equivalent ways:
(1) ((13+15)*(2+8)) mod 8 = 280 mod 8 = 0 mod 8
(2) 13+15==28 mod 8 == 4 mod 8 and 2+8==10 mod 8 ==2 mod 8 so
((13+15)*(2+8)) mod 8 == 4*2 mod 8 == 8 mod 8 == 0 mod 8
ASK&WAIT: Any other ways?
Here are several useful applications of modular arithmetic:
Thm: Let x = d(n-1)d(n-2)...d(0) be an n-digit decimal integer.
Then 3|x if and only if 3 | d(n-1)+d(n-2)+...+d(0), i.e. the
sum of x's decimal digits.
Proof. We want to show that x mod 3 = 0 if and only if
d(n-1)+...+d(0) mod 3 = 0.
We will show more, namely that x == d(n-1)+...+d(0) mod 3:
x == sum_{i=0 to n-1} d(i)*10^i mod 3 ... by def of decimal number
== sum_{i=0 to n-1} d(i)*(10^i mod 3) mod 3
== sum_{i=0 to n-1} d(i)*(10 mod 3)^i mod 3
== sum_{i=0 to n-1} d(i)*(1)^i mod 3
== sum_{i=0 to n-1} d(i) mod 3
as desired
Thm: Let x = d(n-1)d(n-2)...d(0) be an n-digit decimal integer.
Then 9|x if and only if 9| d(n-1)+d(n-2)+...+d(0), i.e. the
sum of x's decimal digits.
Proof: the same as above, substituting 9 for 3
ASK&WAIT: What about a rule for deciding if 11 | x?
ASK&WAIT: what about a rule for deciding if 7 | x?
EX: Simplest way to implement "arithmetic modulo 8" means
only use numbers in set S={0,1,2,3,4,5,6,7};
after every operation (like 3*4) take result modulo 8 to get
number (4) in S
EX: Take a disk with d=8 equispaced points on circumference, labelled
0 (at top), 1 (to right) and around to d-1 = 7. Take another similar
disk with same center. to add a+b, align 0 of second disk
with a of first disk, and see where b of second disk hits
first disk, namely at a=b mod d ("circular slide rule").
Multiplication can be thought of as repeated addition.
(picture on board)
EX: Computer Implementation of arithmetic mod 8:
"Unsigned Integers" in C, C++
represent numbers in base 2 (with 3 binary digits, or bits):
Addition is done as in elementary school: add bits from right
to left, where you get a "carry" from one column of bits to the
next if the sum in the column is at least 2 (10 in decimal), as
indicated below. If there is a carry out of the last column, we
ignore it, since there is no place to "carry it to".
This discarded carry represents an 8, so the final sum is 8 smaller
than the true value, eg 12-8=4 instead of 12, which is the
answer mod 8.
carries: 000 100 110 000
001_2 = 1 010_2 = 2 101_2 = 5 100_2 = 4
+ 010_2 = 2 + 011_2 = 3 + 111_2 = 7 + 101_2 = 5
----------- ----------- ----------- -----------
011_2 = 3 101_2 = 5 100_2 = 4 001_2 = 1
= 12 mod 8 = 9 mod 8
EX: 2's complement arithmetic: how computers do integer arithmetic
with positive and negative integers.
Suppose computer words had just 3 bits, representing 2^3=8 numbers.
(A real computer would use 32 bits, representing 2^32 numbers, but
it is the same idea.). Then instead of doing modular arithmetic on
the set S={0,1,2,3,4,5,6,7}, we use the set S={-4,-3,-2,-1,0,1,2,3}.
I.e. after each operation, we add a multiple of 8 (or 2^32) to the
result to get an answer in S.
The way you tell positive from negative numbers among the 8 bit
patterns on our 3-bit computer is to look at the leftmost bit,
the "sign bit": it is 0 for nonnegative numbers, and 1 for negative.
bit pattern unsigned integer 2's complement integer
----------- ---------------- ----------------------
000 0 0
001 1 1
010 2 2
011 3 3
100 4 -4 = 4-8
101 5 -3 = 5-8
110 6 -2 = 6-8
111 7 -1 = 7-8
Rule to interpret bit pattern as 2's complement number:
if leading bit ("sign bit") is 0
the number is positive, with the same value as the unsigned integer
else if the sign bit is 1
the number is negative, with the value of unsigned integer minus 8
There are "circular slide rules" for unsigned (draw on board) and
2s complement (draw on board) integer arithmetic:
With 3 bits, numbers range from -2^2 = 100_2 = -4
to 2^2-1 = 011_2 = 3
With 32 bits, numbers range from -2^31 = 10...0_2 = -2147483648
to 2^31 - 1 = 011..1_2 = 2147483647
Arithmetic is done the same way, whether unsigned or 2's complement:
carries: 000 100 110 000
001_2 = 1 010_2 = 2 101_2 = -3 100_2 = -4
+ 010_2 = 2 + 011_2 = 3 + 111_2 = -1 + 101_2 = -3
----------- ----------- ----------- -----------
011_2 = 3 101_2 = -3 100_2 = -4 001_2 = 1
ASK: int a,b,c,d,e,f on 3 bit machine
a = 3
b = a+1 ... what is b?
c = a+2 ... what is c?
d = 2
e = 2*d ... what is e?
f = 2*e ... what is f?
ASK: int a,b,c,d,e,f on 32 bit machine (like most)
a = (2^30-1) + 2^30 ... what is a?
b = a+1 ... what is b?
c = a+2 ... what is c?
d = 2^30 ... what is d?
e = 2*d ... what is e?
f = 2*e ... what is f?
Try running above program on your own machine