This chapter introduces the notion of a ring, more specifically, a commutative ring with unity. The theory of rings provides a useful conceptual framework for reasoning about a wide class of interesting algebraic structures. Intuitively speaking, a ring is an algebraic structure with addition and multiplication operations that behave like we expect addition and multiplication should. While there is a lot of terminology associated with rings, the basic ideas are fairly simple.

Definitions, basic properties, and examples

Definition 9.1. A commutative ring with unityis a set R together with addition and multiplication operations on R, such that:

1. (i) the set R under addition forms an abelian group, and we denote the additive identity by 0R;

2. (ii) multiplication is associative; that is, for all a, b, c ∈ R, we have a(bc) = (ab)c;

3. (iii) multiplication distributes over addition; that is, for all a, b, c ∈ R, we have a(b + c) = ab + ac and (b + c)a = ba + ca;

4. (iv) there exists a multiplicative identity; that is, there exists an element 1R ∈ R, such that 1R · a = a = a · 1R for all a ∈ R;

5. (v) multiplication is commutative; that is, for all a, b ∈ R, we have ab = ba.

There are other, more general (and less convenient) types of rings–one can drop properties (iv) and (v), and still have what is called a ring.

This chapter introduces the notion of an abelian group. This is an abstraction that models many different algebraic structures, and yet despite the level of generality, a number of very useful results can be easily obtained.

Definitions, basic properties, and examples

Definition 8.1.An abelian group is a set G together with a binary operation ⋆ on G such that

1. (i) for all a, b, c ∈ G, a ⋆ (b ⋆ c) = (a ⋆ b) ⋆ c (i.e., ⋆ is associative),

2. (ii) there exists e ∈ G (called the identity element) such that for all a ∈ G, a ⋆ e = a = e ⋆ a,

3. (iii) for all a ∈ G there exists a′ ∈ G (called the inverse of a) such that a ⋆ a′ = e = a′ ⋆ a,

4. (iv) for all a, b ∈ G, a ⋆ b = b ⋆ a (i.e., ⋆ is commutative).

While there is a more general notion of a group, which may be defined simply by dropping property (iv) in Definition 8.1, we shall not need this notion in this text. The restriction to abelian groups helps to simplify the discussion significantly. Because we will only be dealing with abelian groups, we may occasionally simply say “group” instead of “abelian group.”

In this chapter, we discuss Euclid's algorithm for computing greatest common divisors. It turns out that Euclid's algorithm has a number of very nice properties, and has applications far beyond that purpose.

The basic Euclidean algorithm

We consider the following problem: given two non-negative integers a and b, compute their greatest common divisor, gcd(a, b). We can do this using the well-known Euclidean algorithm, also called Euclid's algorithm.

The basic idea of Euclid's algorithm is the following. Without loss of generality, we may assume that a ≥ b ≥ 0. If b = 0, then there is nothing to do, since in this case, gcd(a, 0) = a. Otherwise, if b > 0, we can compute the integer quotient q ≔ └a/b┘ and remainder r ≔ a mod b, where 0 ≤ r < b. From the equation

it is easy to see that if an integer d divides both b and r, then it also divides a; likewise, if an integer d divides a and b, then it also divides r. From this observation, it follows that gcd(a, b) = gcd(b, r), and so by performing a division, we reduce the problem of computing gcd(a, b) to the “smaller” problem of computing gcd(b, r).

In this chapter, we discuss basic definitions and results concerning matrices. We shall start out with a very general point of view, discussing matrices whose entries lie in an arbitrary ring R. Then we shall specialize to the case where the entries lie in a field F, where much more can be said.

One of the main goals of this chapter is to discuss “Gaussian elimination,” which is an algorithm that allows us to efficiently compute bases for the image and kernel of an F-linear map.

In discussing the complexity of algorithms for matrices over a ring R, we shall treat a ring R as an “abstract data type,” so that the running times of algorithms will be stated in terms of the number of arithmetic operations in R. If R is a finite ring, such as ℤm, we can immediately translate this into a running time on a RAM (in later chapters, we will discuss other finite rings and efficient algorithms for doing arithmetic in them).

If R is, say, the field of rational numbers, a complete running time analysis would require an additional analysis of the sizes of the numbers that appear in the execution of the algorithm. We shall not attempt such an analysis here—however, we note that all the algorithms discussed in this chapter do in fact run in polynomial time when R = ℚ, assuming we represent rational numbers as fractions in lowest terms. Another possible approach for dealing with rational numbers is to use floating point approximations.

This chapter concerns itself with the question: how many primes are there? In Chapter 1, we proved that there are infinitely many primes; however, we are interested in a more quantitative answer to this question; that is, we want to know how “dense” the prime numbers are.

This chapter has a bit more of an “analytical” flavor than other chapters in this text. However, we shall not make use of any mathematics beyond that of elementary calculus.

Chebyshev's theorem on the density of primes

The natural way of measuring the density of primes is to count the number of primes up to a bound x, where x is a real number. For a real number x ≥ 0, the function π(x) is defined to be the number of primes up to x. Thus, π(1) = 0, π(2) = 1, π(7.5) = 4, and so on. The function π is an example of a “step function,” that is, a function that changes values only at a discrete set of points. It might seem more natural to define π only on the integers, but it is the tradition to define it over the real numbers (and there are some technical benefits in doing so).

Let us first take a look at some values of π(x). Table 5.1 shows values of π(x) for x = 103i and i = 1, …, 6.

In this chapter, we review standard asymptotic notation, introduce the formal computational model we shall use throughout the rest of the text, and discuss basic algorithms for computing with large integers.

Asymptotic notation

We review some standard notation for relating the rate of growth of functions. This notation will be useful in discussing the running times of algorithms, and in a number of other contexts as well.

Suppose that x is a variable taking non-negative integer or real values, and let g denote a real-valued function in x that is positive for all sufficiently large x; also, let f denote any real-valued function in x. Then

• f = O(g) means that |f(x)| ≤ cg(x) for some positive constant c and all sufficiently large x (read, “f is big-O of g”),

• f = Ω(g) means that f(x) ≥ cg(x) for some positive constant c and all sufficiently large x (read, “f is big-Omega of g”),

• f = ⊗(g) means that cg(x) ≤ f(x) ≤ dg(x), for some positive constants c and d and all sufficiently large x (read, “f is big-Theta of g”),

• f = o(g) means that f/g → 0 as x → ∞ (read, “f is little-o of g”), and

• f ∼ g means that f/g → 1 as x → ∞ (read, “f is asymptotically equal to g”).

Example 3.1. Let f(x) ≔ x2 and g(x) ≔ 2x2 - x+1. Then f = O(g) and f = Ω(g). Indeed, f = ⊗(g). ▪

Number theory and algebra play an increasingly significant role in computing and communications, as evidenced by the striking applications of these subjects to such fields as cryptography and coding theory. My goal in writing this book was to provide an introduction to number theory and algebra, with an emphasis on algorithms and applications, that would be accessible to a broad audience. In particular, I wanted to write a book that would be accessible to typical students in computer science or mathematics who have a some amount of general mathematical experience, but without presuming too much specific mathematical knowledge.

Prerequisites. The mathematical prerequisites are minimal: no particular mathematical concepts beyond what is taught in a typical undergraduate calculus sequence are assumed.

The computer science prerequisites are also quite minimal: it is assumed that the reader is proficient in programming, and has had some exposure to the analysis of algorithms, essentially at the level of an undergraduate course on algorithms and data structures.

Even though it is mathematically quite self contained, the text does presuppose that the reader is comfortable with mathematical formalism and has some experience in reading and writing mathematical proofs. Readers may have gained such experience in computer science courses such as algorithms, automata or complexity theory, or some type of “discrete mathematics for computer science students” course.

It is sometimes useful to endow our algorithms with the ability to generate random numbers. To simplify matters, we only consider algorithms that generate random bits. Where such random bits actually come from will not be of great concern to us here. In a practical implementation, one would use a pseudo-random bit generator, which should produce bits that “for all practical purposes” are “as good as random.” While there is a welldeveloped theory of pseudo-random bit generation (some of which builds on the ideas in §6.9), we will not delve into this here. Moreover, the pseudorandom bit generators used in practice are not based on this general theory, and are much more ad hoc in design. So, although we will present a rigorous formal theory of probabilistic algorithms, the application of this theory to practice is ultimately a bit heuristic.

Basic definitions

Formally speaking, we will add a new type of instruction to our random access machine (described in §3.2):

random bit

This type of instruction is of the form α ← RANDOM, where α takes the same form as in arithmetic instructions. Execution of this type of instruction assigns to α a value sampled from the uniform distribution on {0, 1}, independently from the execution of all other random-bit instructions.

In describing algorithms at a high level, we shall write “b ←R {0, 1}” to denote the assignment of a random bit to the variable b, and “s ←R {0, 1}×ℓ” to denote the assignment of a random bit string of length ℓ to the variable s.