Algebra

Algebra is the study of numbers and the rules they follow, so it starts with the numbers themselves. The first ones anybody uses are the counting numbers: 1, 2, 3, and so on, as many as you like. Add zero, the number of things in an empty box, and you have the natural numbers. Mathematicians write the set of them with a doubled letter, $\mathbb{N}$.

Every natural number has a next one, so there is no largest. You can always add two of them and get another natural number. You cannot always subtract: $3-5$ has no answer among the naturals. Each new kind of number in this module exists to fill a gap like that one.

Natural number

A counting number or zero: 0, 1, 2, 3, …

Set

A collection of things, written in braces: $\{1,2,3\}$.

Element

One of the things in a set. $3$ is an element of $\mathbb{N}$, written $3\in \mathbb{N}$.

We write numbers with ten digits, 0 to 9, and the place of a digit says what it is worth. In 3407 the 7 counts ones, the 0 counts tens, the 4 counts hundreds and the 3 counts thousands. Each place is worth ten times the one to its right, which is why this is called the decimal (base ten) system.

Zero matters here: it holds the tens place open. Without it, 3407 and 347 would look the same. Roman numerals had no zero and no places, which is one reason long sums in them were so hard.

Some ideas in this course are worth computing, so its exercises include small programs, written in C++. You need no programming to start: this slide and the next teach the C++ they are built from, and anything more is explained where it first appears. You write C++ as text, a compiler turns it into instructions the machine runs, and then it runs. Here the compiler (Clang) works inside this page: press Run.

1#include <cmath>2#include <iostream>3
4int main() {5  int apples = 7;          // a whole number6  double price = 0.35;     // a number with a fraction7  bool cheap = price < 1;  // true or false8  std::cout << "Cost: " << apples * price << "\n";9  std::cout << "Cheap? " << cheap << "\n";10  std::cout << 7 / 2 << " but " << 7.0 / 2 << "\n";11  std::cout << std::sqrt(2.0) << " " << std::pow(2, 10) << "\n";12  return 0;13}

• #include <iostream> brings in the part of the standard library (the code that comes with C++) that prints. #include <cmath> brings in the maths: std::sqrt, std::pow, std::abs, std::floor, std::round, and later std::exp, std::log and std::sin.
• int main() is where the program starts. The { } braces hold its steps, each ending in ;, and return 0; says it finished well.
• std::cout << x prints x, and "\n" starts a new line. std:: says the name comes from the standard library.
• A variable is a named box with a type that never changes: int for whole numbers, double for numbers with a fraction, bool for true or false. Text after // is a comment, for people: the compiler skips it.

1std::cout << 9 / 4 << " " << 9.0 / 4 << " " << 1 / 3;

A function is named steps you can use again: the type of its answer, its name, then its parameters (the values it is given) in brackets. It hands its answer back with return. Here is one for the area of a circle, one for the mean of a list, and a loop that decides between odd and even.

1#include <iostream>2#include <vector>3
4double area(double r) {             // given a double, returns one5  return 3.14159 * r * r;6}7
8double mean(const std::vector<double>& xs) {9  double total = 0;10  for (double x : xs) total += x;   // each x in the list, in turn11  return total / xs.size();12}13
14int main() {15  std::cout << area(2) << "\n";16  for (int i = 1; i <= 4; i++) {    // i = 1, 2, 3, 417    if (i % 2 == 0) {               // == compares; = would store18      std::cout << i << " is even\n";19    } else {20      std::cout << i << " is odd\n";21    }22  }23  std::vector<double> marks = {12, 15, 9};24  marks.push_back(16);              // add one at the end25  std::cout << marks[0] << " of " << marks.size() << "\n";26  std::cout << "mean " << mean(marks) << "\n";27}

• double area(double r) is given a double called r and returns a double. area(2) calls it, with r as 2.
• if (…) { … } else { … } runs one branch or the other. == compares (= stores), != is “not equal”, && is “and”, || is “or”, and % is the remainder: i % 2 == 0 means i is even.
• for (int i = 1; i <= 4; i++) starts i at 1, runs while i <= 4, and adds one (i++) after each turn. while (n > 0) { … } repeats while its condition holds. total += x is short for total = total + x.
• std::vector<double> (from <vector>) is a list of doubles: {12, 15, 9} makes one, marks[0] is the first (positions count from 0), marks.size() is how many, push_back adds one at the end, and for (double x : marks) visits each in turn.
• const std::vector<double>& xs lets a function read the caller’s list without copying it or changing it.

1#include <vector>2
3 sumOfSquares(const std::vector<double>& xs) {4  double total = ;5   (double x : xs) {6    total += ;7  }8   total;9}

A computer finds the digits of a number with two operations. n % 10 is the remainder when you divide by 10, which is the ones digit. n / 10 drops that digit, because dividing one int by another throws the fraction away: the trap from two slides ago, put to work. Repeat until nothing is left, and each digit times its place value gives the pieces of the sum $3\times 1000+4\times 100+0\times 10+7\times 1$ from before.

1#include <vector>2
3std::vector<int> placeValues(int n) {4  std::vector<int> parts;5  // TODO: take off the ones digit, times its place,6  // until n is 07  return parts;8}

To make $3-5$ have an answer, we add negative numbers: $-1,-2,-3,\dots$, written with a minus sign. You already use them: a temperature of $-4$ degrees is 4 below zero, and a bank balance of $-20$ is a debt of 20. The naturals and their negatives together are the integers, written $\mathbb{Z}$ (from the German Zahlen, “numbers”).

The number line is the picture to keep in your head: zero in the middle, positives to the right, negatives to the left, each integer one step from the next. Adding moves you right, subtracting moves you left. Drag the slider to move from 3, five steps left.

On the number line, of two numbers the one further right is the bigger. We write $a<b$ for “$a$ is less than $b$” and $a>b$ for “$a$ is greater than $b$”; the open side of the sign faces the bigger number. For negatives this can feel backwards: $-7<-2$, because $-7$ is further left. Being 7 below zero is colder than being 2 below.

The absolute value of a number is how far it is from zero, ignoring direction. It is written with two upright bars: $|5|=5$ and $|-5|=5$, because both are five steps from zero. A distance is never negative, so $|x|\ge 0$ for every $x$, and $|x|=0$ only when $x=0$.

The distance between any two numbers $a$ and $b$ is $|a-b|$. Subtracting finds the gap; the bars throw away which way you went. From $-3$ to $4$ is $|-3-4|=|-7|=7$ steps. Drag both points and watch the readout.

1#include <cmath>2
3double distance(double a, double b) {4  return b - a;5}

Integers let you subtract freely, but not divide: $7÷2$ is not an integer. So we add fractions: a number $\frac{p}{q}$, where $p$ and $q$ are integers and $q$ is not zero. These are the rational numbers (from ratio), written $\mathbb{Q}$ for quotient. Every integer is one too: $5=\frac{5}{1}$.

Rationals are dense: between any two of them there is another. Their average, $\frac{a+b}{2}$, is always between them, and it is rational too. So there are no gaps you could point to between rationals. And yet, as the next slide shows, the line still has holes.

Written as decimals, rationals either stop, like $\frac{3}{8}=0.375$, or settle into a block of digits that repeats for ever, like $\frac{1}{7}=0.142857142857\dots$ (Module 3 shows why). A bar over the block marks the repeat: $0.\overline{142857}$.

A square with sides of 1 metre has a diagonal $d$ with $d^2=1^2+1^2=2$ (Pythagoras’ theorem). So $d=\sqrt{2}$, the number whose square is 2. The ancient Greeks found, to their alarm, that no fraction squares to exactly 2. A number that is not rational is irrational. Its decimal goes on for ever without repeating: $\sqrt{2}=1.41421356\dots$

This is a proof by contradiction: assume the opposite, follow the rules, and reach something impossible. It is the first proof most people meet, and it shows what algebra can do that trying examples cannot: it settles the question for every fraction at once, including ones too big to ever write down.

The proof says no fraction works; a computer can show how close they get. For each bottom number $q$, the program takes the nearest top number $p$ and measures how far $p^2$ is from $2q^2$. If $\frac{p}{q}$ were exactly $\sqrt{2}$, the gap would be 0. Run it: the best fractions miss by exactly 1, every time.

1#include <cmath>2#include <iomanip>3#include <iostream>4#include <numbers>5
6int main() {7  std::cout << std::setprecision(17); // all the digits8  // Look for p/q with p * p exactly 2 * q * q.9  // long long: an int that holds whole numbers up to 9.2e1810  for (long long q = 1; q <= 500; q++) {11    long long p = std::llround(q * std::numbers::sqrt2);12    long long gap = p * p - 2 * q * q;13    if (gap == 0) std::cout << "A fraction for root 2!\n";14    if (std::abs(gap) == 1) {15      std::cout << p << "/" << q << " = " << 1.0 * p / q;16      std::cout << ", gap " << gap << "\n";17    }18  }19  std::cout << "sqrt2 = " << std::numbers::sqrt2 << "\n";20}

Put the rationals and the irrationals together and you get the real numbers, $ℝ$: every point on the number line, with no holes left. Each kind of number contains the one before it, so a number can belong to several sets at once. $-4$ is an integer, a rational and a real.

• Natural numbers $\mathbb{N}$ count: 0, 1, 2, … Adding them always gives another.
• Place value: each digit is worth ten times the same digit one place to its right.
• Integers $\mathbb{Z}$ add negatives, so subtraction always has an answer.
• On the number line, further right is bigger: $-7<-2$.
• $|x|$ is the distance from $x$ to 0; $|a-b|$ is the distance between $a$ and $b$.
• Rationals $\mathbb{Q}$ are fractions $\frac{p}{q}$; their decimals stop or repeat.
• Irrationals like $\sqrt{2}$ and $\pi$ are not fractions; their decimals never repeat.
• The reals $ℝ$ are the whole line: $\mathbb{N}\subset \mathbb{Z}\subset \mathbb{Q}\subset ℝ$.

What is $2+3\times 4$? Working left to right gives $5\times 4=20$; multiplying first gives $2+12=14$. Both are fair readings, so everyone has agreed on one: the order of operations. It is a convention, a rule people chose, not a fact of nature, and its job is that a written sum means the same to everybody. The agreed answer is 14.

1. Brackets first, innermost first.
2. Powers (and roots), like $3^2$.
3. Multiplication and division, left to right, as equals.
4. Addition and subtraction, left to right, as equals.

C++ follows the same convention: *, / and % before + and -, each level left to right, and brackets to override. It has no power operator: $2^3$ is std::pow(2, 3), a function call, worked out before anything around it. Beware 2 ^ 3: it compiles, but ^ is exclusive or on the numbers’ binary digits, and 2 ^ 3 is 1. When you are not sure, add brackets: they cost nothing and make your meaning plain to the next reader.

1std::cout << 12 / 3 * 2 << "\n";2std::cout << 2 + 3 * 4 << "\n";

Two laws let you rearrange freely. Commutative: the order of two numbers does not change the answer. Associative: how you group three numbers does not change it either. Both hold for addition and for multiplication, for every real number. The letters stand for any numbers: that is what makes them laws, not examples.

They are what make mental arithmetic possible: $25\times 17\times 4=(25\times 4)\times 17=100\times 17=1700$. Subtraction and division have neither law: $5-3\ne 3-5$, and $(8÷4)÷2=1$ but $8÷(4÷2)=4$.

The distributive law connects the two operations: multiplying a sum is the same as multiplying each part and adding. Picture a rectangle $a$ wide and $b+c$ long: its area is $a(b+c)$, and it is also the two smaller rectangles, $ab$ and $ac$, side by side. It is the law behind almost every simplification in algebra, from Module 5 on.

1bool first = 6 * 103 == 6 * 100 + 6 * ;2bool second = 9 * 49 == 9 * 50 - 9 * ;3bool third = 4 * 12 + 4 * 8 == 4 * ;

Adding 0 leaves a number alone, and so does multiplying by 1: they are the identity elements of addition and multiplication. Each number also has an inverse that brings you back to the identity. For addition it is the opposite, $-a$. For multiplication it is the reciprocal, $\frac{1}{a}$.

The last row is the useful one. $10-4$ is $10+(-4)$, and $10÷4$ is $10\times \frac{1}{4}$. So subtraction and division are not new operations, just adding and multiplying by an inverse. Solving equations in Module 6 is nothing but applying inverses.

A whole number $d$ divides $n$, written $d|n$, when $n÷d$ leaves no remainder; then $d$ is a factor (or divisor) of $n$ and $n$ is a multiple of $d$. A prime is a natural number with exactly two factors, 1 and itself: 2, 3, 5, 7, 11, 13, … A number above 1 that is not prime is composite. 1 is neither: it has only one factor.

Keep splitting a composite number into factors until every piece is prime. However you split, you end with the same primes: this is the fundamental theorem of arithmetic. Primes are the atoms that every natural number above 1 is built from, and the prime factorisation is its recipe.

1#include <vector>2
3std::vector<int> primeFactors(int n) {4  std::vector<int> factors;5  // TODO: try 2, 3, 4, … and divide each out6  // for as long as it goes7  return factors;8}

The greatest common divisor, $\gcd (a,b)$, is the biggest number that divides both. The least common multiple, $\mathrm{lcm}(a,b)$, is the smallest positive number both divide. You use the gcd to simplify fractions and the lcm to add them (Module 3). From the factorisations: the gcd takes each shared prime to the lower power, the lcm takes every prime to the higher power.

Notice $6\times 36=216=12\times 18$. That always holds: $\gcd (a,b)\times \mathrm{lcm}(a,b)=a\times b$, because between them they take every prime power from $a$ and $b$ exactly once. So once you have the gcd, the lcm is one division away.

Factorising big numbers is slow. Euclid found a way around it, around 300 BC, which is still how computers do it. Any number that divides $a$ and $b$ also divides the remainder $a-qb$ when $a$ is divided by $b$. So $\gcd (a,b)=\gcd (b,r)$: replace the pair with a smaller pair, and repeat until the remainder is 0. The last non-zero number is the gcd.

1int gcd(int a, int b) {2  // TODO: replace (a, b) with (b, a % b) until b is 03  return 1;4}5
6int lcm(int a, int b) {7  return a * b;8}

An estimate is a quick, rough answer, made by rounding each number to something easy. Rounding to the nearest hundred, 487 becomes 500 and 432 becomes 400: look at the tens digit, and round up from 5. Estimating first is how you catch a slip on a calculator: if you expected about 1000 and got 10 000, a key went wrong.

• Order of operations: brackets, powers, then × and ÷ left to right, then + and − left to right.
• Commutative and associative: order and grouping do not matter for + and ×. Not for − and ÷.
• Distributive: $a(b+c)=ab+ac$. Run it backwards to factor.
• Identities 0 and 1; inverses $-a$ and $\frac{1}{a}$. Zero has no reciprocal.
• A prime has exactly two factors. Every number above 1 factorises into primes in one way.
• gcd: shared primes at the lower power. lcm: all primes at the higher. $\gcd \times \mathrm{lcm}=ab$.
• Euclid: $\gcd (a,b)=\gcd (b,amodb)$, until the remainder is 0.
• Round and estimate first, so you know roughly what the answer should be.

Cut a cake into 4 equal slices and take 3: you have $\frac{3}{4}$ of the cake. The bottom number, the denominator, says how many equal parts the whole is cut into; the top, the numerator, how many you take. A fraction is also a division: $\frac{3}{4}=3÷4=0.75$, a point on the number line between 0 and 1.

Numerator

The top number: how many parts you have.

Denominator

The bottom number: how many equal parts make a whole. Never 0.

Proper fraction

Top smaller than bottom, so less than 1: $\frac{3}{4}$.

Improper fraction

Top at least the bottom: $\frac{7}{4}$, which is also the mixed number $1\frac{3}{4}$.

$\frac{1}{2}$, $\frac{2}{4}$ and $\frac{50}{100}$ are the same amount: cutting each piece in two doubles both the number of pieces and the number you hold. Multiplying or dividing the top and bottom by the same non-zero number gives an equivalent fraction. To simplify, divide both by their gcd (Module 2); the result is in lowest terms.

You can only add pieces of the same size. Quarters and sixths are different sizes, so first rewrite both as twelfths: 12 is the lcm of 4 and 6, the least common denominator. Then add the tops and keep the bottom. Subtracting works the same way.

To multiply, multiply the tops and multiply the bottoms: half of three quarters is $\frac{1}{2}\times \frac{3}{4}=\frac{3}{8}$. To divide, multiply by the reciprocal, the fraction flipped over (Module 2: dividing is multiplying by the inverse). $\frac{3}{4}÷\frac{1}{2}$ asks “how many halves fit in three quarters?”, and the answer is one and a half.

A computer’s 1.0 / 3 is a decimal that has been rounded (and in C++, 1 / 3 is worse: two ints divide to 0). To keep a fraction exact, store its top and bottom as two whole numbers. The starter does what many people do on paper: adds tops and bottoms. Fix it with the formula from two slides back, then simplify with the gcd that is already written.

1#include <cmath>2#include <utility>3
4int gcd(int a, int b) {5  while (b != 0) {6    int r = a % b;7    a = b;8    b = r;9  }10  return std::abs(a);11}12
13std::pair<int, int> addFractions(int a, int b, int c, int d) {14  return {a + c, b + d};15}

The places after the decimal point continue the pattern of Module 1: tenths, hundredths, thousandths. So $0.375=\frac{375}{1000}$, which simplifies to $\frac{3}{8}$. Going the other way, divide: $\frac{3}{8}=3÷8=0.375$.

A fraction in lowest terms has a decimal that stops exactly when its denominator has no prime factors except 2 and 5, the factors of 10. $\frac{3}{8}$ stops because $8=2^3$; $\frac{1}{6}$ never does, because $6=2\times 3$ and no power of ten is a multiple of 3.

Why must the decimal of a fraction repeat? In the long division $1÷7$, each step leaves a remainder, and a remainder on dividing by 7 can only be 0 to 6. If it ever is 0 the decimal stops; otherwise, within 6 steps a remainder comes back, and from then on the digits repeat. So $\frac{1}{7}=0.\overline{142857}$, a block of six.

To turn a repeating decimal back into a fraction, give it a name, shift it by the length of the block, and subtract: the endless tails cancel.

Per cent means “for each hundred”: $35\%=\frac{35}{100}=0.35$. To find $35\%$ of 80, multiply: $0.35\times 80=28$. A percentage change compares the change with where you started, so the starting value goes on the bottom.

A change of $p\%$ multiplies by $1+\frac{p}{100}$: up 20% is $\times 1.2$, down 20% is $\times 0.8$. That makes chains of changes easy, and shows a trap: up 20% then down 20% is $\times 1.2\times 0.8=\times 0.96$, a 4% loss overall. The graph shows a price of 100 going up by $p$% and then down by the same $p$%.

A ratio $a:b$ says how much of one thing there is for each amount of another: a dressing of oil and vinegar in the ratio $3:1$ has 3 spoons of oil for every spoon of vinegar. Like fractions, ratios simplify: $6:2=3:1$. To share 45 in the ratio $2:3$, cut it into $2+3=5$ equal parts of 9: one share is $2\times 9=18$, the other $3\times 9=27$.

Two amounts are in direct proportion when their ratio never changes: double one and the other doubles. Then $y=kx$ for a fixed constant of proportionality $k$, and the graph is a straight line through the origin. Here $x$ is kilograms of apples and $k$ the price per kilogram.

A rate is a ratio of two different kinds of quantity: kilometres per hour, euros per kilogram. To convert units, multiply by fractions equal to 1, like $\frac{1000\text{m}}{1\text{km}}$, chosen so the units you do not want cancel, top against bottom, like factors.

1double kmPerHour = 72;2double metresPerKm = ;3double secondsPerHour = ;4double metresPerSecond = kmPerHour * metresPerKm / secondsPerHour;5std::cout << metresPerSecond; // 20

• A fraction $\frac{p}{q}$ is $p÷q$; equivalent fractions multiply top and bottom by the same number.
• Simplify by dividing top and bottom by their gcd.
• Add and subtract over a common denominator: $\frac{a}{b}+\frac{c}{d}=\frac{ad+cb}{bd}$.
• Multiply straight across; divide by multiplying by the reciprocal.
• A decimal stops when the bottom has only 2s and 5s; otherwise it repeats.
• Shift and subtract turns a repeating decimal into a fraction: $0.\overline{27}=\frac{3}{11}$.
• A $p\%$ change multiplies by $1+\frac{p}{100}$; changes chain by multiplying.
• Proportion: $y=kx$. Convert units by multiplying by fractions equal to 1.

Just as $3\times 4$ is short for $4+4+4$, the power $4^3$ is short for $4\times 4\times 4=64$. The number multiplied, 4, is the base; the small raised number, 3, is the exponent (or index), and says how many times the base appears. $a^2$ is read “$a$ squared” and $a^3$ “$a$ cubed”, after the area of a square and the volume of a cube.

Every law of exponents comes from counting how many times the base appears. Multiply $a^3$ by $a^2$ and you have three $a$’s and then two more: five in all. Divide and the common ones cancel. Raise a power to a power and you repeat the whole group.