Download Sample Writing

SAMPLES OF HIGHER RATED WRITING: LAB 3
1. Introduction
Example 1
Euclid’s Algorithm, discovered by the ancient Greek mathematician, Euclid, provides a method for finding
the greatest common divisor for a pair of integers. An algorithm is a step-by-step procedure for performing
a calculation, so Euclid’s algorithm is a series of steps based on the idea of divisibility that tells us how to
calculate the greatest common divisor of two integers.
There are many reasons, both within pure mathematics, and with practical applications which will be
discussed after the theoretical results, that make this algorithm incredibly useful. A select few of these
applications will be discussed after the theory behind the algorithm is defined.
1.1. Theory. First, it is important to define division, that is, we say that, given two integers a 6= 0 and b,
a divides b iff ("if and only if") there is an integer k which satisfies b = ka. (Note that we denote a divides
b symbolically with a|b.)
Now, we can define the division algorithm as follows:
Theorem (Division Algorithm). Given a > b ∈ Z, there exist unique q, r ∈ Z such that:
a = qb + r and 0 ≤ r < b.
Euclid’s algorithm combines this theorem with another result, which we will now observe:
Theorem. Let a, b, q, r ∈ Z and a = qb + r. Then, gcd(a, b) = gcd(b, r).
Proof. Let d divide a and b. Then, we have that a = dn and b = dm for some n, m ∈ Z.
It then follows that a − b = dn − dm = d(n − m) = d(t) where t = (n − m) ∈ Z. This means that d also
divides a − b.
Additionally, if d divides a and a − b, then similarly we have that a = dn and a − b = dt, so:
b = a − (a − b) = dn − dt = d(n − t) = d(g) where g ∈ Z. This means that d must divide b.
Lastly, since a = qb + r, if d divides a then d divides qb + r. So, if d also divides b, then it is necessarily the
case that d divides r.
Combining these results establishes that the set of integers which divide a and b is the same as the set of
integers which divide b and r.
From here, we can give a general outline of Euclid’s Algorithm. For simplicity, let’s assume that a > b. The
algorithm proceeds by subtracting b from the a repeatedly until the difference is less than b. In symbols, the
steps look like this:
(1) a − b = r1 . If r1 < b, stop. Else,
(2) r1 − b = r2 . If r2 < b, stop. Else,
...
(n) rn−1 − b = rn , where rn < b.
Notice that the stopping condition is specified on every step of the algorithm, and met on step (n), making
step (n) the final step. So, n represents the number of steps the algorithm takes, and will not always take
the same value for different pairs of integers.
Now, we can begin to think about what values n might have for a given pair of integers. Here are some
results that give us a few ideas about the number of steps that this algorithm takes in order to find gcd(a, b).
Theorem. If a, b ∈ Z+ and determining gcd(a, b) takes exactly n long divisions, then max{a, b} ≥ Fn+2
and min{a, b} ≥ Fn+1 where Fn denotes the nth Fibonacci number.
Proof. Assume that a > b.
Then, we know the Division Algorithm will execute:
(1)a = q1 b + r1 , 0 ≤ r1 < b.
(2)b = q2 r1 + r2 , 0 ≤ r2 < r1
(3)r1 = q3 r2 + r3 , 0 ≤ r3 < r2 .
(4)r2 = q4 r3 + r4 , 0 ≤ r4 < r3 .
...
(n-1)rn−3 = qn−1 rn−2 + rn−1 , 0 < rn−1 < rn−2 .
(n)rn−2 = qn rn−1 + 0, 0 = rn < rn−1 .
Then, it follows that rn−1 ≥ 1, rn−2 ≥ 2rn−1 ≥ 2, ..., rn−j ≥ Fj+1
This gives us a nice result for some very specific cases of integers, but it raises a question about what happens
when it does not take exactly n divisions to find gcd(a, b) for some (a, b). In what follows, we have another
nice result which provides a maximum amount of divisions required to compute the greatest common divisor
of two integers, but we first need the following Lemma to establish this result.
Lemma. Fm > ( 58 )m−2 ∀m ≥ 3 ∈ Z where Fm is the mth Fibonacci number.
Date: February 18, 2015.
1
2
SAMPLES OF HIGHER RATED WRITING: LAB 3
Proof. We define the set S = {n ∈ N : Fn+2 > ( 58 )n }. We must show that S = N. That is, ∀n ∈ N, if n ∈ S
then n + 1 ∈ S.
Consider the base case where n = 1: 1 ∈ S because Fn+2 = F3 = 2 > ( 85 )1 .
When n = 2:
Assume that {1, 2, 3, . . . , n} ∈ S is true.
Then, both n − 1 ∈ S and n ∈ S are true.
Now, F(n−1)+2 > ( 58 )n−1 and Fn+2 > ( 85 )n .
Consider the case of n = n+1, we have F(n+1)+2 = F(n+1)+1 +Fn+1 > ( 85 )n +( 85 )n−1 = ( 85 )( 58 )n−1 +( 85 )n−1 =
8 n−1
( 13
> ( 85 )2 ( 85 )n−1 = ( 58 )n+1 .
5 )( 5 )
Now, we are in a position to establish a maximum bound on the number of divisions it takes to find the
greatest common divisor for two integers.
Theorem (Lamé’s Theorem). For a, b ∈ Z+ , computing gcd(a, b) requires at most 5n divisions where n is
the number of digits of min{a, b}
Proof. Assume b < a.
Let k be the number of decimal digits in b.
Then, 10k−1 ≤ b ≤ 10k , that is, b ∈ [10k−1 , 10k ].
Suppose exactly n steps are required to compute gcd(a, b). We must show that n ≤ 5k.
By Theorem 1, we know that b ≥ Fn+1 , so it follows that 10k > Fn+1 .
Claim: Fm > ( 58 )m−2 ∀m ≥ 3 ∈ Z.
By Lemma 1, we know that Fn+1 > ( 58 )(n+1)−2 so we have that 10k > ( 58 )n−1 .
Thus, (10k )5 = 105k > (( 85 )n−1 )5 = 10n−1 .
So, 5k > n − 1, or 5k ≥ n.
We now have a better idea of what sort of values n may take, since we have at least established its maximum.
In other words, we now have a concept of what the worst-case scenario for the number of steps in Euclid’s
algorithm looks like.
For example, imagine that, for some reason, we want to find the greatest common divisor of two integers
that have 5 and 3 digits, respectively. Because of Lame´’s Theorem, we know we are guaranteed to have our
answer within 15 steps, which sounds like a reasonable amount. However, imagine instead that we want the
greatest common divisor of two integers that have 700 and 500 digits, respectively. Now, we risk having to
go through 2500 steps in the algorithm, which does not sound appealing at all!
Fortunately, there are ways to improve upon the efficiency of Euclid’s algorithm, which will be discussed
after we look at a few of the algorithm’s applications.
Sample 2
If one was given two numbers, and asked what the Greates Common Divisor (GCD) of the two numbers
are they would have a choice of ways to compute it. First, before listing the ways let us explain what a
Greatest Common Divisor is.
Definition 1. Divides For integers a 6= 0 and b we say: a divides b if There is an integer k such that
b = k ∗ a. D(a) := {d : d a positive integer and d divides a} d|a denotes: d divides a.
The Greatest Common Divisor is just the biggest number that divides both (a,b). The GCD can be found
by using prime facotrization, the binary method, or by using Euclids Algorithm. This paper will focus solely
on using Euclids Algorithm and the speed at which the algorithm can be computed.
Theorem 1. If a,b,q and r are integers such that a=q*b+r, then gcd(a,b)=gcd(b,r).
This means that if we are given a pair of integers (a,b) and we want to find the gcd(a,b), then we can
use long division, and divide b into a to get q, the number which we multiplied b by to get close to a, and
r, the non-negative integer remainder that we must add to (q*b) to get the a. We then use the pair (b,r)
as our new (a’,b’). Every time we do this division, and have a number remainder we know to keep going
and do it again, when the remainder is 0 we stop and the previous r is the GCD. The focus of the speed of
Euclids Algorithm translates to how many long divisions must be done in order to find the GCD (or get our
remainder to 0). For example to find the gcd(6,14) the steps would look like this:
14=6*2+2
6=2*3+0
the gcd is 2
We see that we need 2 steps to find the gcd(6,14)=2. Through this we will have examples of Sage code to
compute the Euclidean Algorithm efficiently. We will investigate the speed of the Algorithm and use the
algorithm to investigate properties of the integers. We will also see the connection between the Euclidean
Algorithm and the Fibonacci sequence.
Sample 3
In today’s school system, elementary-level students are taught about the idea of "factors" of a number,
and are subsequently introduced to the notion of a "Greatest Common Factor," or GCF for short. Over the
years, the word divisor replaces the word factor, and GCF becomes GCD.
Definition 1. Divides: Let a, b ∈ Z. We say a divides b if there is a number c ∈ Z such that a ∗ c = b. This
can also be denoted a | b
Definition 2. Factor/Divisor : Let m, n ∈ Z. We say n is a factor or divisor of m if n | m.
Definition 3. Common Factor/Common Divisor : Let a, b, c ∈ Z. We say c is a common factor or common
divisor of a and b provided c | a and c | b.
SAMPLES OF HIGHER RATED WRITING: LAB 3
3
Definition 4. Greatest Common Divisor (GCD): Let D be the set of common divisors of a, b ∈ Z. The
greatest common divisor, or gcd, of a and b is equivalent to the largest element in D. In other words, if
∃d ∈ D, ∀e ∈ D, d ≥ e, then d is the gcd of a and b. The GCD of any two numbers must be greater than or
equal to 1.
The traditional method taught in elementary schools for finding the GCD of two numbers a, b was to find
all the divisors of a and b, and then compare the sets of divisors for each to find the greatest common divisor.
However, as we achieve much higher levels of education, we are introduced to a seemingly magical formula
to find the GCD of two numbers, using only the relatively easy concept of long division. This formula is
Euclid’s Algorithm.
Theorem 2. Long Division. Let a, b ∈ Z. Then there is only one unique pair of integers (q, r) where
0 ≤ r <| b | such that a = qb + r.
Proof. Suppose, for the sake of contradiction, that there is more than one unique solution pair (q, r) to
a = qb + r such that a, b, q, r ∈ Z and 0 ≤ r <| b |. Let(q0 , r0 ) and (q1 , r1 ) be two such solutions. There are
two cases to consider.
If q0 = q1 , then r0 = r1 . Thus (q0 , r0 ) = (q1 , r1 ). But (q0 , r0 ) 6= (q1 , r1 ). ⇒⇐
If q0 6= q1 , then because q0 and q1 are integers, there must be an integer c such that q0 = q1 + c. Since
a = q0 b + r0 and a = q1 b + r1 , q0 b + r0 = q1 b + r1 . Replacing q0 with q1 + c (q1 + c)b + r0 = q1 b + r1 .
By the law of distribution, q1 b + cb + r0 = q1 b + r1 . Subtracting q1 b from both sides yields the equation
cb+r0 = r1 . Recall that 0 ≤ r0 <| b | and 0 ≤ r1 <| b | and that c ∈ Z. However, if c 6= 0, then r0 < 0 and/or
r1 ≥| b |, violating the conditions on r0 and r1 . So c = 0, r0 = r1 and q0 = q1 . Thus (q0 , r0 ) = (q1 , r1 ). But
(q0 , r0 ) 6= (q1 , r1 ). ⇒⇐
Thus there is only one unique solution (q, r) to the equation a = qb + r such that 0 ≤ r <| b |.
Definition 5. Euclid’s Algorithm: Introduced in Euclid’s Elements (circa 300 B.C.E.), Euclid’s Algorithm
uses repeated long division to find the GCD of two numbers. Once the solution pair (q, r) has been found
for a given a and b, the process is repeated, using (b, r) as the new (a, b). This process goes on until rn = 0:
the b value for this final step (the r value from the previous step) is the GCD of the original (a, b). The
algorithm functions on a theorem that states that the GCD value of a given (a, b) is equal to the GCD of
(b, r). (Proof below.)
Theorem 3. Euclid’s Algorithm Let a, b ∈ Z. The greatest common divisor of a and b is equal to the greatest
common divisor of b and r, where r is the remainder in the long division equation a = qb + r.
Magic! We now have a way to unfailingly find the GCD of any two numbers without searching all of
their divisors! But now, more questions arise. What sort of patterns will (q, r) take as the algorithm is
employed? Is there a way to determine in advance how many steps it will take to find a solution? Could
other mathematical phenomena be related to the Euclidean Algorithm? To answer all this and more, we’ll
need a few more theorems and definitions under our belt.
Definition 6. Euclid’s Extended Algorithm: By going backwards and expressing previous remainders as
functions of earlier remainders, one can express gcd(a, b) as a sum of multiples of a and b. In other words,
Euclid’s Extended Algorithm finds integers x and y such that ax + by = gcd(a, b).
Definition 7. Fibonacci Numbers: A sequence introduced to Western mathematics by Leonardo Fibonacci,
defined by F0 = 0, F1 = 1, Fn+2 = Fn+1 + Fn .
Theorem 4. Lamé’s Theorem Let a, b ∈ Z and let k be the number of decimal digits in b (k ∈ Z:10k−1 ≤
b < 10k ) (1). The number of long division steps in Euclid’s Algorithm is ≤ 5k.
Sample 4
An algorithm is an explicitly defined computational procedure, an established blueprint of execution to
guarantee a precise, accurate result with each use. We see algorithms every day: recipes in the kitchen,
assembly instructions for your new desk, and the workings of the brain of every computer. There are
infinitely many examples from simple everyday tasks to the fine-tuned work of machines. You even use an
algorithm to tie your shoes. Everyone learns it differently; be it criss-cross and under the bridge, into the
tee-pee and over the mountain, or bunny ears; these are all similar versions of the same basic algorithm.
Near the end of the third century B.C., Euclid was a bright-eyed, bushy-tailed Greek mathematician with
the world in his pocket. His eager curiosity and brilliance would lead him to uncover what are now staples
in the world’s understanding of mathematics. Referred to now as the Father of Geometry, one of Euclid’s
more famous endeavors was his algorithm for finding the greatest common factor shared by any two given
numbers. This remains a fundamental algorithm in the study of mathematics today. Euclid’s fascination
with the golden ratio is less than surprising. Great mathematicians and philosophers have been studying
its beauty and wonder for centuries. The concept was new, and there was much to be learned. It is the
golden ratio that ties Euclid to Lamé. Centuries after Euclid’s time, mathematician Lamé would discover a
connection between the Fibonacci sequence and Euclid’s method for finding the greatest common divisor.
1.2. The Division Algorithm.
Definition 2. For integers a and b, where b 6= 0, we say that b divides a, denoted b|a, if there is an integer
k such that a = k · b.
Definition 3. For integers a, b, and d, we call d a common divisor of a and b provided d|a and d|b.
4
SAMPLES OF HIGHER RATED WRITING: LAB 3
Definition 4. For integers a and b, where b 6= 0, a positive integer d ≥ 0, where d|a and d|b, is known as
a common divisor of a and b. The greatest common divisor of a and b, denoted gcd(a, b), is the greatest
possible of such d.
Definition 5. For integers a, b, x, and y, a linear combination of a and b is an integer c of the form
ax + by = c.
Theorem (Division Algorithm). Let a > b be positive integers. There are unique integers q and r such that
a = q · b + r and 0 ≤ r < b.
1.3. The Euclidean Algorithm.
Theorem (Euclidean Algorithm). If a, b, q and r are integers such that a = q·b+r, then gcd(a, b) = gcd(b, r).
1.3.1. Euclidean Algorithm: The number of steps.
Theorem (Lamé). If a < b are positive integers, the number of Euclidean Algorithm steps required to
compute gcd(a, b), is no more than 5 times the number of digits of min{a, b}.
1.4. Lame’s Theorem. In 1844 while studying Euclid’s algorithm, Gabriel Lame found that the number
of steps required to find the GCD of a and b could be no more than 5 times the number of digits of a. For
example if we are finding the GCD (688, 599) with a=688 and b=599, then the number of steps required
to find the GCD will be no greater than 3*5=15. Lame’s theorem was one of the first applications of the
Fibonacci numbers and he used this in his proof of the Euclidean Algorithm’s number of steps.
1.5. Euclidean Algorithm & Linear Diophantine Equations. A Diophantine equation is is an equation
that seeks integer solutions. The equation ax + by = c, where a, b, and c are integers, is an example of a
linear Diophantine equation. Some Diophantine equations do not have solutions but, if gcd(a, b) divides c,
then it does have solutions. The Euclidean Algorithm produces such a solution (x, y) to the Diophantine
equation ax + by = c.
2. Technical Findings
Sample 1
UPPER AND LOWER BOUNDS OF THE EUCLIDEAN ALGORITHM
When looking at an algorithm it is useful to have an educated guess about the best and worst case scenario. With an idea of how long the process at hand might take a person, using the algorithm can help
better decide how they want to distribute their resources.
The definition of the Fibonacci sequence fits nicely into the Euclidean algorithm. Additionally, we noticed that upon iteration of the Euclidean Algorithm to the Fibonacci sequence results in q = 1 for all
steps. With only one multiple , q = 1, being taken off with each application of the algorithm, the Fibonacci
numbers appear to be a good way to estimate the run time of the algorithm.
In order to gain a better understanding of the number of computations required to find the gcd, we made
the following function in Sage.
import matplotlib.pyplot as plt
import random
from scipy.stats import norm
import matplotlib.mlab as mlab
import numpy
import pylab
def ed(a,b):
a,b=max(a,b),min(a,b)
cnt=0
rdr = 1
while rdr!=0:
qnt,rdr=floor(a/b),a%b
cnt=cnt+1
if rdr==0:
return cnt
a=b
b=rdr
def statt(a,b,nm):
d=[]
for m in xrange(50000):
d.append(ed(randint(10^(a+1),10^(a+2)),randint(10^(b+1),10^(b+2))))
fig1 = plt.figure()
ax1 = fig1.add_subplot(1, 1, 1)
n, bins, patches = ax1.hist(d,bins=range(min(d), max(d)),normed=true, color=’b’,histtype=’bar’)
ax1.set_xlabel(’Steps Required’)
ax1.set_ylabel(’Probability’)
c=a+1
f=b+1
SAMPLES OF HIGHER RATED WRITING: LAB 3
5
title="Steps Required for digits(a)=%d and digits(b)=%d"%(c,f)
plt.title(title)
pylab.savefig("g%d.png"%(nm))
plt.show()
result = numpy.mean(d)
print result
return result
k=[[] for x in range(5)]
figurecount = 0
for i in xrange(5):
for j in xrange(5):
print i,j
figurecount=figurecount+1
k[i].append(statt(i,j,figurecount))
for i in xrange(5):
print k[i]
print ’done’
Using the above function we were also able to gain an understanding of the distribution of steps required
based on the order of magnitude of the input numbers. The above code generated the below graphs.
6
SAMPLES OF HIGHER RATED WRITING: LAB 3
SAMPLES OF HIGHER RATED WRITING: LAB 3
7
8
SAMPLES OF HIGHER RATED WRITING: LAB 3
By taking the average of the data sets used to generate the above histograms, we were able to create
the following graph which was a helpful way to visualize the trends from above. By trying various fits on the
data it appears as though the efficiency of the algorithm is not polynomial. The trendline with the lowest
amount of steps was a logarithmic function.
This data could be used by a computing company that is trying to better price their computing time. Another interesting result from our investigation was a correlation between the Fibonacci numbers and the
steps required. The definition of the Fibonacci numbers is strikingly similar to the Euclidean algorithm.
(We observed this in our games report, so it was awesome to see the connection come back here!)
Sample 2
Question 6
What is gcd(Fj ,Fj+1 )? How many steps does the algorithm take? Do Fibonacci pairs behave like your
randomly chosen pairs in the previous section? What about gcd(Fj ,Fj+2 )? Is there a pattern here? Try
gcd(Fj ,Fj+3 ).
For both (Fj+1 , Fj ) and (Fj+2 , Fj ), j > 0, the GCD will always be 1. In the case of the former, the
algorithm takes 1 step when j = 1, as 1 = 1 ∗ 1 + 0. Otherwise, it requires j − 1 steps when j > 1.
Proof. First, consider the definition of a Fibonacci number(definition 7 above). Disregarding for the moment
0 and 1, all Fibonacci numbers F > 1 are related by the following:
Fn+2 = 1 ∗ Fn+1 + Fn .
By examining how this would affect Euclid’s Algorithm, we can see that the sequence would only end
at 2 = 2 ∗ 1 + 0, and until this equation is reached, we would go through each long division and end up
with the next pair of Fibonacci numbers! Observe that 1 = F2 . The equation with F2 and F3 (2 and 1) is
a 1-step solution. Each successive pair of Fibonacci numbers requires an additional step. So an equation
where b = Fj requires j − 1 steps.
In the case of Fj+2 , Fj , Consider this: Fn+2 = Fn+1 +Fn and Fn+1 = Fn +Fn−1 . So Fn+2 = 2∗Fn +Fn−1 .
Observe that, using Euclid’s Algorithm, the next step would be Fn = 1 ∗ Fn−1 + Fn−2 , returning to the
system described in the earlier proof. In essence, this version just "skips over" Fj+1 , but requires exactly
the same number of steps as (Fn+1 , Fn ). So we can say that this problem would still require 1 step for j = 1
and j − 1 steps for j > 1.
However, what about the case of Fj+2 , the GCD begins to take some odd turns. When j = 3, the GCD is
2, as it is for all j when j = 3n, where n ∈ N. This is because every 3rd Fibonacci number is divisible by 2.
SAMPLES OF HIGHER RATED WRITING: LAB 3
9
Question 9 Is it possible to improve Lamé’s Theorem by replacing "5" with "4"?
It is not possible to replace the "5" with "4" in Lamè’s Theorem. The reason for this is based in the
Fibonacci numbers. There are five distinct numbers of k digits in which k > 0 in the Fibonacci sequence.
By the definition of Fibonacci numbers Fn+2 = Fn+1 + Fn when F0 = 0 and F1 = 1 for all n ≥ 0. One
can see that the Fibonacci equation is a modified version of the Euclidean Algorithm in which a = Fn+2 ,
b = Fn+1 , r = Fn , and q = 1. So we can see that when using the Euclidean Algorithm to solve for the gcd of
two consecutive Fibonacci numbers is 1 and the number of steps it will take to solve for the gcd is n. Lets
give an example. Let b be a Fibonacci number which has k digits, so b = 8 and let a be the next Fibonacci
number with k + 1 digits, so a = 13. Now lets apply the Euclidean Algorithm to solve for the gcd(13, 8):
13 = (1)8 + 5
8 = (1)5 + 3
5 = (1)3 + 2
3 = (1)2 + 1
2 = (2)1 + 0
Notice that b = 8 has k = 1 digits and the process for finding the gcd took n = 5 steps.
Sample 3
In the eighth investigation, it is questioned what proportion of the pairs (a, b), where a > b and a is less
than some number n, are pairs for which Player ONE has a winning strategy in the Euclidean game. This is
first approached by gathering some data for small n up to 20 and looking for a pattern. If b = 1, then Player
ONE can subtract a ∗ 1 from a and win by leaving 0 as the lower number. If b = 2, then any a = m ∗ 2 where
m is an integer is winning for Player ONE for the same reason, as is a = m ∗ b for all b. The table starts
filling in with w’s. If a = m ∗ b + 1 up to m ∗ b + (b − 1), then Player ONE wins by taking (m − 1) ∗ b, to
arrive at an already established losing position with a and b reversed. If m = 1, however, then Player ONE
can’t take (1 − 1) ∗ b, since that is not positive. In that case, Player TWO can win, and an L is placed in
that box. The ability or inability to force Player TWO to land on an L square iteratively creates the rest of
the table below:
For a > b, if a < 2b, Player TWO has a winning strategy; otherwise, Player ONE does. For small values
of b, most values of a have a winning strategy for Player ONE.
3. Conclusion
Sample 1
To conclude, we have examined the Euclidean algorithm from a theoretical and numerical perspective in
addition to considering a small fraction of its applications. We successfully proved the truth of the algorithm
and it’s worst-case computational cost, and then were successful in testing a proposed modification to the
implementation of Euclid’s algorithm in the computer that significantly reduced the number of steps required
to find the gcd of any two integers.
Now, it might be worthwhile to look into the possibility of extending the Euclidean algorithm to other sets of
numbers. Particularly, we can ask ourselves if there exists a version of the Euclidean algorithm that operates
on complex numbers, and if so, what are its steps?
Additionally, we can pursue the question of using the Euclidean algorithm to study non-linear Diophantine
equations. That is, another interesting project could be to search for results about finding integer solutions
of polynomials that have a degree greater than 1.