Mathematical language, numbers, and functions

Imagine an application that scores the first four results of a search. One developer starts counting at zero; another starts at one. One returns a total; another returns an average. Both implementations run, and both produce numbers, but they answer different questions. Before deciding which is correct, we need a precise description of the intended computation.

Mathematical notation gives us that description. It names the objects involved, says which inputs are allowed, and describes the relationship between an input and its result. A formula becomes useful when you can read those commitments. Recognising a symbol without understanding its role is insufficient: the meaning of a sum changes when its bounds change, and the meaning of a function changes when its domain changes.

Our running task is deliberately small. Given a nonnegative integer $n$, add the first $n$ positive odd integers. For $n=4$, the terms are $1,3,5,7$ and the result is $16$. For $n=0$, there are no terms and the result is $0$. We will express this task as a formula, translate its indices into Python, and distinguish a few successful executions from a statement about every valid input.

Along the way, keep three questions beside each expression: What kind of object is this? Which values are permitted? What must the result mean? The same questions will later help you read a loss function, a probability model, a matrix transformation, or an algorithm’s cost. This module establishes the language; later modules develop proofs and the more specialised mathematics.

Before the labs, use the Python primer. If school algebra feels uncertain, try the entry diagnostic and the optional refresher. Neither resource is a gate: use it to identify what needs practice.

A mathematical object is something we can describe and reason about: a number, an ordered pair, a set, a function, or a sequence. The operations that make sense depend on the object. You can add two real numbers, but a library catalogue and a temperature are different kinds of objects. A programming language may allow many representations; the mathematical description supplies the meaning.

A definition gives a term its intended meaning. In this series, we define the natural numbers to include zero: $\mathbb{N}=\{0,1,2,\ldots\}$. A different book may reserve that symbol for $\{1,2,\ldots\}$. Neither convention is universally compulsory; declare the convention before using it. We write $\mathbb{N}_{>0}$ when we specifically require a positive integer. The distinction matters when zero means an empty input, an initial counter, or an invalid count.

An assumption specifies the setting in which an argument or calculation applies. “Let $n\in\mathbb{N}$” permits zero and excludes $2.5$. A claim is a statement to examine, such as “the sum of the first $n$ odd integers is $n^2$.” That claim concerns every permitted $n$; defining the sum does not make the claim true automatically. A theorem is a claim established by a proof from stated assumptions and accepted rules. Module 04 will develop proof methods systematically.

The main number systems form a useful hierarchy. The integers $\mathbb{Z}$ add negative whole numbers. The rationals $\mathbb{Q}$ contain fractions $p/q$ with integers $p,q$ and $q\ne0$. The reals $\mathbb{R}$ also contain irrational quantities such as $\sqrt{2}$. A decimal representation is a way to write a number, not a new number system: $0.5=1/2$ is rational, whereas the infinite decimal expansion of $\sqrt{2}$ does not terminate or repeat.

Membership and containment use different symbols. The statement $3\in\mathbb{N}$ says that one object belongs to a set. The statement $\mathbb{N}\subseteq\mathbb{Z}$ says that every element of the first set also belongs to the second. We need this small amount of set language to declare domains; Module 03 will study set operations in depth.

The complex numbers have the form $a+b\mathrm{i}$, where $a,b\in\mathbb{R}$ and $\mathrm{i}^2=-1$. This is a preview, not a prerequisite for the module’s labs. A real number is the special case with $b=0$. Complex numbers will matter in spectral and Fourier methods; for now, our calculations use real numbers and integer indices.

When a formula uses a letter, declare its role rather than guessing from the shape of the letter. A variable may range over permitted values; a parameter is held fixed while a particular operation is studied; a constant has a specified value in the current setting. These roles are contextual. In $f_a(x)=ax+1$, we may treat $a$ as a parameter and $x$ as the input. Later, fitting $a$ from data makes it the quantity we vary.

The symbol $=$ asserts that two expressions denote the same value. It is symmetric: if $a=b$, then $b=a$. It does not mean “do the next step” or “store a new value.” The symbol $\ne$ asserts inequality. The relations $<$ and $\le$ compare ordered real values; $x\le3$ includes the boundary $3$, while $x<3$ excludes it. Read a chain such as $0\le x<1$ as two simultaneous conditions.

In mathematics, $x=x+1$ has no real solution: subtracting $x$ would give $0=1$. In Python, x = x + 1 evaluates the expression on the right using the current value and assigns the result to the name on the left. Python uses == for an equality comparison. A mathematical text may use $x:=3$ or “define $x$ to be 3” to distinguish a definition from an equation to solve. These notational differences express different operations.

Order of operations is another part of meaning. Exponentiation is evaluated before a leading minus in the conventional expression $-3^2=-(3^2)=-9$. Parentheses change the base: $(-3)^2=9$. A fraction bar groups its numerator and denominator; writing $1/(x-2)$ in code preserves that grouping. The code 1/x-2 represents a different expression. When translating a formula, add parentheses for clarity even if the language’s precedence would give the same answer.

An interval specifies a range of real inputs. Square brackets include an endpoint; round brackets exclude it. Thus $[0,1]$ includes both boundaries, $(0,1)$ includes neither, and $[0,1)$ includes only zero. Infinity is not a real endpoint that can be included, so we use $(0,\infty)$ for positive real numbers. An interval such as $[0,4]$ is not the same as the five-element set $\{0,1,2,3,4\}$: the interval also contains $1/2$ and $\sqrt{2}$.

Absolute value measures distance from zero: $|x|=x$ when $x\ge0$ and $|x|=-x$ when $x<0$. It is always nonnegative. This is why $|-3|=3$, rather than $-3$. A condition $|x|<2$ means that $x$ lies less than two units from zero, equivalently $-2<x<2$. This way of writing a distance will later appear in approximation errors and tolerances.

Subscripts label components or terms. For a sequence $a_0,a_1,a_2$, the symbol $a_2$ denotes the term labelled two; it is not the product $a\cdot2$ and is not the square $a^2$. Superscripts often mean powers, but their meaning is also declared by context: a later text may write $x^{(t)}$ for an iterate. Parentheses and explanations prevent the two meanings from being confused.

Our odd-number task uses $a_i=2i+1$ for integer indices $i=0,1,\ldots,n-1$. With $n=4$, the indices are $0,1,2,3$ and the terms are $1,3,5,7$. There are four terms even though the final index is three. Starting at $i=1$ without changing the formula would start at $3$ and describe a different sequence.

The notation $\sum_{i=0}^{3}(2i+1)$ means “substitute each permitted integer index, then add the terms.” It expands to $(2\cdot0+1)+(2\cdot1+1)+(2\cdot2+1)+(2\cdot3+1)=16$. The large Greek sigma is an aggregation instruction. Section 5 will examine its scope and nested forms; you already know enough to trace Lab 1.

Distinguish exact equality from approximation. Writing $\sqrt{2}\approx1.414$ acknowledges a difference. A displayed decimal rounded to three places is not evidence that the underlying values are exactly equal. The labs use integer arithmetic for exact sums and explicit tolerances where floating-point calculations are involved. Module 29 will explain how to choose numerical comparisons in more demanding calculations.

A function assigns exactly one output to each input in its declared domain. We write $f:D\to C$ to name its domain $D$ and codomain $C$. Every output must belong to $C$, but not every element of $C$ needs to be produced. The set of outputs that are actually produced is the image $f(D)=\{f(x):x\in D\}$. This distinction affects whether an inverse exists and whether a proposed output can ever occur.

A formula is one way to describe a function. It is not the whole specification: the same expression with different domains can describe different functions. The rule $f(x)=x^2$ on all real inputs has image $[0,\infty)$. On the domain $\{0,1,2\}$ it has image $\{0,1,4\}$. In both cases, we could choose $\mathbb{R}$ as the codomain, but the unused values in that codomain are not outputs of the function.

Domain restrictions may come from an expression or from the problem. The reciprocal $r(x)=1/(x-2)$ cannot accept $x=2$ as a real input because division by zero is undefined. A real square-root function requires a nonnegative argument. A count-based function may exclude negative inputs even when its algebraic formula could be evaluated there. Declare the restriction that belongs to the problem before relying on a formula’s mechanical evaluability.

A function can also be piecewise. For example,

The conditions select the applicable rule. They must assign one result to every input in the domain. Here every real number belongs to exactly one branch, including the boundary $x=0$. Overlapping branches with inconsistent values would fail to define a function; a missing branch would leave part of a proposed domain uncovered.

Composition means applying one function to the output of another. The notation $(f\circ g)(x)=f(g(x))$ places the outer function on the left, but evaluation begins with $g$. An input is valid only when it belongs to the domain of $g$ and the intermediate output belongs to the domain of $f$. If all outputs of $g$ lie in $f$’s domain, the composition is defined on all of $g$’s domain. Otherwise, restrict the composition to the inputs that satisfy both checks.

Suppose instead that $f(t)=\ln(t-1)$ and $g(x)=x^2$. The outer rule requires $t>1$, so the composition requires $x^2>1$, or $x<-1$ or $x>1$. Although the inner square accepts zero, the composition does not. Checking only the original input against the inner domain misses the failure at the intermediate value.

An inverse function reverses a mapping uniquely. The inverse of $f(x)=2x+1$ on $\mathbb{R}$ is $f^{-1}(y)=(y-1)/2$: substituting it in either direction restores the original value. The notation $f^{-1}$ denotes the inverse mapping, not the reciprocal $1/f$. A square on all real inputs has no inverse function to recover the input: $2$ and $-2$ both produce $4$. Restricting both the square’s domain and codomain to $[0,\infty)$ gives the inverse $\sqrt{y}$.

Do not infer that an implementation is a mathematical function of its displayed argument alone. A procedure that reads a clock, a mutable global variable, or a random generator may return different results on repeated calls with the same explicit input. Include the additional state in the model when you need a deterministic mapping. Later probability modules will model random outputs directly.

Powers describe repeated multiplication when the exponent is a positive integer. Thus $a^3=aaa$. For a nonzero base, the zero power is $a^0=1$ and a negative integer power is $a^{-k}=1/a^k$. The restriction on the base matters: a negative power of zero would require division by zero. Expressions such as $0^0$ have context-specific conventions; this module does not assign them a general real-valued interpretation.

Within their valid domains, powers obey $a^r a^s=a^{r+s}$ and $(a^r)^s=a^{rs}$. For positive real bases these rules extend naturally to real exponents. When a base is negative and an exponent is non-integer, the real-domain question becomes more delicate: $(-1)^{1/2}$ is not real. Do not apply a positive-base identity to every possible expression merely because the symbols look similar.

Exponential functions fix the base and vary the exponent. In $2^x$, $x$ is the input. This differs from the power function $x^2$, whose base varies and whose exponent is fixed. At $x=2$ both yield $4$, but at $x=3$ they yield $8$ and $9$, and at $x=4$ both again yield $16$. A few coincidences do not make the functions identical. The plot in Lab 2 lets you compare them on a declared interval; their eventual growth is studied more carefully in Module 06.

A logarithm asks which exponent would produce a positive value. For a real base $a>0$ with $a\ne1$, $\log_a x=y$ means $a^y=x$, with $x>0$. The function is the inverse of $a^x$ on the corresponding real domain and positive codomain. The natural logarithm $\ln x$ uses the base $e$, a positive irrational constant approximately $2.71828$. In this series, an unqualified mathematical $\log$ means the natural logarithm unless a different base is stated.

The domains are part of these identities. For any real $y$, $\ln(e^y)=y$. For positive $x$, $e^{\ln x}=x$. The second expression is undefined as a real calculation at $x=0$ or at a negative input. A calculator error there is not a random software inconvenience: it reflects the domain of the specified real function.

For positive real $u,v$, logarithms convert multiplication into addition:

The multiplication identity follows from the exponential rule: writing $u=e^r$ and $v=e^s$ gives $uv=e^{r+s}$, so its natural logarithm is $r+s$. The arguments and the quotient must remain in the valid domain. A corresponding real-power identity is $\ln(u^r)=r\ln u$ for $u>0$. These relationships will later turn products of independent probabilities into sums of log-likelihoods.

There is no corresponding general identity for addition. At $u=v=1$, $\ln(u+v)=\ln2$ is positive, while $\ln u+\ln v=0$. One valid counterexample disproves a claimed identity over all positive inputs. It does not establish a replacement formula; the product identity needs its own explanation.

Growth comparisons need an input range and a purpose. Multiplying $\ln n$ by the positive constant $1/\ln2$ changes its numeric values but not its broad growth pattern as $n$ increases. In a coding or information calculation, the base still matters because the units change: base-two logarithms express bits, while natural logarithms express nats. We will return to these units in information theory.

A graph is evidence about its displayed window, not a proof about all positive inputs. An exponential can appear smaller than a polynomial over a limited range and later grow faster. Also check the axes: a logarithmic axis changes the spacing of plotted values. Lab 2 uses shared ordinary axes so you can inspect the values directly. A curve leaving the visible rectangle has not ceased to exist.

A finite sum combines terms over a declared index range. The summation symbol binds the index inside its expression: in $\sum_{i=1}^n a_i$, the letter $i$ takes each integer value from one through $n$, while $n$ remains a parameter controlling the range. An occurrence of a letter outside that binding has its own meaning. This is the mathematical counterpart of a loop variable with a specified scope.

To read a sum reliably, identify four pieces: the index name, its start, its end, and the term being evaluated. Then expand a small case before trying to simplify. For example,

This expression contains four terms. Neither the index nor the term is multiplied by the upper bound as a shortcut. Replacing the sum with $4(4+2)=24$ would incorrectly use the final term four times.

The index is a bound or dummy variable. Renaming it consistently does not change the sum: $\sum_{i=1}^4 i^2=\sum_{j=1}^4 j^2$. But a rename must not capture a variable already doing another job. In $\sum_{i=1}^n(x+i)$, $x$ is free and $i$ is bound. Renaming the bound index to $x$ without changing the original free variable would silently alter the expression. Choose distinct names, just as you would avoid overwriting a parameter in code.

Finite sums can be rearranged and distributed using ordinary addition. For constant $c$,

Expand both sides to see each term appear once. This is a property of the addition and multiplication used here; it is not evidence that every function satisfies $f(a+b)=f(a)+f(b)$. Infinite sums require further convergence conditions before similar rearrangements are justified. The present section concerns finite sums only.

The empty sum is zero. This convention means that adding no contributions leaves an accumulated total unchanged. In our task, $n=0$ makes the range from zero to $n-1$ empty. There is no final term with a negative index to evaluate. The result is defined by the aggregation rule, not by pretending that a nonexistent term has the value zero.

A finite product uses $\prod$ instead of $\sum$. For example, $\prod_{i=1}^4 i=1\cdot2\cdot3\cdot4=24$. The empty product is one, because multiplying by no factors leaves a product unchanged. Setting it to zero would make every ordinary product vanish whenever it was split into a nonempty part and an empty part. These two identity values explain Python’s sum([]) and math.prod([]) results.

A double sum has two aggregation instructions. In

fix the outer index $i$, complete the inner sum over $j$, and then add the inner results. At $i=1$, the terms are $11,12,13$ and total $36$. At $i=2$, they are $21,22,23$ and total $66$. The whole sum is $102$. There are six terms because each of two outer values has three inner values.

Because this range is a finite rectangle, summing columns first gives the same result: $(11+21)+(12+22)+(13+23)=32+34+36=102$. A nonrectangular range needs more care. In $\sum_{i=1}^3\sum_{j=1}^i j$, the inner upper bound depends on $i$. The rows contain $1$, then $1,2$, then $1,2,3$, for a total $10$. Simply switching the two written summation symbols without translating the valid index pairs changes the range.

The variable remaining after a sum tells you what kind of output it defines. In $s(x)=\sum_{i=1}^3(x+i)$, the bound index disappears after aggregation, but $x$ remains as the function input. Expanding gives $s(x)=3x+6$. In $t_j=\sum_{i=1}^2 a_{ij}$, $j$ remains free and labels which column total is being described. These distinctions will prevent shape and axis mistakes when arrays appear in Module 09.

To translate the rectangular double sum, use range(1, 3) for the outer indices and range(1, 4) for the inner ones. To translate the triangular example, use range(1, 4) outside and range(1, i + 1) inside. Check a tiny example and an empty range before trying a large input. A large, plausible result does not expose which indices were omitted.

A mathematical contract states what inputs are allowed and what relationship the result must satisfy. For the odd-number task, an input is a nonnegative integer $n$. The output is the integer total

with the empty sum interpreted as zero. The input is not modified. Negative counts, fractional counts, and a request to average rather than total the terms are outside this specification. A separate software policy determines how invalid inputs are handled; the labs raise a clear ValueError.

Break the translation into explicit decisions. The mathematical count $n$ becomes a Python integer. The inclusive range ending at $n-1$ becomes range(n). Each term becomes 2 * i + 1; multiplication needs its own operator in code. The total starts at zero and receives one term per iteration. This describes the computation more faithfully than copying symbols into a language that interprets them differently.

The formula defining $S$ and the claim $S(n)=n^2$ have different roles. The definition tells us what to compute. The identity claims that an apparently different expression gives the same value for every valid $n$. A test at $n=4$ confirms one case. To establish the general identity, one can use induction in Module 04 or an algebraic finite-sum argument like the optional exercise at the end of this module.

Disproving a universal claim is often cheaper than proving one. To refute “every real function is additive,” choose $f(x)=x^2$, $a=2$, and $b=3$. Then $f(a+b)=25$ but $f(a)+f(b)=13$. Both inputs and all intermediate values lie in the declared domain, so the counterexample is valid. A supposed counterexample using an undefined logarithm would not be valid evidence about an identity stated only for positive arguments.

Distinguish three possible faults. A specification fault means the formula describes the wrong task: an average where a total was required. A translation fault means the program implements the wrong expression: range(1, n) where range(n) was required. A numerical fault means the machine arithmetic does not sufficiently approximate the intended calculation: an overflowing exponential or an unsuitable equality check. Different faults require different repairs.

When an AI paper writes an objective such as $L(\theta)=\frac1n\sum_{i=1}^n\ell_i(\theta)$, these basic skills still apply. The parameter $\theta$ is free; $i$ is bound; $n$ is a positive count because division by zero would make the average undefined; and changing a sum to a mean changes its scale. You do not yet need to know how to minimise the objective to read its declared relationship. Differentiation and optimisation will supply those later steps.

Do not add a case to a formula silently. If the task later needs $n=0$ to return “no score” rather than zero, update the contract and its tests. If a function must accept an array instead of a scalar, state its new input and output shapes. Mathematical precision is useful precisely because it makes these choices visible enough to discuss and verify.

Read the Python primer if any notation in the scripts is unfamiliar. Download each script into a folder you can find, open a terminal in that folder, and run python lab1_sums.py, python lab2_functions.py, or python lab3_diagnose.py. On Windows, py may be the appropriate command; on macOS/Linux it is often python3. Check that the selected interpreter is Python 3.11 or later. These scripts use only the standard library.

Each block below is the complete distributed script followed by output captured by the page builder. Read the questions and predict the important numbers before executing it. Changing a script locally should change its output; the published output describes the unmodified version. The figures generated by Lab 2 can be opened directly in a browser.

Goal: connect a declared integer range to its terms and total. Predict the terms and totals at $n=0,1,4,6$, then run the code.

Download lab1_sums.py

"""Read finite sums and products. Run with Python 3.11+; no packages needed."""
from math import prod


def odd_sum(n):
    """Sum the first n positive odd integers; n must be a nonnegative int."""
    if isinstance(n, bool) or not isinstance(n, int) or n < 0:
        raise ValueError("n must be a nonnegative integer")
    terms = [2 * i + 1 for i in range(n)]
    return terms, sum(terms)


def rectangular_sum(rows, columns):
    """Sum 10*i+j for mathematical indices 1..rows and 1..columns."""
    return [[10 * i + j for j in range(1, columns + 1)]
            for i in range(1, rows + 1)]


if __name__ == "__main__":
    for n in (0, 1, 4, 6):
        terms, total = odd_sum(n)
        assert total == n * n
        print(f"n={n}: terms={terms}, sum={total}, n*n={n*n}")
    grid = rectangular_sum(2, 3)
    total = sum(sum(row) for row in grid)
    assert total == 102
    print(f"grid={grid}, double_sum={total}")
    assert sum([]) == 0 and prod([]) == 1
    print(f"empty_sum={sum([])}, empty_product={prod([])}")
    print("Checks passed on these inputs; examples alone are not a general proof.")

n=0: terms=[], sum=0, n*n=0
n=1: terms=[1], sum=1, n*n=1
n=4: terms=[1, 3, 5, 7], sum=16, n*n=16
n=6: terms=[1, 3, 5, 7, 9, 11], sum=36, n*n=36
grid=[[11, 12, 13], [21, 22, 23]], double_sum=102
empty_sum=0, empty_product=1
Checks passed on these inputs; examples alone are not a general proof.

Investigate: change the test values to $n=2,3,8$ and predict the totals. Explain why the two-dimensional table has six entries and why their total is $102$. Check the empty product and explain why one is the relevant identity.

Written result: show one complete expansion and trace. State exactly which inputs the assertions checked. Explain why these checks do not establish the identity for every $n$.

Goal: connect values, formulas, and a plot. Predict the row for $x=0$ and the two compositions at $x=3$. The logarithm uses its real domain $x>0$.

Download lab2_functions.py

"""Compare four functions and write an SVG plot using only the standard library.

Run: python lab2_functions.py
Optional: python lab2_functions.py --output functions.svg
"""
import argparse
from html import escape
import math
from pathlib import Path


def logarithm(x):
    if x <= 0:
        raise ValueError("ln(x) requires x > 0")
    return math.log(x)


FUNCTIONS = [("2*x+1", lambda x: 2 * x + 1, "#2563eb"),
             ("x*x", lambda x: x * x, "#7e22ce"),
             ("2**x", lambda x: 2 ** x, "#15803d"),
             ("ln(x)", logarithm, "#c2410c")]


def make_plot(destination):
    width, height = 760, 420
    left, right, top, bottom = 60, 720, 45, 335
    x_min, x_max, y_min, y_max = -2, 4, -4, 18
    def px(x):
        return left + (x - x_min) / (x_max - x_min) * (right - left)
    def py(y):
        return bottom - (y - y_min) / (y_max - y_min) * (bottom - top)
    parts = [f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {width} {height}" role="img" aria-labelledby="title desc">',
             '<title id="title">Four functions over stated domains</title>',
             '<desc id="desc">Linear, square, exponential and natural logarithm. The logarithm has no curve at nonpositive inputs. All curves share the same axes.</desc>',
             '<rect width="760" height="420" fill="white"/>',
             '<g font-family="sans-serif" font-size="13" fill="#475569">']
    for x in range(-2, 5):
        parts.append(f'<path d="M{px(x):.2f},{top} V{bottom}" stroke="#e2e8f0"/>')
        parts.append(f'<text x="{px(x):.2f}" y="355" text-anchor="middle">{x}</text>')
    for y in range(-4, 19, 2):
        parts.append(f'<path d="M{left},{py(y):.2f} H{right}" stroke="#e2e8f0"/>')
        parts.append(f'<text x="48" y="{py(y)+4:.2f}" text-anchor="end">{y}</text>')
    parts.extend([f'<path d="M{left},{py(0):.2f} H{right} M{px(0):.2f},{top} V{bottom}" stroke="#475569"/>',
                  '<text x="735" y="355">x</text><text x="35" y="30">y</text></g>'])
    for index, (label, function, colour) in enumerate(FUNCTIONS):
        commands = []
        connected = False
        for step in range(601):
            x = x_min + step * (x_max - x_min) / 600
            try:
                y = function(x)
            except ValueError:
                connected = False
                continue
            if not y_min <= y <= y_max:
                connected = False
                continue
            commands.append(f'{"L" if connected else "M"}{px(x):.2f},{py(y):.2f}')
            connected = True
        parts.append(f'<path d="{" ".join(commands)}" fill="none" stroke="{colour}" stroke-width="2.5"/>')
        legend_x = 70 + index * 170
        parts.append(f'<path d="M{legend_x},387 h20" stroke="{colour}" stroke-width="3"/>')
        parts.append(f'<text x="{legend_x+27}" y="391" font-family="monospace" font-size="14">{escape(label)}</text>')
    parts.append('</svg>')
    destination.parent.mkdir(parents=True, exist_ok=True)
    destination.write_text('\n'.join(parts), encoding='utf-8')


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--output', type=Path, default=Path('functions.svg'))
    args = parser.parse_args()
    print('x      2*x+1      x*x      2**x      ln(x)')
    for x in (-2, -1, 0, 1, 2, 4):
        values = []
        for _, function, _ in FUNCTIONS:
            try:
                values.append(f'{function(x):9.4f}')
            except ValueError:
                values.append('undefined')
        print(f'{x:2d} ' + ' '.join(values))
    f = lambda x: 2 * x + 1
    g = lambda x: x * x
    assert f(g(3)) == 19 and g(f(3)) == 49
    print(f'f(g(3))={f(g(3))}; g(f(3))={g(f(3))}')
    assert math.isclose(logarithm(4) / logarithm(2), 2.0)
    try:
        logarithm(0)
    except ValueError as error:
        print(f'domain check: {error}')
    else:
        raise AssertionError('zero must be rejected')
    make_plot(args.output)
    print(f'Plot written: {args.output.name}')

x      2*x+1      x*x      2**x      ln(x)
-2   -3.0000    4.0000    0.2500 undefined
-1   -1.0000    1.0000    0.5000 undefined
 0    1.0000    0.0000    1.0000 undefined
 1    3.0000    1.0000    2.0000    0.0000
 2    5.0000    4.0000    4.0000    0.6931
 4    9.0000   16.0000   16.0000    1.3863
f(g(3))=19; g(f(3))=49
domain check: ln(x) requires x > 0
Plot written: functions.svg

Investigate: open functions.svg. Locate the curve for each rule and inspect where the logarithm begins. Change the sampled table inputs to 0.5, 1, 3; update the integer-format input label to a floating format if you do so. Explain why the plot’s absence at $x\le0$ differs from a valid curve lying above its vertical limit.

Written result: show the intermediate values leading to $19$ and $49$. Describe the four functions’ domains and explain why a plot over $[-2,4]$ is insufficient to prove an eventual-growth claim.

Goal: use valid counterexamples to locate a fault before repairing it. Predict the off-by-one total and the square-function counterexample.

Download lab3_diagnose.py

"""Find counterexamples and repair a contract, an index range, and an identity."""
import math


def bad_odd_sum(n):
    return sum(2 * i + 1 for i in range(1, n))


def odd_sum(n):
    if isinstance(n, bool) or not isinstance(n, int) or n < 0:
        raise ValueError('n must be a nonnegative integer')
    return sum(2 * i + 1 for i in range(n))


def shifted_log(x):
    if x <= 1:
        raise ValueError('ln(x-1) requires x > 1')
    return math.log(x - 1)


if __name__ == '__main__':
    n = 4
    print(f'off-by-one: n={n}, faulty={bad_odd_sum(n)}, repaired={odd_sum(n)}, expected={n*n}')
    assert bad_odd_sum(n) != n * n and odd_sum(n) == n * n
    f = lambda x: x * x
    a, b = 2, 3
    print(f'non-additive square: f(a+b)={f(a+b)}, f(a)+f(b)={f(a)+f(b)}')
    assert f(a + b) != f(a) + f(b)
    lhs, rhs = math.log(a + b), math.log(a) + math.log(b)
    print(f'false log identity: ln(a+b)={lhs:.6f}, ln(a)+ln(b)={rhs:.6f}')
    assert not math.isclose(lhs, rhs)
    assert math.isclose(math.log(a * b), rhs)
    print(f'correct product identity: ln(a*b)={math.log(a*b):.6f}')
    for x in (1, 2):
        try:
            print(f'shifted_log({x})={shifted_log(x):.6f}')
        except ValueError as error:
            print(f'shifted_log({x}) rejected: {error}')
    for invalid in (-1, 2.5, True):
        try:
            odd_sum(invalid)
        except ValueError:
            print(f'odd_sum({invalid!r}) rejected')
        else:
            raise AssertionError('invalid input accepted')
    print('Repairs preserve the stated domains; counterexamples refute the false claims.')

off-by-one: n=4, faulty=15, repaired=16, expected=16
non-additive square: f(a+b)=25, f(a)+f(b)=13
false log identity: ln(a+b)=1.609438, ln(a)+ln(b)=1.791759
correct product identity: ln(a*b)=1.791759
shifted_log(1) rejected: ln(x-1) requires x > 1
shifted_log(2)=0.000000
odd_sum(-1) rejected
odd_sum(2.5) rejected
odd_sum(True) rejected
Repairs preserve the stated domains; counterexamples refute the false claims.

Investigate: use $n=1$ as the minimal positive boundary case; choose other positive $a,b$ for the logarithm comparison; use shifted_log(0) and shifted_log(3) to test both sides of the domain boundary. Do not disable the domain checks to make the program appear to succeed.

Written result: distinguish the index-range fault, the false mathematical identity, and the invalid input. Explain each repair in terms of the original contract. Python booleans are deliberately rejected as counts even though Python treats them as an integer subtype.

Exercises 1–12 are required and take about 80 minutes. Exercises 13–14 are optional extensions adding about 25 minutes. Try a written solution before revealing the answer.

def h(x):
    if x < 0:
        return 2 * x + 1
    return x * x

Nine choices are checked automatically. Question 10 requires an explanation; compare it with the model answer and mark your own reasoning. The automatic score concerns the nine choices only. The written response and its review mark are saved in this browser, alongside session progress.

Required, 10 minutes: use the functions material in MIT Mathematics for Computer Science. Read the definitions of a function, its domain, and its codomain in the linked textbook; stop before the later relation/proof material. Write a mapping whose codomain has one unused value and explain why it is still a function.

Required, 15 minutes: read the notation and mathematical-language introduction in Mathematics for Machine Learning, alongside the notation summary below. Locate a finite indexed expression, name each symbol’s role, and expand a three-term instance. This is a preview of the book’s notation; you are not expected to understand its later linear algebra yet.

Optional: read the official Python range examples and math logarithm documentation when comparing code with notation. Use the documentation matching your installed interpreter if behaviour matters. The mathematical exposition and exercises here are original; external sources supply further reading.

The chain of ideas is: declare an object and its permitted values; name the operation; inspect its domain; expand a small case; translate the scope and indices; then check a claim using a valid argument. A function’s image is the output it actually attains, while its codomain is the declared target set. A finite sum binds its index; its other inputs may remain free.

Exit task: specify the piecewise function from Exercise 9, give its Python implementation, expand a small double sum, and refute the logarithm addition identity on valid inputs. Explain these without merely reproducing the answer. Use the proposed course rubric: written exercises 60 points, lab explanations 30, and quiz 10 including your reviewed written response.

Module 02 makes the words “every,” “some,” “if,” and “only if” precise. Before proceeding, explain the difference between a definition and a statement claiming something about every input. Keep the counterexample from this module: it is the first step towards logical reasoning.