Number Theory Learning Module 2 — Prime Numbers and Integer in Sage 1

1 Objectives.

• Learn how to test for primality and generate prime numbers and in Sage. • Learn how to work with in Sage. • Introduce lists in Sage. • Do examples of mathematical experiments.

As usual, this should be read as a tutorial, in front of the computer, trying the commands as you read them.

2 Prime Numbers

The Sage function that checks if a number is prime or composite is called is_prime: is_prime(129) is_prime(101)

Try the following, to check that Sages uses the same conventions we made when defining prime numbers : is_prime(1) is_prime(0) is_prime(-2)

Sage can decide primality of pretty large numbers. For example, it will quickly determine that the 10th , 210 F10  2 1, is not prime: is_prime(2ˆ2ˆ10+1)

215 F10 is an integer with 309 digits. Now, let’s try to check if F15  2 1 is prime: is_prime(2ˆ2ˆ15+1)

Don’t be alarmed if Sage takes more than a few seconds to produce any output. This number has 9865 digits, and is taxing Sage a little bit. We often need to generate all primes to a given bound. This is done by the function prime_range: plist = prime_range(50) print plist

This will output: r2,3,5,7,11,13,17,19,23,29,31,37,41,43,47s The range does not have to start at 1: prime_range(2000,2500)

The prime_range function returns a Sage data structure called a list. Lists are denoted by a sequence of Sage objects enclosed by brackets. Lists are a very important structure, and have to be well understood to take full advantage of Sage. Elements of a list can be accessed using index notation:

Created by L. Felipe Martins. [email protected] License: http://creativecommons.org/licenses/by-nc-sa/3.0/us/ Learning Module 2 — Prime Numbers and Integer Factorization in Sage 2

plist[2] returns 5. Indexes in Sage (as in most modern computer languages) start at 0, so plist[2] returns the third list entry, not the second. This may take a while to get used to, but eventually becomes second nature. We compute the length of a list with the function len: len(plist)

This returns 15, which is the number of primes smaller than 50. Now suppose that we want to know the number of primes up to 1000. We can do this in a single statement, without using a variabale to store the intermediate result: len(prime_range(1000))

This shows that there are 168 primes smaller than 1000. There is an important point to be emphasized concerning ranges in Sage. For example, enter: prime_range(19)

This outputs r2,3,5,7,11,13,17s Notice that the upper limit of the range (19) is not included in the list, even though it is a . This is a convention that is enforced throughout Sage: The upper limit of a range is never included in the range. Lists are a very powerful construct, and will be studied in more detail in Section4. The functions next_prime and previous_prime return the first prime above and below its argument: next_prime(10000) previous_prime(10000}

Finally, applications in usually require the generation of ”random” primes, which is done with the function random_prime: random_prime(10000)

Go ahead and execute the command above several times. Each time it generates a different prime in the interval r0,10000q. To generate a random prime with, say, 30 digits, use: random_prime(10ˆ30,10ˆ31)

Computers, being deterministic machines, can’t really generate perfectly random numbers. Computer-generated se- quences that approximate randomness are called pseudorandom number generators. So, to be exact, we should say that random_prime generates pseudorandom primes in a given range.

3 Integer Factorization

The Sage function factor returns the prime factorization of an integer: factor(326025) factor(64184207) factor(3883843)

We can access the terms of the factorization using index notation:

Created by L. Felipe Martins. [email protected] License: http://creativecommons.org/licenses/by-nc-sa/3.0/us/ Number Theory Learning Module 2 — Prime Numbers and Integer Factorization in Sage 3

factors = factor(2282600) print factors first_factor = factors[0] print first_factor second_factor = factors[1] print second_factor This produces the following output: 23 ¤ 52 ¤ 101 ¤ 113 p2,3q p5,2q Each factor is represented as a pair pp,eq, where p is a prime and e is the corresponding exponent. The elements of the pair can also be accessed using index notation: print first_factor[0] print first_factor[1] The first statement prints the prime in the first term of the factorization (2) and the second the exponent (3). If we only need to know what are the prime factors of a number, we can use the prime_factors function: prime_factors{2282600}

4 Lists

One of the advantages of using software like Sage is that it becomes much simpler to perform mathematical experi- ments. In this section we explore the use of Sage’s lists to test conjectures about integer numbers. A Sage list is a sequence of comma-separated objects enclosed between [ and ]. A list can be created by explicitly enumerating its elements: list0 = [2,5,-3,0,2] print list0 This outputs: r2,5,¡3,0,2s Another basic method of generating lists is to use range: list1 = range(7) print list1 list2 = range(9,15) print list2 list3 = range(0,21,3) print list3 The last example shows how to use the third argument to specify a step size for the range. Notice, in all examples, that the upper limit is never included in the range. Another way to generate a list in to use list comprehensions. These have the following form: [ expression for variable in list ] Here is an example:

Created by L. Felipe Martins. [email protected] License: http://creativecommons.org/licenses/by-nc-sa/3.0/us/ Number Theory Learning Module 2 — Prime Numbers and Integer Factorization in Sage 4

list4 = [nˆ2 for n in range(11)] print list4

The expression defining list4 is interpreted as:

The list of n2, where n is an integer in the range r0,11q.

In other words, it generates a list of the squares of the integers from 0 to 10 (inclusive). There is another form of list comprehension that will be very useful to us:

[ expression for variable in list if condition ]

Suppose, for example, that we want to generate a list of the primes up to 100 that leave remainder 1 when divided by 4, that is, primes of the form 4n 1 for some integer n. This is how to do it: [p for p in prime_range(100) if p%4 == 1]

Recall that p%4 is the remainder of p divided by 4. To test if this is equal to 1, we use ==. (We can’t use = because this represents assignment.) Let’s also compute the list of primes up to 100 that have the form 4n 3: [p for p in prime_range(100) if p%4==3]

Notice that there are more primes of the form 4n 3 than of the form 4n 1. We can investigate whether this pattern holds for bounds different than 100. The actual list of primes does not have to be displayed each time, all we need is its length (that is, the number of entries). We can use the following: pmax = 1000 primes_list = prime_range(pmax+1) n1 = len([p for p in primes_list if p%4 == 1]) n3 = len([p for p in primes_list if p%4 == 3]) print "Remainder 1: " + str(n1) print "Remainder 3: " + str(n3)

This code introduces some techniques for improving organization and efficiency: • We assign the largest number in consideration (1000) to a variable. This makes it easier to change this value when experimenting.

• The list of primes is also precomputed and stored in the variable primes_list. This makes the code more efficient, since otherwise the list has to be computed twice.

• We store the number of primes of form 4n 1 and 4n 3, respectively, in the variables n1 and n3.

• We make Sage print a nice message explaining what is each computed value. The function str is used to convert a numerical value into a string, and + here means string concatenation.

Try different values for pmax and compare the values you get. Can you find a value of pmax for which the number of integers of form 4n 1 is greater than the number of primes of form 4n 3?

Created by L. Felipe Martins. [email protected] License: http://creativecommons.org/licenses/by-nc-sa/3.0/us/ Number Theory Learning Module 2 — Prime Numbers and Integer Factorization in Sage 5

5 Problems

1. Create list comprehensions defining the following sequences, and test them in Sage: (a) The sequence of numbers n3 for 1 ¤ n ¤ 10. (b) The sequence of integers n for 1 ¤ n ¤ 30 that are composite. Hint: The operator not represents negation in Sage. (c) The sequence of prime numbers p ¤ 200 that leave remainder 1 when divided by 3. (d) The sequence of prime numbers p ¤ 200 such that 2p ¡ 1 is prime. Note: The list you will obtain repre- sents all Mersenne primes discovered from around 500BCE (by the ancient greeks) to 1876 (by the french mathematician Edouard´ Lucas). Today, the largest known examples of prime numbers are of this form. 2. The is a method to identify all primes in a range of integers. In each step, the multiples of the primes 2, 3, 5, 7, . . . are successively eliminated. When the process stops, the numbers left are all the primes in the given range. (a) Manually perform a sieve to find all prime numbers up to 50. If you are not familiar, or do not remember, how the sieve works, search the web for an example. (b) In this and the next steps we will use Sage to perform the Sieve of Eratosthenes to find the primes up to 200. Start by creating a list of all the integers from 2 to 200: sieve_list = range(2,201) (c) Now we want to eliminate the multiples of 2, except for the number 2 itself. This can be done by: sieve_list = [n for n in sieve_list if n<=2 or n%2 != 0] print sieve_list The != means not equal. (d) Notice that it is not necessary to sieve the list for all primes up to 200. What is the largest prime one has to “sieve by”? Explain your answer carefully. (e) Continue the sieving process, as far as needed as determined by the previous item. When done, use the prime_range function to check your result. 3. Any integer a can be written in the form a  2nd, where d ¡ 1 is an odd integer. In this problem, we will n investigate when 2a 1  22 d 1 can be a prime number.

n (a) Choose several values of n and d, where d is odd and larger than 1 and test if 22 d 1 is prime. Choose at least 5 values of n, and at least three values of d for each n. Hint: you can make the test more automatic using list comprehensions. If you do that, it is easy to make even more tests. (b) Make a conjecture concerning primality of the numbers of the form being considered. Write it as a mathe- matical proposition, following the template: Let n be a positive integer and d ¡ 1 be odd. Then. . . (c) Prove your conjecture. Before writing your proof, you may want to make more tests, and factoring the numbers under consideration may be useful. 4. In this problem we continue the investigation of primes of the form 4n 1 and 4n 3 in an interval [0,pmax]. Let’s attempt to find a value pmax for which the number of primes of form 4n 1 is larger than the the number of primes of form 4n 3. We have to introduce some new Sage structures to do it efficiently. Enter the following code segment:

Created by L. Felipe Martins. [email protected] License: http://creativecommons.org/licenses/by-nc-sa/3.0/us/ Number Theory Learning Module 2 — Prime Numbers and Integer Factorization in Sage 6

pmax = ### Replace this by an integer ### primes_list = prime_range(pmax+1) n1 = 0 n3 = 0 for p in primes_list: if p%4==1: n1 += 1 else: n3 += 1 if n1 > n3: print p,n1,n3

Be very careful with indentation when typing this code.

(a) Try several values of pmax. Notice that the code may not display any message. Why is that? When it does print something, what does the numbers mean? What is the smallest pmax for which the number of primes of form 4n 1 is larger than those of form 4n 3? (b) Modify the code in such a way that it finds a value for which the number of primes of form 4n 1 and 4n 3 are equal. What is the smallest pmax for which this is true?

Created by L. Felipe Martins. [email protected] License: http://creativecommons.org/licenses/by-nc-sa/3.0/us/