数学语言、数与函数

设想一个应用为搜索结果中的前四项计算分数。一位开发者从零计数，另一位从一开始；一位返回总和，另一位返回平均值。两种实现都能运行，也都产生数字，却回答了不同的问题。判断谁正确之前，我们需要精确说明预期计算的含义。

数学记法帮助我们做这件事：明确涉及的对象、允许的输入，以及输入与结果之间的关系。只有读懂这些承诺，公式才真正有用。仅仅认识符号并不够：求和范围一变，含义就变；函数的定义域一变，函数本身也可能改变。

贯穿本模块的任务很小：给定非负整数 $n$，求前 $n$ 个正奇数的和。$n=4$ 时，各项为 $1,3,5,7$，结果为 $16$；$n=0$ 时，没有任何项，结果为 $0$。我们将写出公式，把下标翻译为 Python，并区分几次成功运行与针对全部有效输入的主张。

阅读每个表达式时，始终问：这是什么对象？允许哪些值？结果必须表示什么？ 今后阅读损失函数、概率模型、矩阵变换或算法成本时，同样的问题仍然适用。本模块建立数学语言；后续模块再发展证明和专门的数学工具。

实验前阅读 Python 入门。如果学校代数知识不够稳固，先做 入门诊断，并使用 可选复习。这些资源用于发现需要练习的内容，不是限制学习的门槛。

数学对象是能够描述并推理的事物，例如数、有序数对、集合、函数或数列。哪些运算有意义，取决于对象的种类。两个实数可以相加，但图书目录与温度是不同种类的对象。程序语言提供表示方式，数学描述则赋予表示以含义。

定义规定一个术语的含义。本系列规定自然数包含零：$\mathbb{N}=\{0,1,2,\ldots\}$。其他书籍可能用该符号表示 $\{1,2,\ldots\}$。没有一项约定在所有文本中强制适用；应先声明再使用。特别要求正整数时，我们写 $\mathbb{N}_{>0}$。零是否允许，关系到空输入、初始计数器和无效数量的处理。

假设说明推理或计算适用的环境。“令 $n\in\mathbb{N}$”允许零而排除 $2.5$。主张是需要检验的陈述，例如“前 $n$ 个奇数之和等于 $n^2$”。它涉及每个允许的 $n$；给出求和定义并不自动证明这个主张。定理是从明确假设和认可规则出发，已经用证明建立的主张。模块 04 将系统介绍证明方法。

常见数系构成层次关系。整数 $\mathbb{Z}$ 包含负的整值数；有理数 $\mathbb{Q}$ 包含 $p/q$，其中 $p,q$ 为整数且 $q\ne0$；实数 $\mathbb{R}$ 还包括 $\sqrt{2}$ 等无理数。小数只是书写方式：$0.5=1/2$ 是有理数，而 $\sqrt{2}$ 的无限小数展开不终止也不循环。

属于与包含使用不同符号。$3\in\mathbb{N}$ 表示一个对象属于一个集合；$\mathbb{N}\subseteq\mathbb{Z}$ 表示前一个集合的每个元素也属于后一个集合。为了声明定义域，我们先使用这部分集合语言；模块 03 再深入学习集合运算。

复数写作 $a+b\mathrm{i}$，其中 $a,b\in\mathbb{R}$ 且 $\mathrm{i}^2=-1$。这里只作预览，不是实验的先修条件。实数对应 $b=0$ 的特殊情况。谱方法和傅里叶方法会用到复数；当前计算使用实数与整数下标。

公式出现字母时，要说明其角色，不要仅凭字母外形猜测。变量可以在允许值中变化；参数在某次分析中保持固定；常量在当前环境中取指定值。这些角色取决于上下文。在 $f_a(x)=ax+1$ 中，可以把 $a$ 视为参数、$x$ 视为输入；以后从数据拟合 $a$ 时，它又成为变化的量。

$=$ 表示两个表达式指向同一个值，具有对称性：若 $a=b$，则 $b=a$。它不表示“继续下一步”或“保存新值”。$\ne$ 表示不相等；$<$ 与 $\le$ 比较有序实数。$x\le3$ 包含边界 $3$，$x<3$ 排除它。$0\le x<1$ 是两个条件同时成立。

数学方程 $x=x+1$ 没有实数解，因为两边减去 $x$ 会得到 $0=1$。Python 的 x = x + 1 则先用旧值计算右侧，再把结果赋给左侧名称；相等比较使用 ==。数学文本也可能用 $x:=3$ 或“定义 $x$ 为 3”，把定义与待求解方程分开。这些写法表示不同操作。

运算优先级也影响含义。通常 $-3^2=-(3^2)=-9$，因为先乘方再处理外面的负号；$(-3)^2=9$ 则把负号纳入底数。分数线将分子和分母各自分组；代码 1/(x-2) 保留了这种结构，而 1/x-2 是另一表达式。翻译公式时，即使默认优先级正确，也可以加括号帮助读者理解。

区间规定一段实数范围。方括号包含端点，圆括号排除端点：$[0,1]$ 包含两端，$(0,1)$ 排除两端，$[0,1)$ 只包含左端。无穷不是能被包含的实数端点，因此正实数范围写为 $(0,\infty)$。区间 $[0,4]$ 不同于五元素集合 $\{0,1,2,3,4\}$：区间还包含 $1/2$ 与 $\sqrt{2}$。

绝对值表示到零的距离：$x\ge0$ 时 $|x|=x$，$x<0$ 时 $|x|=-x$。它总是非负，因此 $|-3|=3$。$|x|<2$ 表示距离零小于二，等价于 $-2<x<2$。以后近似误差和容差也会用到这种距离记法。

下标标记分量或项。数列 $a_0,a_1,a_2$ 中，$a_2$ 是标记为二的项，不是 $a\cdot2$，也不是 $a^2$。上标经常表示乘方，但含义仍取决于声明：以后可能用 $x^{(t)}$ 表示第几次迭代。括号与解释帮助区分这两种含义。

奇数任务使用 $a_i=2i+1$，整数下标为 $i=0,1,\ldots,n-1$。当 $n=4$ 时，下标为 $0,1,2,3$，对应项为 $1,3,5,7$。最后下标是三，但项数是四。若从 $i=1$ 开始却不改变公式，就会从 $3$ 开始，描述另一数列。

$\sum_{i=0}^{3}(2i+1)$ 表示依次代入允许的整数下标，再相加。展开为 $(2\cdot0+1)+(2\cdot1+1)+(2\cdot2+1)+(2\cdot3+1)=16$。大写希腊字母 sigma 是聚合指令。第 5 节会深入讨论作用范围与嵌套形式；这些知识已经足够跟踪实验 1。

还要区分精确相等与近似。$\sqrt{2}\approx1.414$ 承认二者存在差异。显示三位小数不能证明底层数值相等。实验中的整数求和使用精确整数运算；浮点计算需要明确容差。模块 29 将解释更复杂情形下如何选择数值比较方式。

函数为其定义域中的每个输入指定唯一输出。$f:D\to C$ 给出定义域 $D$ 与陪域 $C$。所有输出必须属于 $C$，但不要求 $C$ 的每个元素都被产生。实际达到的输出集合叫像：$f(D)=\{f(x):x\in D\}$。这一区分关系到反函数是否存在，以及一个候选输出是否可能出现。

公式只是描述函数的一种方法，并不是完整规格。同一表达式配上不同定义域，可以描述不同函数。$f(x)=x^2$ 在全部实数上定义时，像为 $[0,\infty)$；定义域为 $\{0,1,2\}$ 时，像为 $\{0,1,4\}$。两者都能选择 $\mathbb{R}$ 为陪域，但陪域中的未达到值不是函数输出。

定义域限制可能来自表达式，也可能来自问题。实数表达式 $r(x)=1/(x-2)$ 不允许 $x=2$，因为除零未定义；实数平方根要求被开方数非负。计数函数可以排除负输入，即使其代数表达式能机械代入负值。先说明问题本身的限制，再讨论表达式是否能计算。

函数也可以分段定义：

条件选择规则，并且必须为定义域中每个输入提供唯一结果。这里每个实数恰好属于一个分支，边界 $x=0$ 也被覆盖。若分支重叠且给出不一致输出，就不是有效函数；若漏掉一部分输入，就没有覆盖声称的定义域。

复合是把一个函数的输出交给另一个函数。$(f\circ g)(x)=f(g(x))$ 中外层函数写在左边，但先执行 $g$。有效输入必须属于 $g$ 的定义域，且中间结果必须属于 $f$ 的定义域。若 $g$ 的所有输出都满足外层要求，复合在 $g$ 的全部定义域上成立；否则必须进一步限制允许输入。

若改成 $f(t)=\ln(t-1)$、$g(x)=x^2$，外层要求 $t>1$，因此复合要求 $x^2>1$，即 $x<-1$ 或 $x>1$。内层平方允许零，但整个复合不允许。只检查原输入是否满足内层条件，会漏掉中间值的定义域错误。

反函数唯一地逆转映射。实数函数 $f(x)=2x+1$ 的反函数为 $f^{-1}(y)=(y-1)/2$；两个方向的复合都会恢复原值。$f^{-1}$ 表示反映射，不是倒数 $1/f$。全部实数上的平方不能唯一恢复输入，因为 $2$ 与 $-2$ 都产生 $4$。将平方的定义域和陪域都限制为 $[0,\infty)$，才得到反函数 $\sqrt{y}$。

程序实现也不一定是仅关于其显式参数的数学函数。读取时钟、可变全局变量或随机生成器的过程，可能对相同显式输入返回不同结果。需要确定性映射时，应把额外状态纳入模型。后续概率模块会直接建模随机输出。

正整数指数表示重复相乘，因此 $a^3=aaa$。非零底数的零次方是 $a^0=1$，负整数次方是 $a^{-k}=1/a^k$。底数限制不可省略：零的负次方会要求除零。$0^0$ 在不同环境中有不同约定；本模块不为它规定普遍的实数解释。

在有效定义域内，乘方满足 $a^r a^s=a^{r+s}$ 与 $(a^r)^s=a^{rs}$。正实数底数允许将这些关系自然推广到实数指数。负底数和非整数指数的实数定义域则更复杂，例如 $(-1)^{1/2}$ 不是实数。不能仅凭符号相似，就把正底数规则套到所有表达式。

指数函数固定底数、改变指数：$2^x$ 的输入是 $x$。幂函数 $x^2$ 则改变底数、固定指数。$x=2$ 时二者都给出 $4$；$x=3$ 时分别为 $8$ 与 $9$；$x=4$ 时又都为 $16$。若干重合值并不说明函数相同。实验 2 在明确范围内比较它们；模块 06 再研究更长远的增长。

对数询问什么指数会产生某个正值。实数底数 $a>0$、$a\ne1$ 时，$\log_a x=y$ 表示 $a^y=x$，要求 $x>0$。它是指数映射的反函数。自然对数 $\ln x$ 使用底数 $e$，约为 $2.71828$ 的正无理数。本系列未注明底数的数学 $\log$ 默认表示自然对数。

定义域也是恒等式的一部分。对任意实数 $y$，$\ln(e^y)=y$；对正数 $x$，$e^{\ln x}=x$。后一表达式在零或负实数上未定义。这种计算器报错反映所规定实函数的定义域，并不是偶然的软件不便。

对正实数 $u,v$，对数将乘法转成加法：

乘积恒等式来自指数规则：写成 $u=e^r$、$v=e^s$，则 $uv=e^{r+s}$，取自然对数得到 $r+s$。参数与商必须仍然满足定义域要求。对 $u>0$，还成立 $\ln(u^r)=r\ln u$。以后，这些关系会把独立概率的乘积转成对数似然之和。

加法没有对应的一般恒等式。取 $u=v=1$，$\ln(u+v)=\ln2$ 为正，但 $\ln u+\ln v=0$。一个有效反例足以否定声称对全部正输入成立的恒等式，却不能自动建立另一条公式；乘积规则需要自己的解释。

比较增长必须说明输入范围和目的。把 $\ln n$ 乘以正的常数 $1/\ln2$ 会改变数值，却不改变随 $n$ 增长的总体形态。在编码和信息计算中，底数仍重要，因为单位会改变：二进制对数对应比特，自然对数对应纳特。信息论模块会再次讨论这些单位。

图像只能提供显示窗口内的证据，不能证明全部正输入上的性质。指数函数可能在某段范围内小于多项式，却在更后面增长更快。坐标轴也必须检查：对数坐标会改变数值间的显示间距。实验 2 使用相同的普通坐标轴；曲线离开可见矩形，不意味着函数不再存在。

有限求和在声明的下标范围内聚合各项。求和符号绑定其中的下标：$\sum_{i=1}^n a_i$ 中，$i$ 逐一取一到 $n$ 的整数值，而 $n$ 仍是控制范围的参数。绑定范围之外的字母可能有另一含义。这与程序循环变量的作用范围相似。

可靠地阅读求和，需要确定四部分：下标名称、起点、终点和被计算的项。先展开小例子，再尝试化简：

共有四项。不能把下标或最后一项简单乘以上界作为捷径。改成 $4(4+2)=24$，等于把末项错误地使用四次。

下标是绑定变量，也称哑变量。完整改名不改变总和：$\sum_{i=1}^4 i^2=\sum_{j=1}^4 j^2$。但改名不能捕获原有变量。在 $\sum_{i=1}^n(x+i)$ 中，$x$ 是自由变量，$i$ 被绑定。若把绑定下标改成 $x$，却不保留原来的自由输入，就悄悄改变了表达式。应选择不同名称，类似避免覆盖函数参数。

有限求和可以使用普通加法规则重新排列和分配。常数 $c$ 满足

展开两侧，就能看到每项恰好出现一次。这是当前加法与乘法的性质，并不证明所有函数满足 $f(a+b)=f(a)+f(b)$。无限求和重新排列时还需要收敛条件；这里只讨论有限情形。

空和为零：没有贡献时，已有累计值不变。奇数任务中，$n=0$ 使零到 $n-1$ 的范围为空，不是需要计算一个负下标末项。结果来自聚合约定，不是把不存在的项假装为零。

有限乘积使用 $\prod$，例如 $\prod_{i=1}^4 i=1\cdot2\cdot3\cdot4=24$。空积为一，因为没有因子时，已有乘积不变。若空积为零，任何普通乘积拆成非空部分与空部分后都会消失。这些单位元解释了 sum([]) 与 math.prod([])。

双重求和包含两个聚合指令：

先固定外层 $i$，完成内层 $j$ 的求和，再把内层结果相加。$i=1$ 时，各项 $11,12,13$ 合计 $36$；$i=2$ 时，各项 $21,22,23$ 合计 $66$；整体为 $102$。两个外层值各对应三个内层值，因此共有六项。

因为是有限矩形，先加列也相同：$(11+21)+(12+22)+(13+23)=32+34+36=102$。非矩形范围需要更谨慎。在 $\sum_{i=1}^3\sum_{j=1}^i j$ 中，内层上界依赖 $i$。各行分别为 $1$、$1,2$、$1,2,3$，总和 $10$。不转换有效下标对而直接交换两个求和符号，会改变范围。

求和后仍保留的变量决定输出含义。$s(x)=\sum_{i=1}^3(x+i)$ 中绑定下标消失，但输入 $x$ 保留；展开得到 $s(x)=3x+6$。$t_j=\sum_{i=1}^2 a_{ij}$ 中，$j$ 仍是自由下标，用来标记哪一列的总和。模块 09 使用数组时，这一区分能避免形状与轴的错误。

矩形双重求和使用外层 range(1,3) 与内层 range(1,4)。三角形例子使用外层 range(1,4) 和内层 range(1,i+1)。扩大输入之前，检查极小例子与空范围。一个很大的、看起来合理的结果，不能显示究竟遗漏了哪些下标。

数学约定说明允许的输入与结果必须满足的关系。奇数任务输入为非负整数 $n$，输出为整数总和

其中空和为零，输入不被修改。负数量、非整数量，以及要求平均值而非总和，都不属于该规格。软件政策另行说明无效输入如何处理；实验抛出清晰的 ValueError。

逐项翻译：数学数量成为 Python 整数；包含 $n-1$ 的范围成为 range(n)；项写为 2 * i + 1，代码需要乘法运算符；累计值从零开始，每次加入一项。这比把符号机械复制到解释方式不同的语言更可靠。

$S$ 的定义与 $S(n)=n^2$ 的主张角色不同。定义说明计算内容，恒等式声称另一个表达式对全部有效 $n$ 给出相同值。$n=4$ 的检查只确认一个案例。一般恒等式可用模块 04 的归纳法，或本模块可选练习中的有限求和代数论证建立。

否定全称主张常常比证明更容易。否定“每个实函数都有加性”，可取 $f(x)=x^2$、$a=2$、$b=3$：$f(a+b)=25$，而 $f(a)+f(b)=13$。所有输入和中间值都有效，因此反例成立。若把未定义的对数作为“反例”，就不能检验只对正参数声称的恒等式。

区分三种故障。规格故障是公式描述了错误任务，如要求总和却写成平均值。翻译故障是代码实现了错误表达式，如该用 range(n) 却写 range(1,n)。数值故障是机器算术没有足够好地近似预期计算，如指数溢出或相等检查不合适。不同故障需要不同修复。

AI 论文写 $L(\theta)=\frac1n\sum_{i=1}^n\ell_i(\theta)$ 时，同样的基本技能仍适用：$\theta$ 自由、$i$ 绑定；$n$ 必须为正，因为平均值不能除以零；求和改成平均会改变尺度。你暂时不需要会最小化它，也能读懂所声明的关系；后续微分与优化再提供进一步工具。

不要默默给公式增加情况。若将来要求 $n=0$ 返回“无分数”而非零，应修改约定与检查；若函数输入从标量改成数组，应声明新的输入输出形状。数学精确性让这些选择清晰可见，便于讨论与验证。

若脚本中有不熟悉的语法，先读 Python 入门。把各脚本下载到能找到的文件夹，在该文件夹打开终端，运行 python lab1_sums.py、python lab2_functions.py 或 python lab3_diagnose.py。Windows 可能需要 py，macOS/Linux 常用 python3；检查所选解释器为 Python 3.11 或更新版本。脚本只使用标准库。

下面提供完整脚本与网页构建器实际捕获的输出。执行之前先阅读问题，预测主要数值。本地改变脚本会改变输出；发布的输出对应未修改版本。实验 2 生成的图像可以直接用浏览器打开。

目标： 将整数范围与项及其总和联系起来。先预测 $n=0,1,4,6$ 的项和总和，再运行代码。

下载 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.

探索： 改为 $n=2,3,8$，预测结果。解释二维表为何有六项且总和为 $102$。检查空积，并解释为什么一是相应单位元。

书面结果： 展示一次完整展开与跟踪，明确断言检查了哪些输入，解释为何这些检查没有证明所有 $n$ 上的恒等式。

目标： 联系数值、公式与图像。先预测 $x=0$ 的一行，以及 $x=3$ 时两种复合。对数使用实数定义域 $x>0$。

下载 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

探索： 打开 functions.svg，找到各条曲线并检查对数从哪里出现。把表格输入改成 0.5,1,3；这样修改时，应同时把整数输入标签改为浮点格式。解释 $x\le0$ 时对数未定义，与有效曲线超出纵轴上限的区别。

书面结果： 写出得到 $19$ 与 $49$ 的中间值，描述四个函数的定义域，解释为何 $[-2,4]$ 上的图像不足以证明最终增长性质。

目标： 在修复之前用有效反例定位错误。先预测少一项的总和，以及平方函数的反例。

下载 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.

探索： 用 $n=1$ 检查最小正边界；为对数比较选择其他正数 $a,b$；用 shifted_log(0) 和 shifted_log(3) 检查定义域边界两侧。不要为了让程序“成功”而关闭定义域检查。

书面结果： 区分下标范围错误、错误数学恒等式与无效输入，按原约定解释各修复。尽管 Python 将布尔值视为整数子类，这里仍明确排除它们作为数量。

练习 1–12 为必做，约 80 分钟；13–14 为可选拓展，额外约 25 分钟。先写自己的解答，再展开答案。

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

九道选择题自动检查。第 10 题需要解释，请与参考答案比较并自评。自动得分只涉及九道选择题。书面回答与复核标记会和时段进度一样保存在当前浏览器。

必读，10 分钟： 使用 MIT 计算机科学数学 的函数材料。阅读其链接教材中函数、定义域与陪域的定义，暂不继续关系与证明内容。写一个陪域有未使用值的映射，解释为什么仍是函数。

必读，15 分钟： 配合下方记法总结，阅读 机器学习数学 的数学语言与记法介绍。找一个有限带下标表达式，说明各符号角色，并展开三项实例。这里只预览书中记法，不要求已经理解后续线性代数。

可选： 比较代码与记法时，阅读官方 Python range 例子 与 对数文档。涉及行为差异时，使用匹配本地解释器版本的文档。本模块数学说明与练习为原创，外部资源供进一步阅读。

思想链条是：声明对象与允许值，明确运算，检查定义域，展开小例子，翻译作用范围与下标，再用有效论证检验主张。函数的像是实际达到的输出，陪域是声明目标集合。有限求和绑定其下标，其他输入可能仍然自由。

结业任务： 为练习 9 的分段函数写规格与 Python 实现，展开一个小双重求和，并在有效输入上否定对数加法恒等式。不要只复述答案，应能自己解释。课程建议评分为书面练习 60 分、实验解释 30 分、自测 10 分，其中包括复核后的书面回答。

模块 02 精确说明“每个”“存在”“如果”“只有当”等表达。开始前应能解释定义与关于全部输入的主张之间的区别。保留本模块反例，它是逻辑推理的起点。