How to read the notation. A letter is a named quantity, not a new operation. Unless a section says otherwise, n is an input size or integer index; i, j, and k count positions or steps. A subscript, as in a[i] or a_i, selects one entry. A superscript, as in 2³, is a power: 2 × 2 × 2. Juxtaposition such as ab, a centered dot such as a·b, and × usually mean multiplication; f(n) means “the value of function f at input n,” not f multiplied by n. The sign ≠ means “not equal”; ≤ and ≥ mean “less than or equal” and “greater than or equal”; ≈ means “approximately equal.” An arrow → in a trace shows the next state or step; ⇒ in a proof means “implies.” Each chapter below gives its letters a local job.

A code-reading key for this course. Instruction snippets use Python or language-neutral pseudocode; monospaced trace tables and diagrams show the resulting states rather than executable statements. You do not need another guide open to read them. A variable is a name holding a value; x = 3 stores 3 under the name x. In ordinary mathematics, = states equality, but in Python it is assignment: the right-hand side is evaluated first, then stored in the left-hand name. Thus x = x + 1 increases x rather than asserting an impossible equation. == tests equality without changing either value.

Lists and positions. Square brackets make a list, an ordered collection. With a = [3,7,2], a[0] selects its first entry, 3; a[1] selects 7; and len(a) gives the number of entries, 3. Python counts positions from zero, so the last position is len(a)-1. a.append(9) adds 9 at the end. sum(a) adds the entries; min(a) and max(a) select a smallest and largest entry of a nonempty list; abs(x) gives the magnitude of x without its sign. Parentheses call a function, as in len(a); they also group arithmetic. Two values such as (2,5) form an ordered pair (a tuple).

list a:          [3, 7, 2]
Python index:     0  1  2
mathematical
1-based index:    1  2  3
# An index selects an entry; len(a)=3 counts entries.

Blocks and functions. def defines a named function; names in its parentheses are its inputs, called parameters. return gives the caller an answer and immediately ends that call. A colon starts a block; indentation shows which statements belong to it. if runs its indented block when the test is True, and else supplies the alternative.

def larger(x, y):           # define a function with two inputs
    if x > y:               # this test belongs to the function
        return x            # this answer belongs to the if branch
    else:
        return y

answer = larger(3, 7)       # caller passes x=3, y=7; stores answer 7

Loops and collections of tests. for x in items takes one item at a time, assigning it to x, and runs the indented body once for each item. range(n) supplies the integers 0 through n−1; range(start, stop) includes start but excludes stop; a third argument sets the step. A while loop repeats while its test remains True. break leaves the nearest loop. Unlike return, it does not by itself leave the function.

total = 0
for x in [2, 4, 6]:
    total += x
# x:          2     4      6
# total: 0 →  2  →  6  →  12

# range(1,4) supplies 1,2,3; range(0,7,2) supplies 0,2,4,6.
# Collecting results in brackets is a list comprehension:
squares = [x*x for x in [2, 4, 6]]   # [4,16,36]

all(...) asks whether every supplied test is True; any(...) asks whether at least one is True. The phrase test for x in items generates one test per item. In all(x > 0 for x in [2,4,6]), the three tests are True, True, True, so all returns True. In any(x > 5 for x in [2,4,6]), the tests are False, False, True, so any returns True. This mirrors the mathematical “for every” and “there exists.” With no tests, all returns True and any returns False.

in also tests membership outside a loop: 3 in [1,3,5] is True. A set such as {1,3,5} stores distinct members without an index order; set() makes an empty set. A dictionary such as {'A': 2, 'B': 5} maps labels to values; indexing by ['A'] retrieves 2. More specialized syntax is explained where used. Code demonstrates a mechanism; running finite examples does not establish a theorem for every input.

Concrete starting point. A recipe for finding the largest list entry must work for every allowed nonempty list, not merely today's example. Its input is the supplied list; its state is the changing collection of variable values; its output is the returned largest value. A precondition says what must be true before it starts (the list is nonempty); a postcondition says what it guarantees when it ends (the returned value is a largest entry).

input [3, 7, 2] → initialize best=3 → compare 7 → best=7
                                               ↓
output 7        ← return best      ← compare 2, keep best=7

One statement's result becomes the next statement's input. With x = 2, then x = x + 3, then y = 2 * x, the state changes (x,y): (2,unset) → (5,unset) → (5,10). Reversing the last two statements would give a different y.

A condition is a true-or-false question. Only the chosen branch runs; the other branch contributes no actions on that execution.

def absolute(x):
    if x < 0:
        return -x
    else:
        return x

# x=-3 → question (-3 < 0)? yes → return 3
# x= 4 → question ( 4 < 0)? no  → return 4

A loop repeats a body while its condition permits it. The loop counter i names the current repetition, not a fixed value.

total = 0
for i in range(1, 4):    # Python includes 1,2,3; excludes 4
    total = total + i
# i:        1  2  3
# total: 0→ 1→ 3→ 6

A recursive call starts a new invocation with its own input. A base case returns without another call; a recursive case reduces the problem. Here n must be a nonnegative integer.

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)
# factorial(3) → 3 * factorial(2) → 3 * 2 * factorial(1)
#              → 3 * 2 * 1 * factorial(0) → 6

Translate every mark into an action. x ← x + 1 reads “replace the old value of x by the old value plus one”; ← is assignment. a[i] reads “the entry at index i of array a”; n is the number of entries. > means strictly greater, ≥ includes equality, and … means continue the displayed pattern. Pseudocode's for i ← 2 to n below includes both endpoints. Its indices start at 1; the equivalent Python indices start at 0.

def maximum(a):
    best = a[0]                    # requires a nonempty list
    for i in range(1, len(a)):      # indices 1 through len(a)-1
        if a[i] > best:
            best = a[i]
    return best

# mathematical a[1], a[2], a[3], a[4]
# Python      a[0], a[1], a[2], a[3]
# values        3     7     2     9

Why a trace is not a proof. The trace [3,7,2,9] → 9 checks four values. The invariant must cover an arbitrary number of arbitrary values. For the maximum algorithm, “best is largest among entries inspected so far” is preserved because the next entry either replaces best when larger or leaves it alone.

already inspected           next entry         new inspected prefix
[3, 7] with best=7       +   [2]            →  [3, 7, 2], best=7
[3, 7, 2] with best=7    +   [9]            →  [3, 7, 2, 9], best=9

The loop also terminates: the number of uninspected entries drops by one each time and cannot become negative. An invariant plus a stopping argument proves total correctness; an invariant alone need not rule out an infinite loop.

Let n be the number of list entries, and let f(n) count a chosen operation. For the maximum algorithm, the first entry initializes best and each of the remaining entries needs one comparison, so f(n) = n − 1. This is an operation count, not a number of seconds. We normally treat one comparison of fixed-size values as constant cost; operations on enormous integers can require a different cost model.

n (entries)       1   2   4   8
comparisons n-1   0   1   3   7
# Doubling the input nearly doubles the comparisons.

These are three different functions of the same size n. For linear search in [A,B,C,D], finding A costs 1 comparison, finding D costs 4, and missing entirely costs 4. If each of the four present targets is equally likely, average cost is (1+2+3+4)/4 = 2.5. If absent targets are allowed, the distribution must also say how often absence happens.

# Explicitly average the costs under a uniform present-target model.
costs = [1, 2, 3, 4]
average = sum(costs) / len(costs)   # 2.5
# best = min(costs)=1; worst = max(costs)=4

Read a bound as a comparison of curves. f(n) is the measured work, g(n) is a simpler comparison function, c is a fixed positive scale factor, and n₀ (“n sub zero”) is the size beyond which the bound must hold. ∀ n ≥ n₀ reads “for every n at least n-zero”; ∃ c > 0 reads “there exists a positive constant c.” Constants must stay fixed as n grows.

The equals sign here is conventional shorthand for belonging to a class of functions; O(g(n)) is not one exact numerical value.

# A few points illustrate, but do not prove, the bound.
# f(n)=3*n**2+5*n; lower=3*n**2; upper=4*n**2
n                1     5      10       100
lower            3    75     300     30000
f(n)             8   100     350     30500
upper            4   100     400     40000
# From n=5 on: lower ≤ f ≤ upper.
# For all n≥5, 5*n≤n**2 is the algebraic proof.

“Drop constants” applies to fixed multipliers and lower-order additions, not to the exponent. 7*n**3 and n**3 have the same growth class; 2**n and 3**n do not. A term is lower-order when its share of the dominant term tends to zero.

def f(n):
    return 7*n**3 + 20*n**2 + 900
# n:                      10          100
# dominant 7*n**3:       7000      7000000
# remaining terms:       2900       200900
# remaining / dominant:  0.414        0.0287

What each shape means. log₂ n asks “how many doublings of 1 reach n?” Thus log₂8 = 3 because 2³ = 8. n log n means n times log n; n² means n times n; cⁿ means a fixed base c multiplied by itself n times. In logₐ n, a is the base and must be positive and not 1. Complexity comparisons here use fixed bases greater than 1. The change-of-base fraction below divides two logarithms; it does not change the input n.

n                 4       8        16
1                 1       1         1
log₂ n            2       3         4
n                 4       8        16
n log₂ n          8      24        64
n²               16      64       256
2ⁿ               16     256     65536
n!               24   40320   20922789888000

The square-root shape √n asks for a number whose square is n: √16=4. A polynomial term nᵏ keeps its exponent k fixed while n grows; an exponential term cⁿ keeps its base c>1 fixed while n grows. These are different growth mechanisms. At the fast end, nⁿ multiplies n by itself n times, whereas n! multiplies the differing factors 1 through n. Thus 4⁴=256 while 4!=24. The ordering describes eventual growth, not strict ordering at every small input. For example 2⁴ = 4², and constants can let a quadratic implementation beat a linear one on small lists.

Count how many times the innermost body actually runs. Python's range(n) supplies n values, 0 through n−1. A body that costs more than constant work must have that cost included too.

# Compare three traversal shapes when n=4.
# square                 triangle             doubling
# (i,j) visits:          (i,j) visits:         i values:
# 1: xxxx                1: x                 1 → 2 → 4(stop)
# 2: xxxx                2: xx                2 body executions
# 3: xxxx                3: xxx
# 4: xxxx                4: xxxx
# 16 total               10 total

A fixed number of fixed-size arithmetic operations does not grow with n. return a + b performs one addition whether a list elsewhere contains 10 or 10,000 entries.

for i in range(n):
    inspect(i)     # assume inspect costs one unit
# n=4: inspect(0), inspect(1), inspect(2), inspect(3): 4 units

for i in range(0, n, 10):
    inspect(i)
# n=31: i=0,10,20,30 → 4 units = ceiling(n/10)
# Growing n by a factor of 10 still grows the count about tenfold.

The exponent k counts completed doublings; it is not the current value i. Each extra bit of n allows approximately one more doubling.

i = 1
while i < n:
    inspect(i)
    i *= 2
# n=16: inspect 1 → 2 → 4 → 8; i=16 stops.
# Four repetitions, log₂16=4. For other n, round upward.

for i in range(n):
    for j in range(n):
        inspect(i, j)
# n=3 visits a 3-by-3 grid: (0,0),(0,1),(0,2),
#                         (1,0),(1,1),(1,2),
#                         (2,0),(2,1),(2,2).

The inner count now depends on the outer counter. Add its actual lengths instead of blindly multiplying n by n.

for i in range(1, n + 1):
    for j in range(i):
        inspect(i, j)
# n=4: lengths 1 + 2 + 3 + 4 = 10 = 4*5/2.
# Two triangles fit a 4-by-5 rectangle, hence division by 2.

for i in range(n):
    j = 1                    # reset for EACH outer repetition
    while j < n:
        inspect(i, j)
        j *= 2
# n=8: 8 rows; each visits j=1,2,4 → 8*3=24 visits.

Without resetting j, only the first outer repetition would run the inner loop. The program's actual state matters more than indentation alone.

for i in range(n):
    inspect(i)
for i in range(n):
    for j in range(n):
        inspect(i, j)
# n=4: 4 visits THEN 16 visits = 20, not 4*16.

“Multiply” means each outer repetition pays the full inner cost: 4 outer repetitions × 3 inner visits each = 12 visits. If the inner length changes with i, add those lengths as in the triangle example instead.

Read the sum sign. Σ (capital sigma) means “add the listed values.” In Σᵢ₌₁ⁿ i², i is a temporary counter, its first value is 1, its last is n, and i² is the item being added: 1² + 2² + … + n². It does not mean square the total sum.

constant_work = sum(1 for i in range(1, n + 1))
triangle_work = sum(i for i in range(1, n + 1))
square_work   = sum(i*i for i in range(1, n + 1))
level_work    = sum(2**i for i in range(k + 1))
# k=3: level widths 1 | 2 | 4 | 8, total=15.
# Number of levels=4; total work=15. These are different quantities.

In the code below, a is a list, x is the search target, and index −1 signals “not found.” Sorting examples compare numeric keys. A key is the field used for ordering, such as a surname; different records can share the same key. Auxiliary memory is extra storage beyond the input itself, such as a temporary list or a recursive call stack.

Start at the first entry and compare each value with the target. A match ends the search immediately; reaching the end proves the target is absent.

def linear_search(a, x):
    for i in range(len(a)):
        if a[i] == x:
            return i
    return -1
# a=[8,3,9,2], x=9:
# index     0   1   2
# compare   8   3   9 → equal, return index 2
# A missing target would inspect the final 2 as well.

The candidate interval has endpoints lo (“low”) and hi (“high”), both included. mid is their integer midpoint. Sorted order justifies every discarded half; without it, the target might be in the half thrown away.

def binary_search(a, x):
    lo, hi = 0, len(a) - 1
    while lo <= hi:
        mid = (lo + hi) // 2
        if a[mid] == x:
            return mid
        if a[mid] < x:
            lo = mid + 1
        else:
            hi = mid - 1
    return -1
# a=[1,3,5,7,9,11,13], x=11
# [1 3 5 7 9 11 13] midpoint=7; x is larger
#          [9 11 13] midpoint=11; found at index 5
# Stopping lo>hi means the candidate interval is empty.

Compare neighbors and swap any pair in the wrong order. One sweep carries a largest remaining value to the right edge; repeat on the unfinished part.

def bubble_sort(a):
    for end in range(len(a) - 1, 0, -1):
        swapped = False
        for j in range(end):
            if a[j] > a[j + 1]:
                a[j], a[j + 1] = a[j + 1], a[j]
                swapped = True
        if not swapped:
            break
# [3,1,2] → [1,3,2] → [1,2,3] | next pass: no swap, stop
#          compare neighbors          fixed suffix [3]

The comma assignment swaps two entries simultaneously. The strict > test does not swap equal keys, which preserves stability.

Reserve the next output position, scan the unfinished entries to find their minimum, and swap that minimum into the reserved position. The sorted prefix grows one item per pass.

def selection_sort(a):
    for i in range(len(a) - 1):
        smallest = i
        for j in range(i + 1, len(a)):
            if a[j] < a[smallest]:
                smallest = j
        a[i], a[smallest] = a[smallest], a[i]
# [3,1,2] → find minimum 1, swap → [1 | 3,2]
#          find remaining minimum 2 → [1,2 | 3]
# Left of | is the completed sorted prefix.

Treat the left prefix as already sorted. Pick up its next neighbor, shift larger prefix entries right to make a space, and put the picked-up item into that space.

def insertion_sort(a):
    for i in range(1, len(a)):
        item = a[i]
        j = i - 1
        while j >= 0 and a[j] > item:
            a[j + 1] = a[j]       # shift larger entry right
            j -= 1
        a[j + 1] = item
# [3 | 1,2] → [1,3 | 2] → [1,2,3 |]
# Insert 1 before 3; then insert 2 between 1 and 3.

Two sorted lists are easy to combine: keep taking the smaller front item. Merge sort obtains those sorted lists by splitting until each piece has at most one item, then combines them on the way back up.

MERGE(left, right):
    output = empty list
    while neither list is empty:
        move the smaller front item to output
        on a tie, choose left
    append the unconsumed items from either list
    return output

MERGE_SORT(items):
    if length(items) <= 1: return items
    split items into left and right halves
    return MERGE(MERGE_SORT(left), MERGE_SORT(right))

[4,1,3,2]        split
   /     \
[4,1]   [3,2]    split
 /  \     /  \
[4] [1] [3] [2]  singleton lists already sorted
 \  /     \  /
[1,4]   [2,3]    merge
   \     /
 [1,2,3,4]      merge

A pivot is a chosen key used to divide the other keys. Partitioning groups keys by their relation to it; it does not by itself sort the groups.

def quicksort(a):
    if len(a) <= 1:
        return a
    pivot = a[(len(a) - 1) // 2]
    less = [x for x in a if x < pivot]
    same = [x for x in a if x == pivot]
    more = [x for x in a if x > pivot]
    return quicksort(less) + same + quicksort(more)
# [3,8,5,1,9,2], pivot at index (6-1)//2=2, value 5:
#       [3,1,2]  | [5] | [8,9]
# sort→ [1,2,3]  | [5] | [8,9] → concatenate
# Balanced partitions: widths n, n/2, n/4... along each path.
# Bad partitions:       n, n-1, n-2... along the long path.

This clear three-list version uses extra lists and preserves order among equal keys. The usual “in-place, unstable” description below refers to swap-based partition implementations, not this particular teaching version.

These categories describe a strategy, not a guaranteed runtime or correctness result. A strategy can combine with another; memoized recursion is both recursive and dynamic programming.

# Find a pair summing to target by trying every pair.
for i in range(len(a)):
    for j in range(i + 1, len(a)):
        if a[i] + a[j] == target:
            return (i, j)
# [2,5,7], target=9: try (2,5) → (2,7), success.
# All-pairs enumeration is quadratic here, not exponential.

# Greedy coin choice: repeatedly take the largest coin that fits.
# coins=[4,3,1], amount=6
# greedy path: 6 → take 4 → remainder 2 → take 1 → take 1
# result [4,1,1]: three coins
# better [3,3]: two coins

The locally largest coin did not give the global minimum number of coins. A proof of a greedy-choice property is needed before assuming this strategy solves a minimization problem.

Kruskal and Prim, named below, are examples where that property can be proved. For a connected undirected network, they find a minimum spanning tree: connect every point (vertex) of the network using connections (edges) of minimum total cost, with no cycles. Kruskal takes the cheapest available edge that does not form a cycle; Prim takes the cheapest edge connecting the growing tree to a new vertex.

triangle edge costs: A--B costs 1; B--C costs 2; A--C costs 4

KRUSKAL: sort edges by cost → take AB(1) → take BC(2)
         skip AC(4): it would close the cycle A-B-C-A
PRIM from A: take AB(1) → tree contains A,B
             among edges reaching C, choose BC(2) over AC(4)

chosen tree: A --1-- B --2-- C     total cost 3

problem size 8
      ↓ divide
    4     4
   / \   / \
  2   2 2   2    solve smaller problems
      ↑ combine their answers
# Merge sort combines by merging; binary search keeps only one child.

def fib(n):                       # nonnegative integer n
    values = [0, 1]
    for k in range(2, n + 1):
        values.append(values[k - 1] + values[k - 2])
    return values[n]
# index k:    0  1  2  3  4  5
# values[k]:  0  1  1  2  3  5
# Each earlier answer is stored and reused, not recomputed.

Memoization stores answers on demand during recursion; tabulation fills a table in dependency order as above. Both exploit overlapping subproblems.

In a = qn + r, a is the dividend, n the positive divisor, q the quotient (whole groups), and r the remainder (leftovers). div names the quotient operation; mod names the remainder operation. The constraint 0 ≤ r < n reads “r is at least zero and strictly less than n.”

q, r = divmod(17, 5)      # q=3, r=2
# [*****] [*****] [*****] **
# 3 full groups of 5       2 left over
q, r = divmod(-21, 33)    # q=-1, r=12
# -21 = (-1)*33 + 12; use the floor quotient, not truncation toward 0.

a ≡ b (mod n) reads “a is congruent to b modulo n.” The triple bar means equal remainders, not equal integers. n ∣ (a−b) says the difference is a whole multiple of n. A residue class is all integers having one specified remainder.

def congruent(a, b, n):
    return (a - b) % n == 0    # n must be positive
# Modulo 5, the class of 2 is:
# ... -8 -- -3 -- 2 -- 7 -- 12 -- 17 ...
#          every step adds 5
# 12 ≡ 2 (mod 5) is true; 12 = 2 is false.
# Clock: 10 → 11 → 0 → 1 → 2 → 3 (five hours mod 12).

A factor divides a number exactly; a prime factor is a factor that is prime. The symbol √N reads “square root of N,” the nonnegative number whose square is N. Neither 0 nor 1 is prime; 1 is also not composite.

def is_prime(N):
    if N < 2:
        return False
    d = 2
    while d*d <= N:
        if N % d == 0:
            return False
        d += 1
    return True
# This checks all integers up to √N, including some redundant composites.
# 60 = 2 * 30 = 2 * 2 * 15 = 2² * 3 * 5
# Prime-factor leaves: 2, 2, 3, 5. Order can change; the multiset cannot.

gcd(a,b) reads “greatest common divisor of a and b”; lcm(a,b) reads “least common multiple.” A multiple is what you obtain by multiplying by an integer. |ab| means the absolute value of their product: remove its sign. For the product identity below, take positive a and b (it extends to nonzero integers with absolute values).

from math import gcd

def lcm(a, b):              # positive inputs here
    return a // gcd(a, b) * b

#                   12 = 2² * 3¹
#                   18 = 2¹ * 3²
# min exponents → gcd  = 2¹ * 3¹ = 6
# max exponents → lcm  = 2² * 3² = 36
# multiples of 12: 12,24,36,48,...
# multiples of 18: 18,36,54,... → first shared positive one is 36.

Each step replaces the pair “old dividend, old divisor” by “old divisor, new remainder.” The quotient q records how many copies were removed; only the remainder affects the next pair.

def euclid(a, b):
    a, b = abs(a), abs(b)
    while b != 0:
        a, b = b, a % b
    return a

# pair (a,b)     quotient   remainder   next pair
# (252,105)         2          42       (105,42)
# (105,42)          2          21       (42,21)
# (42,21)           2           0       (21,0) → return 21

In gcd(a,b) = sa + tb, s and t are integer coefficients: the multipliers telling how many signed copies of a and b to combine. They can be negative. Extended Euclid tracks a remainder together with the two coefficients expressing that remainder in terms of the original inputs.

def extended_gcd(a, b):     # nonnegative a, positive b
    if b == 0:
        return a, 1, 0     # a = 1*a + 0*b
    g, u, v = extended_gcd(b, a % b)
    return g, v, u - (a // b) * v

# remainder      coefficient of 252     coefficient of 105
# 252                    1                      0
# 105                    0                      1
#  42=252-2*105          1                     -2
#  21=105-2*42          -2                      5
# Thus 21=(-2)*252 + 5*105.

a⁻¹ reads “a inverse” in this modular setting. The exponent −1 names an undo operation; it does not ask for a negative residue or an ordinary decimal reciprocal. In ax ≡ 1 (mod n), a and n are known and x is the inverse to find.

def inverse(a, n):
    g, s, t = extended_gcd(a, n)
    if g != 1:
        raise ValueError('no modular inverse')
    return s % n

# multiplication by 3 modulo 7:
# input x:   0 1 2 3 4 5 6
# output:    0 3 6 2 5 1 4
#                            x=5 lands at 1, so inverse(3,7)=5.
# multiplication by 2 modulo 8:
# output:    0 2 4 6 0 2 4 6 → 1 never appears.

raise ValueError(...) stops the calculation with an error message when the precondition for an inverse fails; it must not silently return an invented inverse.

A linear congruence asks which integer x makes a*x leave the same remainder as b when divided by n. The gcd d measures a shared obstruction. “d incongruent solutions modulo n” means d distinct representatives among 0,1,…,n−1, with infinitely many integer solutions obtained by adding multiples of n.

def solutions(a, b, n):
    return [x for x in range(n) if (a*x - b) % n == 0]
# Small enumeration illustrates 4*x ≡ 6 (mod 10):
# x:       0 1 2 3 4 5 6 7 8 9
# 4*x %10: 0 4 8 2 6 0 4 8 2 6
#                 ↑         ↑
# solutions x=4,9. Reduce all three a,b,n by d=2:
# 2*x ≡ 3 (mod 5) → x≡4 (mod 5) → 4 and 9 modulo 10.

Each subscript i selects one equation: nᵢ is its modulus and aᵢ its required remainder. “Pairwise coprime” means every pair of distinct moduli has gcd 1. N is the product of all moduli; Nᵢ = N/nᵢ omits just the ith one; yᵢ is the inverse of Nᵢ modulo nᵢ. The sum Σᵢ aᵢNᵢyᵢ adds one carefully isolated contribution per equation.

from math import prod

def crt(residues, moduli):  # positive, pairwise coprime moduli
    N = prod(moduli)
    answer = 0
    for ai, ni in zip(residues, moduli):
        Ni = N // ni
        yi = inverse(Ni, ni)
        answer += ai * Ni * yi
    return answer % N

# equation       Ni   yi   contribution     mod 3   mod 5
# x≡2 (mod 3)     5    2   2*5*2=20           2       0
# x≡3 (mod 5)     3    2   3*3*2=18           0       3
# sum=38, reduce modulo N=15 → 8              2       3

In the code, prod(moduli) multiplies the moduli, and zip(residues,moduli) pairs each remainder with its corresponding modulus. The two lists must have the same length. The zeroes in the other equation's column are why adding contributions does not undo earlier requirements. With non-coprime moduli, this formula is not directly available; a system can be incompatible or can have a different combined period.

In the numeral (dₖ dₖ₋₁ … d₀)ᵦ, b is the base; dᵢ is the digit in position i; the rightmost position is 0. The subscript b labels the representation, not multiplication by b. A digit's value is dᵢ × bⁱ, and Σ adds those contributions. The most significant digit is the leftmost nonzero one.

numeral (2301)₄      digit     place value     contribution
position 3             2        4³=64           128
position 2             3        4²=16            48
position 1             0        4¹=4              0
position 0             1        4⁰=1              1
                                                 ---
integer represented                              177

You can compute place values explicitly or accumulate from the left. Multiplying the current partial value by b shifts its digits one place left; adding the next digit fills the empty place.

def value_of(digits, base):
    value = 0
    for digit in digits:
        value = value * base + digit
    return value
# digits=[2,3,0,1], base=4:
# 0 → 0*4+2=2 → 2*4+3=11 → 11*4+0=44 → 44*4+1=177

def base_digits(N, base):        # N≥0, integer base≥2
    if N == 0:
        return [0]
    reversed_digits = []
    while N > 0:
        N, remainder = divmod(N, base)
        reversed_digits.append(remainder)
    return reversed_digits[::-1]
# 177 → quotient 44, remainder 1 → quotient 11, remainder 0
#      → quotient  2, remainder 3 → quotient  0, remainder 2
# collected [1,0,3,2]; reversed [2,3,0,1].

The slice [::-1] reads a list backward: the −1 is the step. divmod(N,base) returns the quotient and remainder together, assigned to N and remainder using their old input values.

A bit is one binary digit, 0 or 1. Hexadecimal needs six extra digit symbols: A=10, B=11, C=12, D=13, E=14, F=15. Groups are made from the right, adding leading zeroes if needed; leading zeroes do not change the value.

binary bits:            1 0 1 1 0 1 1 1
hex groups (4 bits):    [1 0 1 1] [0 1 1 1] → B7
                        8+2+1=11   4+2+1=7
octal groups (3 bits): [0 1 0] [1 1 0] [1 1 1] → 267
                          2       6       7
# In Python, int('B7',16)=183 and format(183,'b')='10110111'.

⌊x⌋ (“floor x”) rounds down to an integer; ⌈x⌉ (“ceiling x”) rounds up. For example ⌊2.8⌋=2 and ⌈2.8⌉=3. A width of w bits provides 2ʷ different patterns. The interval of integers 0 through N has N+1 values. If N=7, 3 bits suffice (000 through 111); N=8 needs 4 bits (0000 through 1000). The formula for positive N's own bit length excludes N=0; the numeral 0 is conventionally written with one digit, even though a singleton set needs zero bits of distinguishing information.

Keep three quantities separate: the base a is multiplied repeatedly; the exponent k says how many factors; the modulus n sets the remainder range. Thus 3¹³ mod 7 uses base 3, exponent 13, and modulus 7. Cryptographic keys will assign new names to some of these roles.

def mod_power(a, k, n):      # k≥0, n>0
    result = 1 % n
    a %= n
    while k > 0:
        if k % 2 == 1:      # rightmost exponent bit is 1
            result = result * a % n
        a = a * a % n       # next power: a, a², a⁴, a⁸,...
        k //= 2             # remove rightmost binary digit
    return result

# 13 = (1101)₂ = 8+4+1; process bits from right to left.
# remaining k    current power mod 7   use it?   result after use
#     13                  3              yes           3
#      6                  2              no            3
#      3                  4              yes           5
#      1                  2              yes           3
#      0                  -              stop          3
# Python's built-in pow(3,13,7) performs modular exponentiation.

The result column reduces after each multiplication: 3×4 mod 7=5, then 5×2 mod 7=3. The O(log k) count concerns modular multiplications; it does not claim each multiplication of arbitrarily large integers costs constant bit operations.

The Greek letter φ (“phi”) names the totient function here: φ(n) counts invertible residue classes modulo n. In the product formula, Π (capital pi) means multiply rather than add. The expression Πₚ∣ₙ(1−1/p) uses each distinct prime divisor p of n once, even if p occurs repeatedly in n's factorization. An exponent eᵢ in pᵢ^eᵢ counts repeated copies of that prime.

from math import gcd

def totient(n):            # simple counting version, n>0
    return sum(1 for k in range(1, n + 1) if gcd(k, n) == 1)

# candidate k: 1  2  3  4  5  6  7  8  9 10 11 12
# coprime 12: ✓  ×  ×  ×  ✓  ×  ✓  ×  ×  ×  ✓  ×
# φ(12)=4. Product version: 12*(1-1/2)*(1-1/3)=4.
# Prime 2 appears twice in 12=2²*3, but removes even numbers only once.

The notation p ∤ a reads “p does not divide a.” With prime p this is equivalent to gcd(a,p)=1. The theorem says a block of p−1 factors of a has remainder 1, so full blocks can be removed from an exponent when that condition holds.

# 3**100 modulo 7; p-1=6
q, r = divmod(100, 6)        # q=16, r=4
# factors: [3⁶][3⁶] ... [3⁶] [3⁴]
#             16 blocks        leftover
# mod 7:      1*1*...*1       *  4 = 4
answer = pow(3, r, 7)        # 4
# Do not reduce 7**6's exponent to 0 modulo 6 and claim 1 mod 7;
# base 7 is divisible by p and its positive powers are 0 modulo 7.

Euler replaces prime p by any positive modulus n, provided the base a is coprime to n. The exponent cycle length φ(n) is a valid period, not necessarily the shortest one.

# a=3, n=10, φ(10)=4
# exponent:     0  1  2  3  4  5  6  7  8
# 3**exponent
# modulo 10:    1  3  9  7  1  3  9  7  1
#               |----------|----------|  blocks of length 4
# Thus 3**123 mod 10 = 3**(123 % 4) mod 10 = 7.

shared-secret scheme:
plaintext → encrypt with secret K → ciphertext → decrypt with K → plaintext

public-key encryption:
sender uses recipient's PUBLIC key → ciphertext
recipient uses their PRIVATE key   → plaintext

digital signature (different purpose):
signer uses PRIVATE key → signature; verifier uses PUBLIC key → valid/invalid

Encryption protects confidentiality. A signature establishes authenticity and detects changes; signing is not simply “encrypting the message backward.” Encoding, such as converting letters to numbers, is reversible without a secret. A cryptographic hash is a fixed-length fingerprint, not an encryption format from which the original can ordinarily be recovered.

Let x be a plaintext letter number, y its ciphertext number, and k the secret shift. E names the encryption function; D names decryption. Both results are reduced to the alphabet's residue range.

def shift_letter(letter, k):
    x = ord(letter) - ord('A')
    y = (x + k) % 26
    return chr(ord('A') + y)
# k=3: A B C ... X Y Z
#       D E F ... A B C  (wrap around)
# Encrypt C(2) → F(5); decrypt F with k=-3 → C(2).

ord(letter) gets a character's numeric code; subtracting ord('A') maps A through Z to 0 through 25. chr(...) converts a numeric character code back to a letter. This example accepts uppercase English letters, not arbitrary text.

The two-part key (a,b) first multiplies by a, then adds b. To undo a composition, reverse the order: subtract b first, then multiply by a's modular inverse. Here m is the alphabet size, not a message.

def affine_encrypt(x, a, b, m=26):
    return (a*x + b) % m

def affine_decrypt(y, a, b, m=26):
    return inverse(a, m) * (y - b) % m

# forward: C=2  --multiply 5→ 10 --add 8→ 18=S
# reverse: S=18 --subtract 8→ 10 --multiply 21 mod 26→ 2=C
# 21 is the inverse of 5 modulo 26, since 5*21=4*26+1.

Keep an RSA role card beside the arithmetic. p and q are distinct secret primes; n is their public product; φ(n) counts the invertible residues; e is the public exponent; d is the private inverse of e modulo φ(n); m is the numeric message representative; c is its ciphertext. The same letter m denoted alphabet size in the affine cipher, but here it denotes a message.

secret p,q → n=p*q and φ(n)=(p-1)*(q-1)
                          ↓ choose coprime e, find inverse d
public (n,e):   m -- raise to e mod n → c
private d:     m ← raise to d mod n -- c
# The modulus for MESSAGE arithmetic is n.
# The modulus for finding exponent d is φ(n). Do not exchange them.

p, q = 3, 11                  # deliberately tiny teaching primes
n = p * q                     # 33
phi = (p - 1) * (q - 1)       # 20
e = 3                         # 1<e<20 and gcd(3,20)=1
d = inverse(e, phi)            # 7
# exponent check: e*d=21=1+1*20 → e*d≡1 (mod 20)

m = 4                         # must satisfy 0≤m<n
c = pow(m, e, n)               # 4³ mod 33=31
# message 4 --public exponent 3→ integer 64 --mod 33→ ciphertext 31

recovered = pow(c, d, n)       # 31⁷ mod 33=4
# 31≡-2 (mod 33); (-2)⁷=-128; -128+4*33=4.
# Use pow with a modulus rather than constructing the enormous power.

The exponent product ed means e×d, not a separate function. The inverse relation gives ed = 1 + kφ(n) for an integer k. Raising m to that exponent means one leftover factor m times k blocks of m^φ(n). When gcd(m,n)=1, each block reduces to 1.

m --encrypt→ mᵉ --decrypt→ (mᵉ)ᵈ = mᵉᵈ
                                      = m¹⁺ᵏφ⁽ⁿ⁾
                                      = m * (m^φ(n))^k
                                      ≡ m * 1^k ≡ m (mod n)
# Toy exponent chain: 4³ then seventh power → 4²¹ = 4*(4²⁰).
# Since φ(33)=20 and gcd(4,33)=1, 4²⁰≡1 (mod 33).

Two different mathematical descriptions. A recursive function is executable instructions that call themselves. A recurrence is an equation relating values at different indices; it can describe a function's answer, a population, or a runtime. aₙ (“a sub n”) is the value at index n; aₙ₋₁ is the preceding value, not aₙ minus 1. A closed form, such as aₙ=2ⁿ−1, computes a value directly from its index without needing earlier sequence values. T(n) will instead name work on input size n.

answer sequence:  factorial(n) = n * factorial(n-1)
work sequence:    T(n) = T(n-1) + constant work
# The factorial answer grows as n!, but this procedure makes n calls
# below the initial call and has linear call count.

The base case anchors the definition; the rule alone does not determine a unique sequence. For example aₙ = aₙ₋₁ + 2 gives 0,2,4,… if a₀=0, but 5,7,9,… if a₀=5.

factorial(3)
  waits for factorial(2)
    waits for factorial(1)
      factorial(0) returns 1   ← base case
# Inputs 3→2→1→0 strictly approach the base.
# Calling factorial(n+1) instead would move away from it.

A stack frame remembers a call's local n and the operation still waiting for its child result. A stack is last-in, first-out: the deepest unfinished call must return first.

def f(n):                         # nonnegative integer n
    if n == 0:
        return 0
    child = f(n - 1)
    return n + child

call downward             return upward
f(3): wait for 3 + ?       3 + 3 = 6
 f(2): wait for 2 + ?      2 + 1 = 3
  f(1): wait for 1 + ?     1 + 0 = 1
   f(0): base             0
# f(3) does not return when f(0) returns; it still has additions to do.

“Order” measures the furthest index lag, not the number of terms written. A rule involving aₙ₋₃ is third-order even if it skips aₙ₋₁ and aₙ₋₂. The first-order rule below needs a₀; the second-order example usually needs a₀ and a₁.

a = [0]                          # a₀=0
for n in range(1, 5):
    a.append(3*a[n - 1] + 2)
# index n: 0  1  2  3   4
# aₙ:      0  2  8 26  80
# dependency: a₀ → a₁ → a₂ → a₃ → a₄

In an arithmetic recurrence, d is the fixed difference added each step. In a geometric recurrence, r is the fixed ratio multiplied each step. a₀ is the starting value, so reaching aₙ requires n steps, not n+1.

# arithmetic: start a₀=5, add d=3
# index n:        0   1   2   3
# aₙ=5+3*n:       5   8  11  14
#                 +3  +3  +3
# geometric: start a₀=5, multiply r=2
# aₙ=5*2**n:      5  10  20  40
#                 ×2  ×2  ×2

In aₙ = r aₙ₋₁ + c, r scales the previous value and c is the fixed new addition. The letter c here is not the Big-O bound constant from chapter 12. Every added c is multiplied by r on later steps; an older deposit has more time to grow.

def growth(start, r, c, steps):
    value = start
    for _ in range(steps):
        value = r*value + c
    return value

# Track three steps without hiding the deposits:
# a₁ = r*a₀ + c
# a₂ = r²*a₀ + r*c + c
# a₃ = r³*a₀ + r²*c + r*c + c
#      initial   old deposit  ...  newest deposit
# r=2,c=1,a₀=0: a₃ = 0 + 4 + 2 + 1 = 7.

The underscore _ is a loop variable whose value is deliberately unused; only the number of repetitions matters. The geometric-sum fraction (rⁿ−1)/(r−1) replaces 1+r+…+rⁿ⁻¹; it is not valid when r=1 because that would divide by zero. At r=1 there are simply n copies of c.

Here f(k) names the increment at step k, not necessarily a recursive function. Sum one equation for each step. Every intermediate value appears once positively and once negatively, so only the endpoints remain.

 a₁ - a₀ = f(1)
 a₂ - a₁ = f(2)
 a₃ - a₂ = f(3)
------------------ add vertically
 a₃ - a₀ = f(1)+f(2)+f(3)

# Odd increments build square layers:
# 1²: #       2²: ##       3²: ###
#                ##           ###
#                             ###
# new cells: 1, then 3, then 5. Total after n layers = n².
a = 0
for k in range(1, n + 1):
    a += 2*k - 1            # same as sum(2*k-1 for k in ...)

In aₙ = c₁aₙ₋₁ + c₂aₙ₋₂, c₁ and c₂ are fixed coefficients. “Linear” means the earlier sequence values are multiplied by constants and added, not squared or multiplied together. “Homogeneous” means no extra forcing term such as +7 or +n. Try a geometric component rⁿ: substituting gives rⁿ = c₁rⁿ⁻¹ + c₂rⁿ⁻², which leads to r² = c₁r + c₂. Move everything to the left to obtain the characteristic equation.

# recurrence: aₙ=5*aₙ₋₁ - 6*aₙ₋₂
# coefficient card: c₁=5, c₂=-6
# polynomial: r² - c₁*r - c₂ = r² - 5*r + 6
# factor: (r-2)*(r-3)=0 → allowed ratios r=2 or r=3
# The minus sign before c₂ turns -(-6) into +6.

A root is a value making that polynomial zero. Distinct roots give two different geometric components. The standard repeated-root formulas below assume the nondegenerate second-order setting; if the coefficient of aₙ₋₂ is zero, the rule reduces to lower order and should be treated directly.

A and B are constants chosen to fit the starting values; they are not new sequences. For the example below, each equation comes from a specific index.

general: aₙ = A*2ⁿ + B*3ⁿ
n=0:     a₀=0 → A+B=0
n=1:     a₁=1 → 2A+3B=1
subtract 2*(first equation) from second → B=1, then A=-1.

# index n         0   1   2   3
# 3**n - 2**n     0   1   5  19
# recurrence: next = 5*current - 6*previous
#                         5*1-6*0=5; 5*5-6*1=19

If both roots coincide, writing A rⁿ + B rⁿ would collapse to just one adjustable constant, (A+B). Multiplying the second component by n provides the missing independent shape.

# aₙ=4*aₙ₋₁-4*aₙ₋₂; a₀=1, a₁=4
# characteristic: r²-4r+4=(r-2)², repeated root r=2.
# aₙ=(A+B*n)*2**n
# n=0: 1=A. n=1: 4=(1+B)*2 → B=1.
# index n:       0   1   2   3
# (1+n)*2**n:    1   4  12  32
# check: 4*4-4*1=12; 4*12-4*4=32.

Fₙ is the nth Fibonacci number. The rule adds the two preceding values, so two initial values are supplied. The Greek letters φ (“phi”) and ψ (“psi”) below are the two roots of a quadratic; φ without an argument here means the golden ratio, not the totient function φ(n).

def fibonacci(n):                 # nonnegative integer n
    previous, current = 0, 1
    for _ in range(n):
        previous, current = current, previous + current
    return previous
# n:    0 1 2 3 4 5 6 7  8  9 10
# Fₙ:   0 1 1 2 3 5 8 13 21 34 55
#                          ↖ 21+34=55
# The closed form combines two geometric components φⁿ and ψⁿ.

In the closed form below, √5 is the positive square root of 5; |ψ| is ψ's absolute value, ignoring its negative sign. Since ψ is about −0.618, its magnitude is less than 1 and repeated powers get smaller. Although the formula uses irrational square roots, their combination is exactly an integer. Floating-point code can lose this exactness for large n; the addition-based recurrence avoids that issue. In the Python assignment, both right-hand values are computed from the old pair before either variable changes.

The plus sign separates the work done in recursive children from the local work of the current call. A term Θ(1) is a bounded positive constant amount of local work. Base cases, usually T(1)=Θ(1), stop the expansion.

example code shape                 runtime equation
one call on n-1, one addition      T(n)=T(n-1)+Θ(1)
one call on n-1, loop of n items   T(n)=T(n-1)+Θ(n)
one call on half, one comparison  T(n)=T(n/2)+Θ(1)
two calls on halves, merge n items T(n)=2T(n/2)+Θ(n)

# def count(n):
#     if n == 0: return 0
#     return 1 + count(n-1)
# work per call:   1 → 1 → 1 → 1 → base
# input sizes:     4 → 3 → 2 → 1 → 0
# Add n constant contributions, not n*n.

WORK(n):
    if n == 0: return
    inspect each of n items
    WORK(n-1)
# n=4 local-work rows:
# ****
# ***
# **
# *      total 4+3+2+1=10; triangle growth.

HALVE(n):
    if n <= 1: return
    do one fixed-cost action
    HALVE(floor(n/2))
# n=16 → 8 → 4 → 2 → 1(base)
# Four constant-work non-base calls, not 16.

size at each call         calls at level   work each   level total
n                                 1          n           n
n/2                               2          n/2         n
n/4                               4          n/4         n
...
1                                 n          1           n
# For n=8: level totals 8,8,8,8. Number of levels grows as log₂n.

fib(5)
├─ fib(4)
│  ├─ fib(3)
│  └─ fib(2)   ← computed again below
└─ fib(3)      ← computed again, including its own fib(2)
# Memoization turns repeated subtrees into one stored answer per index.
# Naive call count grows exponentially even though this table-free
# algorithm has only O(n) simultaneous frames on its deepest stack.

Translate the recurrence before selecting a case. In T(n)=aT(n/b)+f(n), a counts recursive children, b is the factor shrinking each child's input, and f(n) is the total local work at that call. Neither a nor b may grow with n. The comparison n^(log_b a) estimates the number of leaf calls. “Polynomially smaller” means smaller by a factor of n^ε for some fixed ε>0, not merely by a logarithm.

# Example: T(n)=4*T(n/2)+n, with n=8
level   calls    size per call   local work total
  0       1            8               8
  1       4            4              16
  2      16            2              32
  3      64            1              64
# Work grows toward the leaves.
# log_b(a)=log₂4=2 → leaf count n² → Θ(n²).

For the larger-local-work case, the usual regularity requirement is a f(n/b) ≤ c f(n) for some fixed c<1 beyond a threshold. It ensures successive levels really get cheaper. With f(n)=n², a=2, b=2, the child-level total is 2*(n/2)²=n²/2, so c=1/2 works. If f(n) differs from the leaf term by only a log factor, or regularity is unknown, this simplified three-case statement may not apply; unroll the recurrence rather than forcing a case.

recognition guide:
smaller local work: levels  n → 2n → 4n ... → n²   leaves dominate
matching work:      levels n → n → n ...          add log n levels
larger local work:  levels n² → n²/2 → n²/4 ...   top dominates
# These sketches illustrate appropriate recurrences, not one equation.

P(n) names a proposition about integer n, such as “the first n positive integers sum to n(n+1)/2.” n₀ is the first index covered; k is an arbitrary index at least n₀. P(k) ⇒ P(k+1) reads “if the claim holds at k, then it holds at the next index.” An arrow is a logical implication, not numerical addition.

base proven          step works for EVERY allowable k
P(n₀)  ─────────→  P(n₀+1) ─────────→ P(n₀+2) ─────────→ ...
   ↑
one starting domino   the same argument links each neighbor

# Proof recipe (not an executable finite test):
# 1. Prove P(n₀).
# 2. Choose arbitrary k≥n₀ and assume P(k).
# 3. Derive P(k+1) using that assumption.
# 4. Conclude P(n) for every integer n≥n₀.

A loop checking P(n) for the first thousand values is evidence, not induction. Induction succeeds because the step is valid for an arbitrary k, including indices beyond any finite check.

claim P(n):  sum of 1..n = n*(n+1)/2
base n=1:    1 = 1*2/2
hypothesis:  1+...+k = k*(k+1)/2
next case:
  1+...+k+(k+1)
= k*(k+1)/2 + (k+1)       replace ONLY the old sum
= (k+1)*(k/2+1)           factor (k+1)
= (k+1)*(k+2)/2           desired formula with n replaced by k+1

# Code correspondence: extending a running total by one term.
total_next = total_through_k + (k + 1)
# Hypothesis supplies total_through_k, not total_next.

In d ∣ f(n), d is the fixed proposed divisor and f(n) is an integer expression. To use the hypothesis, turn divisibility into an equality with an integer multiplier m. This m is a witness, not necessarily a constant independent of k.

claim: 6 divides 7ⁿ−1, for integer n≥1
hypothesis: 7ᵏ−1 = 6*m for some integer m
next expression: 7ᵏ⁺¹−1
               = 7*(7ᵏ−1)+6
               = 7*(6*m)+6
               = 6*(7*m+1)
# New witness = 7*m+1, still an integer.
# If k=1, m=1; k=2 gives witness 8 and 7²−1=6*8=48.
# Computational view: remainder stays zero under this update.

Write the target for k+1 before manipulating the hypothesis. For n! > 2ⁿ, the next target is (k+1)! > 2^(k+1), not a statement involving k alone. A positive multiplier preserves the direction of an inequality; a negative multiplier reverses it.

k! > 2ᵏ                    hypothesis
(k+1)*k! > (k+1)*2ᵏ       multiply by positive k+1
(k+1)*2ᵏ > 2*2ᵏ           because k+1>2
therefore (k+1)! > 2ᵏ⁺¹

# ratio picture: factorial gains a factor k+1;
#                powers of two gain only a factor 2.
# Once ahead at n=4, factorial stays ahead under each next step.

Ordinary induction gives one earlier case P(k); strong induction permits all earlier cases P(n₀) through P(k). It still requires a base case and may require several bases if the step needs several prior values.

PROVE_FACTORABLE(n):             # describes proof structure
    if n is prime: use n itself
    otherwise write n=a*b with 2≤a,b<n
    use already-established claims for a and b
    concatenate their prime factorizations

84
├─ 7    → prime
└─ 12
   ├─ 3 → prime
   └─ 4
      ├─ 2 → prime
      └─ 2 → prime
# Every child is smaller than its parent, but not necessarily one smaller.

The induction variable is the way an object was built. First list every permitted constructor; then prove the property survives each constructor. For balanced-parenthesis strings, ε (“epsilon”) is the empty string, wrapping adds ( and ), and concatenation joins two strings without adding a separator.

constructors: EMPTY | WRAP(s) | JOIN(s,t)

EMPTY           produces ε, with counts (left,right)=(0,0)
WRAP(EMPTY)     produces (), with counts (1,1)
JOIN((),())     produces ()(), with counts (2,2)
WRAP(()())      produces (()()), with counts (3,3)

# Property expressed as code over a constructed string s:
# s.count('(') == s.count(')')
# Proof: EMPTY establishes equality; WRAP adds one to each side;
# JOIN adds equal pairs of counts, keeping the totals equal.

Equal counts alone do not characterize balanced parentheses: )( has equal counts but cannot be built by these rules. The claim is that every generated string has equal counts, not that every equal-count string is generated.

Suppose you have three people, A, B and C. “Choose two people” is incomplete: choosing a chair and a secretary gives six outcomes, but choosing a committee gives three. Counting starts by defining when two outcomes are different, not by looking for numbers to put in a formula.

Notation used throughout this chapter: n usually counts available objects, r counts selected objects, and k often counts categories or a specified number of successes. A subscript labels an item: n₂ means “the number for stage 2,” not n squared. Superscripts such as 2⁵ are powers: multiply five copies of 2. Juxtaposition means multiplication, so nr means n times r. A factorial, n!, multiplies the positive integers from 1 through n; by definition, 0! = 1. Vertical bars around a set, |A|, mean its number of elements. Braces { } describe a set; parentheses (A,B) can describe an ordered pair. The snippets below use Python-like pseudocode; “append,” “add,” and “return” show the counting process, not a requirement to run software. In these snippets, = stores a value, == compares two values, != means “not equal,” and += adds to a stored value. len counts a collection’s entries, and sum adds numerical entries. A loop written “1 through n” includes both endpoints; it has no iterations when the upper endpoint is below the lower one. An example computed for one small input illustrates a general rule; it does not by itself prove the rule for every input.

factorial(n):
    total = 1
    for value in 1 through n:
        total = total * value
    return total

# 4! = 1 * 2 * 3 * 4 = 24; 0! uses no loop, so returns 1

m and n are the sizes of two separate lists. Disjoint means no outcome occurs in both. Add the lengths when choosing exactly one item from either list. You are joining alternatives, not pairing every item in one list with every item in the other.

math = [M1, M2, M3, M4, M5]
art = [A1, A2, A3]
choices = math + art       # join the lists
count = len(choices)       # 5 + 3 = 8

Here k is the number of stages, and n_i is the number of choices at stage i. The dots in n₁n₂⋯n_k mean “continue multiplying through the last stage.” Two shirts and three trousers make six outfits because each shirt has three extensions.

outfits = []
for shirt in [A, B]:
    for trousers in [1, 2, 3]:
        outfits.append((shirt, trousers))
# A1 A2 A3 B1 B2 B3

shirt A ── trousers 1, 2, 3 ── 3 leaves
shirt B ── trousers 1, 2, 3 ── 3 leaves
                               6 outfits

A bijection is a reversible pairing: every object on the left has exactly one partner on the right, with nobody left over. A bit is a 0-or-1 position. For subsets, write 1 when the corresponding item is included and 0 when it is excluded. There are two independent choices per position.

items = [1, 2, 3]
encode(subset): return [1 if x in subset else 0 for x in items]
decode(bits):  return {items[i] for i in positions if bits[i] == 1}
# decode(encode(subset)) gives the original subset

If your list has M entries but each real outcome appears d times, the true count is M/d. The “exactly” matters: division by a common number is justified only when every outcome has that many representations. For two-person committees, the two orders of each pair create a duplication factor of 2! = 2.

ordered = [AB, BA, AC, CA, BC, CB]
committee_count = len(ordered) / factorial(2)   # 6 / 2 = 3

P(n,r) reads “permutations of n objects taken r at a time.” Here 0 ≤ r ≤ n; objects are distinct and cannot be reused. Filling ordered positions leaves one fewer choice each time. The denominator (n−r)! cancels the unused tail of n!. A fraction bar means division; n!/(n−r)! is not n! divided by (n−r) followed by another factorial.

permutations_count(n, r):
    count = 1
    for filled in 0 through r-1:
        count = count * (n - filled)
    return count
# n=4, r=2: first role 4 choices, second role 3; count=12

The stacked notation n choose r, also written C(n,r) or choose(n,r), counts unordered subsets of size r. It is not the fraction n/r. First count ordered selections, then divide by r!, the number of orders of each selected group. The symbol = says both expressions have the same value.

choose(n, r) = factorial(n) / (factorial(r) * factorial(n-r))
# Choose 2 of A,B,C,D: 4! / (2! * 2!) = 6
committees = [{A,B}, {A,C}, {A,D}, {B,C}, {B,D}, {C,D}]

Each chosen subset has one complementary excluded subset. That pairing explains C(n,r) = C(n,n−r). The table shows three such pairs; reversing the two columns gives the other three size-two choices.

Read the following table as four different experiments using the same n available types and r selections. “Repetition” means the same type may be selected again; it does not mean counting the same outcome twice. For a small concrete comparison, choose two letters from {A,B,C}.

for first in [A,B,C]:
    for second in [A,B,C]:
        if no_reuse and first == second: continue
        outcome = (first, second) if ordered else sorted_pair(first, second)
        distinct_outcomes.add(outcome)

Now all n objects are arranged, but some copies are indistinguishable. n_i is the number of copies of category i; k is the number of categories. A multinomial coefficient is the many-category version of a binomial coefficient. The counts must add to n, because every position receives exactly one object.

distinct_orders = factorial(3) / (factorial(2) * factorial(1))
# AAB: six labeled orders collapse to three visible words.
# BANANA: counts A=3, N=2, B=1; 6!/(3!*2!*1!) = 60

A circle has no distinguished first seat in this model. Rotating everybody together produces the same arrangement, but reversing clockwise order usually does not. Fix one named person as an anchor, then arrange the remaining n−1 people. If seats are numbered, rotations are different and the answer returns to n!.

anchor = A
for order in permutations([B,C,D]):
    circle = [anchor] + order
# 3! = 6. Do not divide by 2 unless reflection is also equivalent.

The complement is everything in your chosen universe that fails your condition. |desired| means the number of desired outcomes, not an absolute value of a number here. The desired and undesired groups do not overlap and together exhaust the universe. Count a hard event by subtracting its easier opposite.

total_pins = 10**4                 # ** means exponentiation
all_distinct = 10 * 9 * 8 * 7
repeated_digit = total_pins - all_distinct   # 4960

Leading 0 is allowed in a PIN. It would not normally be allowed in a four-digit integer; changing the universe changes the count.

Here n is the total being distributed and k is the number of labeled recipients. Each variable x_i is the integer share for recipient i. “Nonnegative” means 0 is allowed. Identical items and no capacity limits are essential. The k−1 bars divide the stars into k possibly empty runs. Of n+k−1 total positions, choose the positions for the bars; the stars fill the rest.

ways = 0
for x1 in 0 through 5:
    for x2 in 0 through 5-x1:
        x3 = 5 - x1 - x2
        ways = ways + 1
# 21 solutions, matching choose(5+3-1, 3-1).

The inequality x_i ≥ L_i means share i must be at least its lower bound L_i. Set y_i = x_i−L_i; then the new variables count only the extra items after the minimum shares have been supplied. Their total is n−(L₁+⋯+L_k). If that is negative, there are zero solutions. For positive shares, all lower bounds are 1 and n must be at least k.

A multiset records how many of each type you choose; it ignores selection order but preserves multiplicity. In this section n counts types and r counts chosen items. This reverses the roles of the total and category letters used in the preceding section: the method is the same, but always read each variable’s definition locally.

cup = {V:2, C:1, S:0, M:0}
# 3 stars + 3 bars = 6 positions. Choose 3 star positions.
possible_cups = choose(4 + 3 - 1, 3)   # 20

The “pigeons” can be people, files or strings; the “holes” are categories. N is the number of objects and k the number of categories, with k positive. The ceiling symbols ⌈ ⌉ mean round up to the next integer: ⌈13/12⌉ = 2. This is a guarantee about some category, not every category.

guaranteed_maximum_at_least = ceil(N / k)
# To avoid r in any one box, each box can hold at most r-1.
maximum_without_r = k * (r-1)
first_forced_total = maximum_without_r + 1

Three boxes; avoid having 3 in one box:
box A: **    box B: **    box C: **     total 6, still possible
next object must join one of those boxes: total 7 forces a group of 3.

A ∪ B (“A union B”) contains objects in A or B, including both. A ∩ B (“A intersection B”) contains objects in both. |A| is the count of A. Adding the separate counts counts a shared object twice, so subtract the overlap once. With three sets, objects in all three were added three times then subtracted three times, leaving zero; add the triple overlap once to restore their intended count of one.

A = {x for x in 1 through 100 if x % 2 == 0}
B = {x for x in 1 through 100 if x % 5 == 0}
at_least_one = len(A) + len(B) - len(A.intersection(B))
neither = 100 - at_least_one       # 40; % means remainder

A binomial has two terms, such as x+y. The exponent n is a nonnegative integer number of identical factors. The summation sign ∑ means add one term for every integer k from the lower limit 0 to the upper limit n. In each term, k factors supply y, and the other n−k supply x. A coefficient tells how many selection patterns produce the same powers.

expanded = 0
for k in 0 through n:
    expanded += choose(n,k) * x**(n-k) * y**k
# n=3: x**3 + 3*x**2*y + 3*x*y**2 + y**3

In Pascal’s identity, designate one of the n objects. A size-k subset either includes it (choose k−1 others from n−1) or excludes it (choose all k from n−1). These disjoint cases explain the addition. For endpoint cases, use C(n,0) = C(n,n) = 1; combinations outside the allowed size range count as 0.

A bit string has ordered positions, each holding 0 or 1. In these formulas n is its length, k the requested number of 1s, and i the running count of 1s in a sum. “Exactly k” chooses which positions hold 1. “At most k” adds the disjoint cases 0,1,…,k. “At least one” excludes just the all-zero string. Assume 0 ≤ k ≤ n.

total = 2**n
exactly_k = choose(n,k)
at_most_k = sum(choose(n,i) for i in 0 through k)
at_least_one = 2**n - 1

# No adjacent 1s: a[n] counts valid length-n strings.
a[0] = 1    # the empty string
a[1] = 2    # 0, 1
for n in 2 through target:
    a[n] = a[n-1] + a[n-2]

Valid length 3, separated by final construction:
append 0 to valid length 2: 00→000, 01→010, 10→100
append 01 to valid length 1: 0→001, 1→101
Total: 3 + 2 = 5. No string appears in both groups.

If designated objects must be consecutive, compress them into a temporary single object. Count outer placements, then inner orders. Multiplication applies because every outer placement permits the same inner arrangements. “Together in any order” differs from “in the fixed order ABC.”

outer = factorial(3)   # [block], D, E
inner = factorial(3)   # A,B,C within the block
answer = outer * inner # 36
# If the block must read ABC, inner = 1 instead.

[ABC] D E ── expand block ── ABCDE, ACBDE, BACDE, BCADE, CABDE, CBADE
D [ABC] E ── another outer arrangement, with the same 6 inner choices

Place the objects allowed to touch each other first. They create one gap at each end and one between each neighboring pair, so four placed people create five gaps. Putting at most one restricted person in each selected gap enforces nonadjacency. The people in the example are all distinct; if only category patterns matter, the person-order factorials would not be present.

girls_order = factorial(4)
boy_positions_and_order = choose(5,3) * factorial(3)
total = girls_order * boy_positions_and_order  # 24 * 10 * 6 = 1440

gaps:    _ G1 _ G2 _ G3 _ G4 _
choose:  B G1 _ G2 B G3 _ G4 B
Distinct gaps separate every pair of boys.

Think dictionary order using a fixed ordering of the symbols. Compare the leftmost position where two sequences differ; whichever has the smaller symbol comes first. If one sequence is a proper prefix of the other, the shorter comes first. Generating the next arrangement means making the smallest possible increase, then making the rest as small as possible.

lex_less(a,b):
    for i in shared_positions(a,b):
        if a[i] != b[i]: return a[i] < b[i]
    return len(a) < len(b)

In the steps below, a_i is the entry at position i; use positions numbered from 1. “Largest i” means the rightmost suitable position, not the largest entry. The suffix is everything to its right. A decreasing suffix is already at its last possible order, so the next increase must change the entry immediately before it.

next_permutation(a):
    i = rightmost position with a[i] < a[i+1]
    if no such i: return NONE    # already last
    j = rightmost position with a[j] > a[i]
    swap(a[i], a[j])
    reverse(a[i+1 ... end])
    return a

Represent an unordered combination by an increasing list, so every subset has one representation. With positions 1 through r, the largest possible entry at position i is n−r+i: enough larger values must remain for the later positions. Increase the rightmost entry that is below its bound, then pack its successors tightly.

next_combination(a, n, r):
    i = rightmost position where a[i] < n-r+i
    if no such i: return NONE
    a[i] += 1
    for j in i+1 through r:
        a[j] = a[j-1] + 1
    return a