前缀函数与 KMP 算法

字符串匹配问题：给定模式串 \(pat\) 和文本 \(txt\)，找出 \(pat\) 在 \(txt\) 中的所有出现位置。朴素做法逐字符比对，失配时模式串回退一位、文本指针也回退，最坏 \(O(nm)\)。

KMP 的核心思想：失配时文本指针不必回退。如果已经匹配了 \(k\) 个字符，那么模式串的前 \(k-1\) 个字符和文本中刚扫描过的部分是相同的。利用这部分重叠信息，可以将模式串向前滑动到下一个可能匹配的位置，而不需要重新扫描文本。

这个”重叠信息”就是前缀函数 \(\pi\)。对模式串 \(s[0:n]\)（下标区间均为前闭后开 \([a,b)\)），\(\pi(i)\) 定义为：

\[ \pi(i) = \max_{k \in [0,i]}\big\{\,k \;\big|\; s[0:k] = s[i+1-k:i+1] \,\big\} \]

也即 \(\pi(i)\) 是 \(s[0:i+1]\) 的最长真前缀同时也是后缀的长度。规定 \(\pi(0)=0\)。

例如模式串 "aabaaab" 的 \(\pi\)：

\(\pi\) 的直观含义：\(\pi(i)=k\) 意味着 \(s[0:k]\) 和 \(s[i+1-k:i+1]\) 完全相同。当在文本位置 \(j\) 处 \(s[k]\) 失配时，可以保持文本指针不动，将模式串状态回退到 \(\pi(k-1)\) 而不是 \(0\)——因为前 \(\pi(k-1)\) 个字符已经在失配位置之前被隐式匹配过了。这就是 KMP 线性时间的来源。

Haskell 实现

import qualified Data.Array as A

-- | 单步转移：给定前缀函数 pi、模式串 pat、当前状态 s 和字符 c，返回下一状态。
step :: (Eq tok) => A.Array Int Int -> A.Array Int tok -> Int -> tok -> Int
step pi pat s c
  | pat A.! s == c = s + 1                              -- 命中：前进
  | s == 0         = 0                                  -- 到根：停止
  | otherwise      = step pi pat (pi A.! (s - 1)) c     -- 沿 pi 失败链回跳

-- | 前缀函数 pi，通过 knot-tying 用 scanl 一步完成。
prefix :: (Eq tok) => A.Array Int tok -> A.Array Int Int
prefix pat
  | null pat   = A.listArray (0, 0) [0]
  | otherwise  = pi
  where
    -- knot: pi 与 pat 同边界，扫描 step 自身得出
    pi = A.listArray (A.bounds pat) (scanl (step pi pat) 0 (drop 1 (A.elems pat)))

-- | KMP 匹配：prefix 算前缀函数，scanl 推进状态，any 检测命中。
contains :: (Eq tok) => A.Array Int tok -> [tok] -> Bool
contains pat = any (== n) . scanl (step pi pat) 0
  where
    pi = prefix pat
    n  = A.rangeSize (A.bounds pat)

step 四行，prefix 四行，contains 三行。\(\pi\) 直接复用 pat 的边界（A.bounds pat），无需单独声明 \(n\)。传统实现中 n = length pat、for i = 1 to n-1 的模板代码被 scanl + drop 1 + elems 取代。

代码分析

step

step :: Array Int Int → Array Int tok → Int → tok → Int

\(\pi\)、模式串、当前状态 → 字符 → 新状态。命中则前进，失配则沿 \(\pi\) 失败链回跳，到根则停止。

step 不持有 \(\pi\) 和模式串——二者均为显式入参。prefix 传入构造中的 \(\pi\)（knot），contains 传入已构造的 \(\pi\)（普通调用）。同一函数，两种用法。

prefix

pi = A.listArray (A.bounds pat) (scanl (step pi pat) 0 (drop 1 (A.elems pat)))

两个动作：

1. scanl 从 \(0\) 开始，将 step pi pat 依次应用到 \(pat[1..n-1]\)，产生 \(\pi(0),\pi(1),\dots,\pi(n-1)\)
2. pi 同时是 step 的入参——knot：\(\pi\) 用 step 扫描自身来构造，step 又需要 \(\pi\) 做失败链回跳

pi 直接复用 pat 的边界——A.bounds pat 决定 pi 的长度，省去手动传递 \(n\)。

flowchart TD
    scanl["scanl (step pi pat)"] -->|"产生"| pi["pi"]
    pi -->|"pi A.! (s-1)"| step["step pi pat"]
    scanl -->|"施加"| step

在严格求值的语言（如 Rust、C++）中这是”用未完成的数据结构读取自身”，是悖论。在 Haskell 中，Data.Array 对 boxed 元素是惰性的：scanl 自左向右逐个产生 thunk，当 step 需要 \(\pi(j-1)\) 时（\(j-1 <\) 当前索引），该 thunk 已被 scanl 顺序强制过。

contains

contains pat = any (== n) . scanl (step pi pat) 0
  where
    pi = prefix pat
    n  = A.rangeSize (A.bounds pat)

scanl (step pi pat) 0 在文本上驱动状态机，生成状态序列；any (== n) 检测是否抵达接受状态 \(n\)。prefix 提供 \(\pi\)。三者数据流：

flowchart LR
    prefix["prefix"] -->|"pi"| contains["contains"]
    prefix --> step["step"]
    contains --> step

正确性证明

定义 \(\pi\)、\(\mathrm{step}\)、\(\{p_i\}\)，证 \(\{p_i\} = \{\pi(i)\}\)。

定义

定义 1（前缀函数）　对字符串 \(s[0:n]\)（区间记号均为前闭后开 \([a,b)\)），\(\pi : \{0,\dots,n-1\} \to \mathbb{N}\)：

\[ \pi(i) = \begin{cases} 0, & i = 0 \\ \max\{\,k \in [0,i] \mid s[0:k] = s[i+1-k : i+1]\,\}, & i \ge 1 \end{cases} \]

定义 2（转移函数）　给定 \(s\) 及其 \(\pi\)，\(\mathrm{step} : \mathbb{N} \times \Sigma \to \mathbb{N}\)（其中 \(\Sigma\) 为字符集）：

\[ \mathrm{step}(j, c) = \begin{cases} j + 1, & \text{若 } s[j] = c \\[2pt] 0, & \text{若 } s[j] \neq c \;\land\; j = 0 \\[2pt] \mathrm{step}(\pi(j-1),\, c), & \text{若 } s[j] \neq c \;\land\; j > 0 \end{cases} \]

定义 3（scanl 序列）　序列 \(\{p_i\}_{i=0}^{n-1}\)：

\[ p_i = \begin{cases} 0, & i = 0 \\ \mathrm{step}(p_{i-1},\, s[i]), & i \ge 1 \end{cases} \]

即 \([p_0,\dots,p_{n-1}] = \mathrm{scanl\ step\ 0}\ [s[1],\dots,s[n-1]]\)。

定理

定理　\(\forall i \in [0, n-1]:\; p_i = \pi(i)\)。

证明　对 \(i\) 归纳。

基始 \(i = 0\)：\(p_0 = 0 = \pi(0)\)。证毕

归纳步　假设对所有 \(k < i\) 有 \(p_k = \pi(k)\)（强归纳）。令 \(j = p_{i-1} = \pi(i-1)\)，则 \(p_i = \mathrm{step}(j, s[i])\)。

\(\mathrm{step}\) 的定义有三条分支，按此展开讨论：

情况 A　\(s[j] = s[i]\)。

此时 \(p_i = \mathrm{step}(j, s[i]) = j+1\)。下证 \(\pi(i) = j+1\)。

（\(\ge\)） \[ \begin{aligned} s[0:j] &= s[i-j:i] && [j = \pi(i-1)] \\ s[j] &= s[i] && [\text{前提}] \\[2pt] \implies s[0:j+1] &= s[i-j:i+1] && [\text{拼接}] \\ \implies \pi(i) &\ge j+1 && [\pi\ \text{定义}] \end{aligned} \]

（\(\le\)） \[ \begin{aligned} k = \pi(i) &\implies s[0:k] = s[i+1-k:i+1] && [\pi\ \text{定义}] \\ &\implies s[0:k-1] = s[i+1-k:i] && [\text{截末字符}] \\ &\implies \pi(i-1) \ge k-1 && [\pi\ \text{定义}] \\ &\implies j \ge k-1 && [\pi(i-1)=j] \\ &\implies k \le j+1 \\ &\implies \pi(i) \le j+1 \end{aligned} \]

由 \((\ge)(\le)\)：\(\pi(i) = j+1 = p_i\)。证毕

情况 B　\(s[j] \neq s[i]\) 且 \(j = 0\)。

此时 \(p_i = \mathrm{step}(j, s[i]) = 0\)。下证 \(\pi(i) = 0\)。

令 \(M_m = \{\,k \mid s[0:k] = s[m+1-k:m+1]\,\}\)，则 \(\pi(m) = \max M_m\)。

由 \(\pi(i-1) = 0\)： \[ M_{i-1} = \{0\} \tag{1} \]

对任意 \(k \ge 1\)： \[ \begin{aligned} k \in M_i &\implies s[0:k] = s[i+1-k:i+1] && [M_i\ \text{定义}] \\ &\implies s[0:k-1] = s[i+1-k:i] && [\text{截末字符}] \\ &\implies k-1 \in M_{i-1} && [M_{i-1}\ \text{定义}] \\ &\implies k-1 = 0 && [\text{由 (1)}] \\ &\implies k = 1 \end{aligned} \]

又： \[ \begin{aligned} 1 \in M_i &\iff s[0:1] = s[i:i+1] && [M_i\ \text{定义}] \\ s[0] &= s[j] \neq s[i] && [j=0,\ \text{前提}] \\[2pt] &\Downarrow \\ 1 &\notin M_i \end{aligned} \]

综上，\(M_i\) 中不存在 \(k \ge 1\)。而 \(0 \in M_i\) 恒真（空匹配），故： \[ M_i = \{0\},\qquad \pi(i) = \max M_i = 0 = p_i \]

证毕

情况 C　\(s[j] \neq s[i]\) 且 \(j > 0\)。

此时 \(p_i = \mathrm{step}(j, s[i]) = \mathrm{step}(\pi(j-1), s[i])\)。

（i）证 \(\pi(i) \le j\)　设 \(k = \pi(i)\)。若 \(k = 0\)，则 \(k \le j\) 平凡。下设 \(k \ge 1\)：

\[ \begin{aligned} k = \pi(i) &\implies s[0:k] = s[i+1-k:i+1] && [\pi\text{ 定义}] \\ &\implies s[0:k-1] = s[i+1-k:i] && [\text{截末字符}] \\ &\implies \pi(i-1) \ge k-1 && [\pi\text{ 定义}] \\ &\implies j \ge k-1 && [\pi(i-1)=j] \\ &\implies k \le j+1 && \text{(1)} \end{aligned} \]

又： \[ \begin{aligned} s[0:k] = s[i+1-k:i+1] &\implies s[k-1] = s[i] && [\text{末字符}] \\ s[j] \neq s[i] &\implies k-1 \neq j && [\text{前提}] \\ &\implies k \neq j+1 && \text{(2)} \end{aligned} \]

由 (1)(2) 及 \(k\) 为整数：\(k \le j\)，即 \(\pi(i) \le j\)。

（ii）将 \(\pi(i)\) 用 \(j\) 表示　令 \(k = \pi(i)\)，\(k \le j\)：

\[ \begin{aligned} k = \pi(i) &\iff s[0:k] = s[i+1-k:i+1] && [\pi\text{ 定义}] \\ &\iff s[0:k-1] = s[i+1-k:i]\;\wedge\; s[k-1] = s[i] && [\text{拆末字符}] \\ &\iff s[0:k-1] = s[j+1-k:j]\;\wedge\; s[k-1] = s[i] && [\text{由 } s[0:j]=s[i-j:i]] \end{aligned} \]

故： \[ \pi(i) = \max\{\,k \mid s[0:k-1] = s[j+1-k:j],\; s[k-1] = s[i]\,\} \]

令 \(\ell = k-1\)： \[ \pi(i) = \max\{\,\ell+1 \mid s[0:\ell] = s[j-\ell:j],\; s[\ell] = s[i]\,\} \]

（空集则 \(0\)。）

记该链为 \(m_0 = \pi(j-1)\)，\(m_1 = \pi(m_0-1)\)，…，\(m_k = 0\)。展开 \(\mathrm{step}\) 的递归定义：

\[ \begin{aligned} \mathrm{step}(m_0, s[i]) &= \begin{cases} m_0 + 1, & s[m_0] = s[i] \\ \mathrm{step}(m_1, s[i]), & s[m_0] \neq s[i] \end{cases} \\ \mathrm{step}(m_1, s[i]) &= \begin{cases} m_1 + 1, & s[m_1] = s[i] \\ \mathrm{step}(m_2, s[i]), & s[m_1] \neq s[i] \end{cases} \\ &\;\;\vdots \\ \mathrm{step}(m_k, s[i]) &= 0 \qquad (m_k = 0) \end{aligned} \]

逐层代入得 \(\mathrm{step}(m_0, s[i]) = m_t + 1\)，其中 \(t\) 是满足 \(s[m_t] = s[i]\) 的最小下标（不存在则 \(0\)）。因 \(m_0 > m_1 > \dots > m_k\)，此 \(m_t\) 是链中满足条件者的最大值，故：

\[ \mathrm{step}(\pi(j-1), s[i]) = \max\{\,\ell+1 \mid \ell \in \{\pi(j-1),\,\pi(\pi(j-1)-1),\,\dots,\,0\},\; s[\ell]=s[i]\,\} \]

因此需确认该链等于 \(\{\,\ell \mid s[0:\ell] = s[j-\ell:j]\,\}\)。分两个方向证明该等式：

\[ \begin{aligned} \{\,\ell \mid s[0:\ell] = s[j-\ell:j]\,\} &\subseteq \{\pi(j-1),\,\pi(\pi(j-1)-1),\,\dots,\,0\} \\ \{\,\ell \mid s[0:\ell] = s[j-\ell:j]\,\} &\supseteq \{\pi(j-1),\,\pi(\pi(j-1)-1),\,\dots,\,0\} \end{aligned} \]

先证 \(\supseteq\)。对链上任一 \(m_i\)：

\[ \begin{aligned} m_i &= \pi(m_{i-1}-1) \\ &\implies s[0:m_i] = s[m_{i-1}-m_i:m_{i-1}] && [\pi\text{ 定义}] \\ &\implies s[0:m_i] = s[j-m_i:j] && [\text{代入 } s[0:m_{i-1}]=s[j-m_{i-1}:j]] \end{aligned} \]

故 \(m_i \in \{\,\ell \mid s[0:\ell] = s[j-\ell:j]\,\}\)。

再证 \(\subseteq\)。设 \(\ell\) 满足 \(s[0:\ell]=s[j-\ell:j]\)，记 \(m_0 = \pi(j-1)\)。

\[ \begin{aligned} \ell &\le m_0 && [m_0 = \max\{\ell \mid s[0:\ell]=s[j-\ell:j]\}] \\ \ell < m_t &\implies s[0:\ell] = s[m_t-\ell:m_t] && [s[0:m_t]=s[j-m_t:j],\ \ell<m_t] \\ &\implies \ell \le \pi(m_t-1) = m_{t+1} && [\pi\text{ 定义}] \\ &\implies \ell = m_{t+1} \lor \ell < m_{t+1} \end{aligned} \]

由 \(\pi(m_t-1) < m_t\) 知链 \(m_0 > m_1 > m_2 > \dots > 0\) 严格递减，因此有限步内必有 \(\ell = m_t\)（对某 \(t\)）或 \(\ell = 0\)，即 \(\ell \in \{m_0,m_1,\dots,0\}\)。

因此两集合相等： \[ \{\,\ell \mid s[0:\ell] = s[j-\ell:j]\,\} = \{\pi(j-1),\,\pi(\pi(j-1)-1),\,\dots,\,0\} \]

代入该等式： \[ \mathrm{step}(\pi(j-1), s[i]) = \max\{\,\ell+1 \mid s[0:\ell]=s[j-\ell:j],\; s[\ell]=s[i]\,\} \]

由强归纳，链上每个 \(\pi\) 值均已得证，故 \(\mathrm{step}(\pi(j-1), s[i]) = \pi(i)\)。

故 \(p_i = \pi(i)\)。证毕

综上，由数学归纳法，\(\forall i:\; p_i = \pi(i)\)。证毕

惰性求值

prefix 中出现了看似循环的依赖：pi 的定义引用了 step pi pat，而 step 的第三个参数正是 pi 自身。在大多数语言中，这行代码会立即崩溃——无法使用尚未构造完成的数据结构。

原因在于求值策略的差异。

严格求值与惰性求值

主流语言（Rust、C++、Java、Python 等）采用严格求值（strict/eager evaluation）：函数调用前所有参数必须计算为确定的值。先算结果，再传参数。

Haskell 采用惰性求值（lazy evaluation）：表达式只在结果被需要时才计算。函数参数传入时并不求值，而是打包为一个thunk——“等需要时再算”的延迟计算。当某个操作需要 thunk 的实际值（如模式匹配、输出、算术运算）时，运行时才强制（force）这个 thunk，执行计算并替换为结果。

spine 与 thunk

Data.Array 在内存中由两部分组成：

• spine：索引结构与边界信息
• 元素：各槽位的值

A.listArray 求值 spine（校验边界合法性），但保留元素为 thunk——每个槽位放一个尚未计算的表达式。

scanl 从左到右扫描模式串时，依次产生 \(\pi(0),\pi(1),\dots\)。每个 \(\pi(i)\) 是一个 thunk。当 step 需要 \(\pi(j-1)\) 时（\(j-1 < i\)），该 thunk 已被 scanl 在前面的迭代中强制为具体整数。

时间线（scanl 从左到右）：
  索引 0: 强制 thunk₀ → π(0)=0           ✓ 无依赖
  索引 1: 强制 thunk₁ → step 需要 π(0)    ✓ π(0) 已就绪
  索引 2: 强制 thunk₂ → step 需要 π(1)    ✓ π(1) 已就绪
  ...
  索引 i: 强制 thunkᵢ → step 需要 π(j-1)  ✓ j-1 < i，已就绪

关键性质：数据依赖索引始终小于当前计算索引。故计算图是有向无环的——不存在前向引用，仅为”引用自身数组的前缀”。惰性求值让这种自引用结构可自左向右依次解开，每一步只读已计算部分。

严格求值语言的对比

在严格求值的语言中，A.listArray 不仅求值 spine，还会立即求值所有元素——数组构造器要求各槽位在创建时即确定。构造 \(\pi\) 时 scanl 第一步就需要访问 \(\pi\)（但 \(\pi\) 还不存在），形成死锁。

Rust / C++ 的 KMP 必须用两趟循环，或手动维护状态、每次只访问已写入位置。这是手动编码”拓扑排序”。

Haskell 的惰性数组将拓扑排序交给运行时——数据依赖前向（\(j < i\)）即可自动串行化。knot-tying 的本质：利用求值顺序的拓扑性质，将循环依赖转化为有向无环计算图。

结语

KMP 的自引用结构——\(\pi(i)\) 依赖 \(\pi(j)\)（\(j < i\)）——在惰性语言中不必绕开，可直接写为程序文本。step 将”跟随失败链”抽象为纯函数，prefix 用 scanl 将同一函数同时用于构造与使用。函数式编程”以数据流表达控制流”的一则例证。

在 Gentoo 上通过 MultiMC 启动 Minecraft 1.12.2 时，客户端在初始化阶段崩溃，错误日志里能看到 No OpenGL context found in the current thread。

[14:37:51] [Client thread/INFO]: Setting user: zLeoAlex
[14:37:52] [Client thread/INFO]: LWJGL Version: 2.9.4
---- Minecraft Crash Report ----
// Quite honestly, I wouldn't worry myself about that.

Time: 6/7/21 2:37 PM
Description: Initializing game

java.lang.ExceptionInInitializerError
	at bib.av(SourceFile:661)
	at bib.aq(SourceFile:456)
	at bib.a(SourceFile:404)
	at net.minecraft.client.main.Main.main(SourceFile:123)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.multimc.onesix.OneSixLauncher.launchWithMainClass(OneSixLauncher.java:196)
	at org.multimc.onesix.OneSixLauncher.launch(OneSixLauncher.java:231)
	at org.multimc.EntryPoint.listen(EntryPoint.java:143)
	at org.multimc.EntryPoint.main(EntryPoint.java:34)
Caused by: java.lang.ArrayIndexOutOfBoundsException: 0
	at org.lwjgl.opengl.LinuxDisplay.getAvailableDisplayModes(LinuxDisplay.java:951)
	at org.lwjgl.opengl.LinuxDisplay.init(LinuxDisplay.java:738)
	at org.lwjgl.opengl.Display.<clinit>(Display.java:138)
	... 12 more


A detailed walkthrough of the error, its code path and all known details is as follows:
---------------------------------------------------------------------------------------

-- Head --
Thread: Client thread
Stacktrace:
	at bib.av(SourceFile:661)
	at bib.aq(SourceFile:456)

-- Initialization --
Details:
Stacktrace:
	at bib.a(SourceFile:404)
	at net.minecraft.client.main.Main.main(SourceFile:123)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.multimc.onesix.OneSixLauncher.launchWithMainClass(OneSixLauncher.java:196)
	at org.multimc.onesix.OneSixLauncher.launch(OneSixLauncher.java:231)
	at org.multimc.EntryPoint.listen(EntryPoint.java:143)
	at org.multimc.EntryPoint.main(EntryPoint.java:34)

-- System Details --
Details:
	Minecraft Version: 1.12.2
	Operating System: Linux (amd64) version 5.10.27-gentoo-x86_64
	Java Version: 1.8.0_292, Gentoo
	Java VM Version: OpenJDK 64-Bit Server VM (mixed mode), Gentoo
	Memory: 498398744 bytes (475 MB) / 649592832 bytes (619 MB) up to 7635730432 bytes (7282 MB)
	JVM Flags: 2 total; -Xms512m -Xmx8192m
	IntCache: cache: 0, tcache: 0, allocated: 0, tallocated: 0
	Launched Version: MultiMC5
	LWJGL: 2.9.4
	OpenGL: ~~ERROR~~ RuntimeException: No OpenGL context found in the current thread.
	GL Caps:
	Using VBOs: Yes
	Is Modded: Probably not. Jar signature remains and client brand is untouched.
	Type: Client (map_client.txt)
	Resource Packs:
	Current Language: ~~ERROR~~ NullPointerException: null
	Profiler Position: N/A (disabled)
	CPU: <unknown>
#@!@# Game crashed! Crash report saved to: #@!@# /home/leo/.local/share/multimc/instances/1.12.2/.minecraft/crash-reports/crash-2021-06-07_14.37.52-client.txt

不过同一套环境里 Minecraft 1.16 可以正常启动，所以问题并不像是显卡驱动、Java 或 MultiMC 整体不可用。

修复

安装 x11-apps/xrandr：

# emerge -av x11-apps/xrandr

从堆栈看，崩溃发生在 LWJGL 2 查询显示模式时。补上 xrandr 后，Minecraft 1.12.2 就可以正常完成初始化。

本文与其说是一篇文章，不如说是对于这篇文章的简化与总结。

最终目的是通过引入尽可能少的外部假定，使得我们可以从一个更高的视角看高中的圆锥曲线题。

基础要素

观察一个任意二次曲线

\[ Ax^2+Bxy+Cy^2+Dx+Ey+F=0 \]

首先，我们可以做如下换元：

\[ \begin{cases} x'=\frac x z\\ y'=\frac y z\\ \end{cases} \]

其中\(z\)为任意实数，则我们可以有：

\[ Ax^2+Bxy+Cy^2+Fz^2+Dxz+Eyz=0 \]

我们均可以将其写成矩阵相乘的形式:

\[ \begin{bmatrix} x \\ y \\ z \end{bmatrix}^T \begin{bmatrix} A & B/2 & D/2 \\ B/2 & C & E/2 \\ D/2 & E/2 & F \\ \end{bmatrix} \begin{bmatrix} x \\ y \\ z \end{bmatrix} = 0 \]

故我们可以用一个实对称矩阵来表示一个二次曲线。

如果把齐次坐标中的\((x,y,z)\)暂时当成三维空间坐标，那么这个二次型描述的是一个过原点的二次锥面。 我们平时在直角坐标系中看到的圆锥曲线，可以理解为这个锥面与仿射平面\(z=1\)的截线。

另外对于一条直线，如果我们做同样的换元，我们也可以以一个向量来表述它。 但为了不与点/坐标产生歧义，我们约定后文以行向量表示直线，列向量表示点/坐标。

\[ Ax+By+C=0 \Longleftrightarrow \begin{bmatrix} A & B & C \end{bmatrix} \begin{bmatrix} x \\ y \\ z \end{bmatrix} = 0 \]

小结

基础原语

点线关系

我们都知道两相异的点可以定义出一条直线，两非平行直线也相交于一点。那么在其次坐标中会如何呢？

也可以选择把无穷远点看作两平行线交点，无穷远线看作相同两点连成的直线。 这样一样对偶。

首先看两直线的交点，若存在两直线\(l_1,l_2\)，则其交点\(p\)需要同时满足：

\[ \begin{cases} l_1p=0\\ l_2p=0\\ \end{cases} \]

可以看到这与立体几何中“求与两向量同时垂直的第三个向量”这一类问题拥有完全相同的形式。

而这一问题最简单直接的解法就是作两向量的叉乘。但出于对偶性的要求，此处定义两行矩阵叉乘得到列矩阵，列矩阵叉乘得到行矩阵。

在向量意义上，简单地，叉乘可以定义为：

\[ a\times b = \det\left(\begin{matrix} \vec i & \vec j & \vec k \\ a_1 & a_2 & a_3 \\ b_1 & b_2 & b_3 \\ \end{matrix}\right) \]

其中,\(\vec i,\vec j,\vec k\)为各方向上的单位向量。 注意到：

\[ \begin{aligned} (a\times b)\cdot a &= \det\left(\begin{matrix} \vec i & \vec j & \vec k \\ a_1 & a_2 & a_3 \\ b_1 & b_2 & b_3 \\ \end{matrix}\right) \cdot a\\ &= \det\left(\begin{matrix} a_1 & a_2 & a_3 \\ a_1 & a_2 & a_3 \\ b_1 & b_2 & b_3 \\ \end{matrix}\right) \\ &= 0 \end{aligned} \]

对于\(b\)同理，所以对于\(c=a\times b\)，任取\(\lambda_1,\lambda_2\)， 我们有：\(c\cdot (\lambda_1 a+\lambda_2 b) = 0\)

那么我们可以直接写出上述方程组的解：\(p=l_1\times l_2\)。

严格意义上是解系\(cl_1\times l_2\)，其中\(c\)是常数。

但常数\(c\)大小与解在平面直角坐标系上的对应位置无关，故此处取\(c=1\)

接下来看过两点的直线，若存在点\(p_1,p_2\)，则其连成的直线\(l\)满足：

\[ \begin{cases} lp_1 = 0 \\ lp_2 = 0 \\ \end{cases} \]

对等式两边翻转可以得到和上面一样的形式，故其解为：\(l=p_1 \times p_2\)

直线与点的线性组合

注意到，对于两直线的交点\(p=l_1\times l_2\)，对于任意\(\lambda_1,\lambda_2\)， 对两直线的线性组合\(l=\lambda_1 l_1 + \lambda_2 l_2\)有：

\[ \begin{aligned} l p &= \lambda_1 l_1 p + \lambda_2 l_2 p \\ &= 0 + 0 = 0 \end{aligned} \]

故可知其线性组合亦通过两直线的交点。这对应直角坐标系的一个直线系。

对偶地，对于两点联结的直线:\(l=p_1 \times p_2\)。对\(p_1,p_2\)的任意一个线性组合： \(p=\lambda_1 p_1 + \lambda_2 p_2\)。我们有：

\[ \begin{aligned} lp &= \lambda_1 lp_1 + \lambda_2 lp_2 \\ &= 0 + 0 = 0 \end{aligned} \]

其也在二者构成的直线上。

这与直角坐标系上类似。

平行

注意一条特殊的“直线”\(l_\infty = \begin{bmatrix} 0&0&1 \end{bmatrix}\)。

其与任意直线\(l\)的线性组合\(l' = \lambda_1 l_\infty + \lambda_2 l\)与\(l\)的交点均无法在直角坐标系内表示。

\[ \begin{aligned} l' \times l &= \lambda_1 l_\infty \times l \\ &= \lambda_1 \begin{bmatrix}-l_y & l_x & 0\end{bmatrix} \end{aligned} \]

且其在平面直角坐标系上的表示正好与\(l\)平行。故我们可以将所有与\(l\)相差任意倍\(l_\infty\)的直线认为其与\(l\)平行。

但对偶地，\(\begin{bmatrix} 0\\0\\1 \end{bmatrix}\)却代表原点。

若想要容器能够监听IPv6的接口，那么首先容器内部需要自己有个IPv6的接口。

参见docker文档

修改/etc/docker/daemon.json，合并以下JSON配置

{
  "ipv6": true,
  "fixed-cidr-v6": "2001:db8:1::/64"
}

然后自行systemctl restart docker之类重启docker daemon。

其中第一项会开启默认的bridge network的IPv6支持，下一个会在IPv6的地址池里添加对应的网段。

不过很奇怪的是，这一个网段的全部地址都会分给全局默认的bridge network，所以如果自己的docker-compose文件里有网络需要IPv6支持的，得手动分配一个网段，或者直接改用默认的全局bridge。

设置ip6tables转发流量

搞定上面一步之后，理论上你容器内expose出的端口都可以监听IPv6的接口了。但若是想让容器内部访问IPv6的外网，还需要配置ip6tables转发流量。

参见这个issue

使用如下命令转发收到的对应地址的流量。

ip6tables -t nat -A POSTROUTING -s 2001:db8:1::/64 ! -o docker0 -j MASQUERADE

但总感觉这个方案还不够完美，只能说暂时够用了。

按照题意，若设所求函数为\(F(n,m)\)，则有：

\[ \begin{aligned} F(0,m)&=0\\ F(n,0)&=0\\ F(n,m)&=F(n,m-1)+F(n-1,m-1)+1 \end{aligned} \]

生成函数

注意到其生成函数满足

\[ G(x,y)=yG(x,y)+xyG(x,y)+\frac{xy}{(1-x)(1-y)} \]

移项可得：

\[ \begin{aligned} (1-y-xy)G(x,y)&=\frac{xy}{(1-x)(1-y)} \\ G(x,y)&=y(1-y)^{-1}x(1-x)^{-1}(1-y-xy)^{-1}\\ \end{aligned} \]

解生成函数

令: \(p_1=(1-x)^{-1},p_2=(1-y-xy)^{-1}\)

则: \(G(x,y)=y(1-y)^{-1}xp_1p_2\)

\[ \frac {\partial^n G(x,y)} {\partial x^n} = y(1-y)^{-1}\frac { \partial^nxp_1p_2 } {\partial x^n}\\ \left. \frac{\partial^n G(x,y)}{\partial x^n} \right| _{x=0} = y(1-y)^{-1}\left.\frac{ \partial^nxp_1p_2 }{\partial x^n}\right| _{x=0} \]

莱布尼兹法则

注意如下同构

\[ \begin{aligned} 令a^nb^m &\sim u^{(n)}v^{(m)} \\ a^nb^m(a+b)=a^{n+1}b^m+a^nb^{m+1} & \sim u^{(n+1)}v^{(m)}+u^{(n)}v^{(m+1)}=(u^{(n)}v^{(m)})' \\ a^0b^0(a+b)^n=\sum_{i=0}^n \frac {n!} {i!(n-i)!} a^ib^{n-i}& \sim (uv)^{(n)}=\sum_{i=0}^n \frac {n!} {i!(n-i)!} u^{(i)}v^{(n-i)} \\ \end{aligned} \]

处理\(p_1p_2\)

解出

\[ \begin {aligned} \frac {\partial^np_1} {\partial x^n} &=n!(1-x)^{-n-1} \\ \frac {\partial^np_2} {\partial x^n}& =n!y^n(1-y-xy)^{-n-1}\\ \left. \frac {\partial^np_1}{\partial x^n} \right|_{x=0} &= n! \\ \left. \frac {\partial^np_2}{\partial x^n} \right|_{x=0} &= n!y^n(1-y)^{-n-1}\\ \left .\frac {\partial^n p_1p_2} {\partial x^n} \right|_{x=0}& =\sum_{i=0}^n \frac {n!}{i!(n-i)!} \left.\frac{\partial^{n-i}p_1}{\partial x^{n-i}} \frac {\partial^i p_2} {\partial x^i} \right|_{x=0} \\ &= \sum_{i=0}^n \frac {n!} {i!(n-i)!} i!y^i(1-y)^{-i-1} (n-i)! \\ &=n! \sum_{i=0}^{n} y^i(1-y)^{-i-1} \\ \end {aligned} \]

处理\(xp_1p_2\)

\[ \begin{aligned} \frac {\partial^n xp_1p_2} {\partial x^{n}}& = \sum _{i=0}^n \frac {n!} {i!(n-i)!}\frac {d^ix}{\partial x^i} \frac {d^{n-i}p_1p_2} {\partial x^{n-i}} \\ &=x \frac {\partial^n p_1p_2} {\partial x^{n}} +n\frac {d^{n-1}p_1p_2} {\partial x^{n-1}} \\ \left. \frac {\partial^n xp_1p_2} {\partial x^{n}} \right| _{x=0}& = n\left .\frac {d^{n-1}p_1p_2} {\partial x^{n-1}} \right| _{x=0}\\ &=n(n-1)! \sum _{i=0}^{n-1} y^i(1-y)^{-i-1} \\ &=n!\sum _{i=0}^{n-1} y^i(1-y)^{-i-1} \end{aligned} \]

解出\(G(x,y)\)

\[ \begin{aligned} G(x,y)&=\sum_{n=0}^\infty \frac{\left. \frac {\partial^n G(x,y)} {\partial x^n} \right|_{x=0}} {n!}x^n & 麦克劳林展开 \\ &=\sum _{n=0}^\infty \frac {n!\sum _{j=0}^{n-1}y^{j+1}(1-y)^{-j-2}} {n!} x^n & 代入\\ &=\sum_{n=0}^\infty x^n\sum _{j=0}^{n-1} y^{j+1}(1-y)^{-j-2} & 前置x^n\\ &=\sum_{n=0}^\infty x^n\sum _{j=0}^{n-1} y^{j+1} \sum_{i=0}^\infty \frac {(i+j+1)!}{i!(j+1)!} y^i & 展开(1-y)^{-j-2}\\ &=\sum_{n=0}^\infty x^n\sum _{j=0}^{n-1} \sum _{i=0}^\infty \frac {(i+j+1)!}{i!(j+1)!} y^{i+j+1} & 乘进y^{j+1}\\ &=\sum_{n=0}^\infty x^n\sum _{j=0}^{n-1} \sum _{m=j+1}^\infty \frac {m!}{(j+1)!(m-j-1)!} y^m & 换元:m=i+j+1\\ &=\sum_{n=0}^\infty x^n\sum _{j=0}^{n-1} \sum _{m=j+1}^\infty \frac {m!}{(j+1)!(m-j-1)!} y^m & 乘进来\\ &= \sum_{n=0}^\infty x^n \sum _{m=1}^\infty \sum _{j=0}^{\min(m,n)-1}\frac {m!}{(j+1)!(m-j-1)!} y^m& 交换求和顺序 \\ &= \sum_{n=0}^\infty x^n \sum _{m=1}^\infty y^m \sum _{j=1}^{\min(n,m)}\frac {m!}{j!(m-j)!} & 换元：j=j+1 \end{aligned} \\ \]

解

\[ F(n,m)=\sum _{j=1}^{\min(n,m)} \frac {m!} {j!(m-j)!} \]

定义

局部有限偏序集(locally finite poset)是一种特殊的偏序集，其满足对于所有的闭区间\([a,b]\)是有限的。

偏序关系的性质:

• 自反性：\(\forall a\in S:a\le a\)
• 反对称性：\(\forall a,b\in S: a\le b \wedge b\le a \rightarrow a=b\)
• 传递性:\(\forall a,b,c\in S: a\le b \wedge b\le c \rightarrow a\le c\)

偏序集上的区间：

• \([a,b]=\{x|a\le x \wedge x\le b\}\)
• \([a,b)=\{x|a\le x\wedge x\le b\wedge b\neq x\}\)
• \((a,b]=\{x|x\neq a\wedge a\le x\wedge x\le b\}\)
• \((a,b)=\{x|x\neq a\wedge a\le x \wedge x\le b\wedge b\neq x\}\)

Incident algebra中的元素\(f\)是一个局部有限偏序集\(S\)上的的非空区间\([a,b]\)到一个标量(实际上幺环就足够了)\(f(a,b)\)的函数。定义其构成的集合为\(X\)，其上的运算定义如下：

\[ (f*g)(a,b)=\sum_{x\in [a,b]} f(a,x)g(x,b) \]

有时我们也会在上面额外定义一个加法运算\((f+g)(a,b)=f(a,b)+g(a,b)\)，这将使得其满足一些有趣的性质。

性质

结合律

\[ \begin{aligned} ((f*g)*h)(a,b)&=\sum_{x\in[a,b]} (f*g)(a,x)h(x,b) & 定义\\ &=\sum_{x\in [a,b]}\left(\sum_{y\in [a,x]} f(a,y)g(y,x)\right)h(x,b) & 定义 \\ &=\sum_{x\in [a,b]}\sum_{y\in[a,x]} f(a,y)g(y,x)h(x,b) & 分配律\\ &=\sum_{y\in [a,b]}\sum_{x\in[y,b]} f(a,y)g(y,x)h(x,b) & 交换求和序\\ &=\sum_{y\in[a,b]}f(a,y)\sum_{x\in[y,b]}g(y,x)h(x,b) & 分配律\\ &=\sum_{y\in[a,b]}f(a,y)(g*h)(y,b) & 定义\\ &=(f*(g*h))(a,b) & 定义 \end{aligned} \]

单位元

定义函数\(\delta\)

\[ \delta (a,b) =[a=b]= \begin{cases} 1 & a=b\\ 0 & otherwise \end{cases} \]

任意\(f\in X\)，有：

\[ \begin{aligned} (f*\delta)(a,b)&=\sum_{x\in [a,b]} f(a,x)\delta(x,b)\\ &=\sum_{x\in [a,b]} f(a,x)[x=b]\\ &=f(a,b) \\ (\delta*f)(a,b)&=\sum_{x\in[a,b]}\delta(a,x)f(x,b)\\ &=\sum_{x\in[a,b]}[a=x]f(x,b) \\ &=f(a,b) \end{aligned} \]

故\(<X,*>\)构成幺半群(Monoid)， \(\delta\) 是其单位元，根据幺半群的性质可知它是唯一的单位元。

分配律

\[ \begin{aligned} (f*(g+h))(a,b)&=\sum_{x\in [a,b]} f(a,x)(g+h)(x,b) & 定义\\ &=\sum_{x\in[a,b]}f(a,x)[g(x,b)+h(x,b)]\\ &=\sum_{x\in[a,b]}f(a,x)g(x,b)+f(a,x)h(x,b) \\ &=\sum_{x\in[a,b]}f(a,x)g(x,b)+\sum_{x\in [a,b]}f(a,x)h(x,b) \\ &=(f*g)(a,b)+(f*h)(a,b)\\ &=(f*g+f*h)(a,b) \end{aligned} \]

\((f+g)*h=f*h+g*h\)类似

逆

对于\(f\in X \wedge \forall a\in S:f(a,a)\neq 0\)，我们可以构造：

\[ g(a,b)= \begin{cases} \frac 1 {f(a,b)} & a=b\\ \frac {-\sum_{x\in (a,b]} f(a,x)g(x,b)} {f(a,a)} & a \neq b\\ \end{cases} \]

因为\((a,b]=[a,b]-\{a\}\)，且\([a,b]\)是有限的，故上述定义是良构的。

那么我们有：

\[ \begin{aligned} (f*g)(a,b)=\sum_{x\in[a,b]}f(a,x)g(x,b)&=\begin{cases} f(a,b)g(a,b)=f(a,b)\frac 1 {f(a,b)}=1 & a=b\\ f(a,a)g(a,b)+\sum_{x\in(a,b]} f(a,x)g(x,b)=0 & a\neq b \end{cases} \\ &=\delta(a,b) \end{aligned} \]

另外，\(g(a,a)=\frac 1 {f(a,a)}\neq 0\)，也满足上述条件

对称地，我们可以构造其另一个方向的逆：

\[ g'(a,b)= \begin{cases} \frac 1 {f(a,b)} & a=b\\ \frac {-\sum_{x\in [a,b)} g'(a,x)f(x,b)} {f(b,b)} & a \neq b\\ \end{cases} \]

满足\((g'*f)=\delta\)

故可知\(\forall a\in S:f(a,a)\neq 0\)是\(f\)可逆的充分条件。

因为\(1=\delta(a,a)=f(a,a)f^{-1}(a,a)\)，故其亦是可逆的必要条件（\(\forall x\in\mathbb R:0\times x=0\)，以此反证)

因此，\(f\)可逆的充要条件是\(\forall a\in S:f(a,a)\neq 0\)

我们可以构造Incident algebra元素的一个子集 \(\hat X=\left\{f|f\in X\wedge \forall a\in S:f(a,a)\neq 0\right\}\)， 那么对于代数结构\(<\hat X,*>\)，有：

• 封闭性(两非\(0\)数积非\(0\))

\[ (f*g)(a,a)=f(a,a)g(a,a)\neq0 \]

• 结合律（同\(<X,*>\))
• 有单位元\(\delta\in\hat X\)
• 有逆(上述已证)

故可知\(<\hat X,*>\)构成群

亦可知 (左右逆元一致，简证如下)

\[ g=\delta*g=(g'*f)*g=g'*f*g=g'*(f*g)=g'*\delta=g' \]

与一般函数之间的关系

若定义\(F,G:S\to \mathbb R,f\in \hat X,a,b\in S\)，且二者满足下列关系:

\[ F(x)=\sum_{k\in [a,x]} G(k)f(k,x) \]

则有：

\[ \begin{aligned} \sum_{k\in [a,x]} F(k)f^{-1}(k,x) &= \sum_{k\in[a,x]} \left[\sum_{t\in [a,k]} G(t)f(t,k)\right] f^{-1}(k,x) & 定义\\ &=\sum_{k\in [a,x]}\sum_{t\in [a,k]} G(t)f(t,k)f^{-1}(k,x) & 分配律\\ &=\sum_{t\in [a,x]} \sum_{k\in [t,x]} G(t)f(t,k)f^{-1}(k,x) & 交换求和序\\ &=\sum_{t\in [a,x]} G(t) \sum_{k\in [t,x]} f(t,k)f^{-1}(k,x) & 分配律\\ &=\sum_{t\in [a,x]} G(t) \delta(t,x) & 定义\\ &=\sum_{t\in [a,x]} G(t) [t=x] = G(x) \end{aligned} \]

本质上，它是\(F(x)=F'(a,x)\)的一种等价。

对称地，也可以构造：

\[ F(x)=\sum_{k\in[x,b]} f(x,k)G(k)\\ G(x)=\sum_{k\in[x,b]}f^{-1}(x,k)F(k) \]

故我们可以在其上构造一个群作用。

偏序集与\(\zeta\)函数

定义

定义\(\zeta\in X\)为：

\[ \zeta(a,b)=[a\le b]=\begin{cases} 1 & a\le b \\ 0 & otherwise \end{cases} \]

因为在\(X\)定义时便要求\([a,b]\)构成非空区间， 而\(\exists x\in S:a\le x \wedge x\le b \Leftrightarrow a\le b\)。 因此其也可以看作\(\zeta(a,b)=1\)

因为\(\forall a\in S:\zeta(a,a)=1\)，所以\(\zeta\in \hat X\)

故可令\(\mu=\zeta^{-1}\)，则有：

\[ \mu (a,b)=\begin{cases} 1 & a=b\\ -\sum_{x\in(a,b]} \mu(x,b) = -\sum_{x\in [a,b)} \mu(a,x) & a\lt b\\ 0 & otherwise \end{cases} \]

令\(S_1,S_2\)为两偏序集，定义\(S_1\times S_2\)上的偏序关系：

\[ <a_1,b_1>\le <a_2,b_2>\Leftrightarrow a_1\le a_2 \wedge b_1\le b_2 \]

因此，我们可以定义\(S_1\times S_2\)也是一个偏序集，进一步，有限个偏序集的直积也是一个偏序集。

性质

区间\([a,b]\)中元素的个数可以表示为：

\[ \zeta^2(a,b)=\sum_{x\in[a,b]}\zeta(a,x)\zeta(x,b)=\sum_{x\in[a,b]}1=Card([a,b]) \]

设局部有限偏序集\(S_1,S_2\)，有\(S=S_1\times S_2\)。若\(\zeta_1,\zeta_2,\zeta\)分别为\(S_1,S_2,S\)上的\(\zeta\)函数，\(\mu_1,\mu_2,\mu\)分别为\(S_1,S_2,S\)上的\(\mu\)函数，\(\delta_1,\delta_2,\delta\)分别为\(S_1,S_2,S\)上的\(\delta\)函数。

\(\forall a,b\in S\wedge a\le b\)，令\(a=<a_1,a_2>,b=<b_1,b_2>\)，易得：

\[ \begin{aligned} \delta(a,b)&=[a=b] \\ &=[a_1=b_1\wedge a_2=b_2]\\ &=[a_1=b_1][a_2=b_2]\\ &=\delta_1(a_1,b_1)\delta_2(a_2,b_2)\\ \\ \zeta(a,b)&=[a\le b] \\ &=[a_1\le b_1 \wedge a_2\le b_2] \\ &=[a_1\le b_1][a_2\le b_2]\\ &=\zeta_1(a_1,b_1)\zeta_2(a_2,b_2)\\ \end{aligned} \]

进一步地，构造\(\mu'(a,b)=\mu_1(a_1,b_1)\mu_2(a_2,b_2)\)，则有:

\[ \begin{aligned} (\mu'*\zeta)(a,b) &= \sum_{x\in [a,b]} \mu'(a,x)\zeta(x,b) & 定义\\ &=\sum_{x_1\in [a_1,b_1] \wedge x_2\in [a_2,b_2]} \mu_1(a_1,x_1)\mu_2(a_2,x_2)\zeta_1(x_1,b_1)\zeta_2(x_2,b_2)& 展开 \\ &=\sum_{x_1\in [a_1,b_1]}\sum_{x_2\in [a_2,b_2]} \mu_1(a_1,x_1)\zeta_1(x_1,b_1) \mu_2(a_2,x_2)\zeta_2(x_2,b_2) & 拆开x_1,x_2的求和\\ &=\sum_{x_1\in [a_1,b_1]}\mu_1(a_1,x_1)\zeta_1(x_1,b_1) \sum_{x_2\in [a_2,b_2]} \mu_2(a_2,x_2)\zeta_2(x_2,b_2) & 分配律\\ &= (u_1*\zeta_1)(a_1,b_1) (u_1*\zeta_2)(a_2,b_2) \\ &= \delta_1(a_1,b_1)\delta_2(a_2,b_2)\\ &=\delta(a,b) \end{aligned} \]

故\(\mu'=\zeta^{-1}=\mu\)，即:\(\mu(a,b)=\mu_1(a_1,b_1)\mu_2(a_2,b_2)\)

反演

二项式反演

设\(n\)次多项式\(p_n(x)=x^n,q_n(x)=(x-1)^n\)，则有：

\[ \begin{aligned} q_n(x)&=\sum_{k=0}^n \binom n k (-1)^{n-k} x^k \\ &= \sum_{k=0}^n \binom n k (-1)^{n-k} q_k(x) \\ \\ p_n(x) &= ((x-1)+1)^n\\ &= \sum_{k=0}^n \binom n k (x-1)^k \\ &= \sum_{k=0}^n \binom n k q_k(x) \end{aligned} \]

可以定义\((n+1)\times (n+1)\)方阵\(A,B\)（下标从0开始）：

\[ \begin{aligned} A_{i,j}&= \binom j i (-1)^{b-a} \\ B_{i,j}&= \binom j i \\ \end{aligned} \]

可知：

• \(A,B\)均为单位上三角矩阵
• 构造\(p,q\)的系数向量可知：\(AB=BA=I\)，即\(A,B\)互为逆矩阵。

令\(f(a,b)=A_{a,b},g(a,b)=B_{a,b}\)。由于\(A,B\)均为单位上三角矩阵， 故\(f,g\)可以被看作以\([0,n]\)整数区间，小于等于作为偏序关系的Incident algebra中的元素。 其可以和\((n+1)\times (n+1)\)矩阵上乘法同构。

\[ \begin{aligned} (f*g)(a,b)&=\sum_{x\in [a,b]} f(a,x)g(x,b) \\ &=\underbrace{\sum_{x\in [0,a)} f(a,x)g(x,b)}_{f(a,x)=0} +\sum_{x\in [a,b]} f(a,x)g(x,b) +\underbrace{\sum_{x\in (b,n]} f(a,x)g(x,b)}_{g(x,b)=0}\\ &=\sum_{x\in [0,n]} f(a,x)g(x,b) \\ &=(AB)_{a,b}=I_{a,b}\\ &=[a=b]=\delta(a,b) \end{aligned} \]

所以\(f,g\)互逆。

按照Incident algebra与一般函数之间的关系，对\([0,n]\)上一整数\(a\)，下两式定义等价：

\[ \begin{aligned} F(x)&=\sum_{k\in [a,x]}G(k)g(k,x)=\sum_{k\in[a,x]} \binom x k G(k) \\ G(x)&=\sum_{k\in[a,x]} F(k)f(k,x)=\sum_{k\in[a,x]}(-1)^{x-k} \binom x k F(k) \\ \end{aligned} \]

特别地，对于\(a=0\)，我们有：

\[ \begin{aligned} F(x)&=\sum_{k\in [0,x]}G(k)g(k,x)=\sum_{k\in[0,x]} \binom x k G(k) \\ G(x)&=\sum_{k\in[0,x]} F(k)f(k,x)=\sum_{k\in[0,x]}(-1)^{x-k} \binom x k F(k) \\ \end{aligned} \]

一般，我们将此称作二项式反演公式。

莫比乌斯反演

将正整数集\(\mathbb N^+\)上的整除作为偏序关系。我们可以得到另一个Incident algebra实例。

其中：

\[ \begin{aligned} \zeta(a,b)&=\begin{cases} 1 & a | b \\ 0 & otherwise\\ \end{cases} \\ \\ \mu(a,b)&=\begin{cases} 1 & a=b \\ -\sum_{a\mid x \wedge a\neq x \wedge x\mid b} \mu(x,b) & a\mid b \wedge a\neq b \\ 0 & otherwise \end{cases} \end{aligned} \]

另外，通过数学归纳，注意到：

\[ \begin{aligned} \mu(ka,kb) &= \begin{cases} 1 & ka = kb &\Leftrightarrow a=b \\ -\sum_{ka\mid kx \wedge ka\neq kx \wedge kx\mid kb} \mu(kx,kb) & ka \mid kb \wedge ka\neq kb & \Leftrightarrow a \mid b\wedge a\neq b \\ 0 & otherwise \end{cases} \\ &= \mu(a,b) \end{aligned} \]

而且，当\(a \mid b\)时，\(\mu(a,b)\)有意义（或者说可能不为\(0\)）。 故我们可以构造函数\(\mu'(\frac b a) = \mu(1,\frac b a)=\mu(a,b)\)，即可简化计算。 那么，我们有：

\[ \mu'(p)=\begin{cases} 1 & p=1 \\ -\sum_{x\neq 1 \wedge x\mid p} \mu'(\frac p x) & otherwise \end{cases} \]

这个函数又被称作经典莫比乌斯函数。

按照Incident algebra与一般函数之间的关系，取下限\(a=1\)(故任取\(k\)均与\(a\)整除)，我们有下述两等价定义：

\[ \begin{aligned} F(x) &= \sum_{k\mid x} G(k) \\ G(x) &= \sum_{k\mid x} F(k) \mu(k,x) = \sum_{k\mid x} F(k) \mu'(\frac x k) \end{aligned} \]

其中称下式为上式的莫比乌斯反演公式。

如果使用 Haskell 语言的话，本题可以使用 containers 包中的 Data.Sequence 秒杀，因为 Seq 本身便是一颗可持久的 FingerTree，用树套树的话，便可以做到一个非常优异的时间/空间复杂度。

惰性求值但是的确是在线算法，可以撤回撤回（返回撤回前的时间点，不知道算不算）。

{-# OPTIONS_GHC -O2 #-} -- 强开O2
import           Control.Monad
import           Data.Functor  (($>))
import           Data.Maybe    (fromJust)
import           Data.Sequence
import           Text.Printf   (printf)

(!) = index -- 强行把函数变成运算符

main :: IO ()
main = do
    n <- readLn :: IO Int -- 读取第一行的整数n，需要手动指定类型，不然会有歧义
    fromList [fromList []] `foldM_'` [1..n] $ \seq _ -> do -- 函数的中缀用法，注意初始的历史记录应该有一个空串
        [[op],c] <- words <$> getLine -- 读取每一行的指令，此处使用了模式匹配（见下文）
        case op of
            'T' -> pure $ (seq!0 |> head c) <| seq  -- 历史记录第0号（即上一次修改的结果）后插入当前字符，然后前插入历史记录
            'U' -> pure $ (seq!read c) <| seq -- 将参数读取为整数（此处无需标明，因为函数有明确的类型限制，编译器将自动推导） 取历史记录的相应项，前插入历史记录
            'Q' -> printf "%c\n" (seq!0!(read c-1))  $> seq -- 将上一次修改的结果的相应位置的字符打印出来，并返回本身的历史记录（($ >)运算符特性）

foldM_' z l f = foldM_ f z l -- 调整参数位置，追求好用

代码十分朴素。

• 空间复杂度: \(O(n\log n)\) ，其中 \(n\) 为总字符数（不是很紧确，但是..能过）
• 每次从后面添加字符，时间复杂度: \(O(1)\)
• 每次打印第 \(i\) 个字符，时间复杂度: \(O(\log (\min (i,n-i)))\) ，其中 \(n\) 为当前字符数， \(i\) 为需要打印的字符位置。
• 每次撤销，时间复杂度: \(O(\log (\min(i,n-i)))\) ，其中 \(n\) 为总修改次数，\(i\) 为撤销步数。
• 总时间复杂度可估算为: \(O(n\log n)\)

如果想看 FingerTree 原理或者希望以此为契机了解一下 Haskell 的话参见后文。也可以参考论文原文。

参考文献：

• Hinze R, Paterson R. Finger trees: a simple general-purpose data structure[J]. Journal of functional programming, 2006, 16(2): 197-217.
• https://hackage.haskell.org/package/fingertree
• https://hackage.haskell.org/package/container
• https://wiki.haskell.org/Functional_dependencies

FingerTree概述

说到可持久化，就得想到 Immutable ，说到 Immutable ，自然而然就是函数式编程语言，说到函数式编程语言，自然而然就是 Haskell ，而说到纯函数式的数据结构，自然而然也绕不开 FingerTree 。

FingerTree 是一种理论上非常通用也非常高效的数据结构，插入头/尾都只需要摊还 \(O(1)\) 的时间， 而对其的“随机”访问只需要 \(O(\log \min(i,n-i))\)

其中 \(i\) 为你访问的下标，所以可以看出访问头/尾其实也是 \(O(1)\) 。

关于它的论文可以戳这里。当然这不是最早的一篇，但我看的就是这篇，才疏学浅没办法在这里列更早的。

但为什么说“理论”上呢，就和斐波那契堆类似，他的常数比较大。（主要因素是Immutable的语言必须维护一个GC来做垃圾回收。）

[更新] 事后我拿 Rust 实现了一遍 FingerTree ，发现其时空消耗均比 Haskell 大，故可认为并非GC原因。

不过也有可能是我写的常数就是大呢（

详见：提交记录

那为什么说“随机”呢？因为完全泛化的 FingerTree 的访问依赖的不是下标，而是一个被称作 \(Measure\) （测度？我也不知道怎么翻译，所以直接拉的原文）的幺半群 (Monoid)。

先解释一下什么是幺半群。幺半群是一个集合 \(X\) 和集合里元素之间一个二元运算 \(\cdot:X\times X\to X\) 的统称（有序对），并要求：

• 二元运算满足结合率，即 \(\forall x,y,z\in X: (x\cdot y)\cdot z = x\cdot (y\cdot z)\)
• 集合 \(X\) 中存在一个单位元，即 \(\exists e:(\forall x: e\cdot x=x\cdot e=x)\)

比如说自然数集 \(\mathbb N\) 与其上的加法 \(+\) 便可以构成一个幺半群（后面我们可以用这条性质做出传统意义上的下标索引）

进一步，我们可以定义两个幺半群的笛卡尔积也是一个幺半群，即对于 \((X,\cdot_1)\) 与 \((Y,\cdot_2)\) ， 我们可以定义一个运算 \(\cdot:(X\times Y) \times (X\times Y)\to X\times Y\) ，并使其满足结合率。定义方法如下：

• \((x_1,y_1) \cdot (x_2,y_2)=(x_1\cdot_1 x_2,y_1\cdot_2 y_2)\)

我们可以用这个条件来拓展我们索引方式（比如论文原文里可以看到用 \(\max\) 幺半群实现的最大堆/优先队列）

Haskell基础

首先，用 Haskell 的方式定义一下幺半群（实际上这个标准库有，不需要自己实现）

class Monoid a where
    mempty :: a
    mappend :: a -> a -> a

与常用的C-like语言中的 class 不同，在 Haskell 中，这代表一个类型类，是对类型 a 的一种约束，类似于接口/抽象类一类的概念。

然后是 Foldable ，它代表我们可以在一个类型(其实是一个 Kind ，拿类型生成类型的类型构造子)上按照某种顺序去遍历。类似于 Java 8 中的 reduce 。注意这个其实标准库也有，只是提一嘴。

class Foldable f where
    foldl :: (b -> a -> b) -> b -> f a -> b
    foldr :: (a -> b -> b) -> b -> f a -> b

还需要提一嘴的是 Haskell 最基本的数据结构，链表(实际上还是单端链表，所以只提供最基本的功能)。

data [] a = [] | a:([] a)

它意味着一个 \(a\) 类型的链表有两种构造方式，一种是空链表，令一种是一个 \(a\) 类型的元素用 : 运算符拼接一个 \(a\) 类型的链表。（对，中缀构造函数， C++ 是做不到这点的。）

另外还有一个比较常用的 data 被称作 Maybe ，它的定义等价于：

data Maybe a = Nothing | Just a

想一想，这个定义是什么意思？

从这里开始就可以看到 Haskell 的一些特性了。Haskell 中的数据结构并非由字段和操作构成，而是由几类数据的组合组合而成。当然它是可以实现上面的俩 class 的。这里我不做过多介绍。

FingerTree 实现（简要复述论文）

首先是一些基础定义。

-- | Things that can be measured.
class (Monoid v) => Measured v a | a -> v where
    measure :: a -> v

data Node v a = Node2 v a a | Node3 v a a a
data Digit a
    = One a
    | Two a a
    | Three a a a
    | Four a a a a
data FingerTree v a
     = Empty
     | Single a
     | Deep v (Digit a) (FingerTree v (Node v a)) (Digit a)

这里开始出现了最开始提到的 Measured，此处将其抽象为一个可以将某个元素测量出一个 Monoid 的函数。但这个 Monoid 有大用。

此处出现的语法使用了一个 Functional Dependencies 的拓展(可参见 wiki )。大概意思是保证对于一个类型，我只能把它 measure 成一种其他类型，不能 measure 成另一种。也就是说，类型 a 到类型 v 是一个单射。

可以看到这里的 \(v\) 类型变元，这个就是稍后要维护的 Monoid，也是索引数据的依据。

可以看到一个 Node 可能有2-3个元素，保证一个 Digit 有 1-4 个元素。(图中也可以看出，不过引用链接是国外的可能比较卡) Digit 和 Node 也可以相互转化，拼接，但后文不再说明实现。

还有一点值得注意的是，如果当前这一层的 FingerTree 缓存的是 a 类型的话，那么下一层所缓存的就是 Node a 类型了。这也就意味着，下层比上层“厚实”。

自然地，我们可以给 Node 和 Digit 来个 Foldable，但具体部分就不展示了。

那么我们应该如何方便的维护这个 \(v\) 类型的数据呢，答案是换一种方式重写构造函数。

deep ::  (Measured v a) =>
      Digit a -> FingerTree v (Node v a) -> Digit a -> FingerTree v a
 deep pr m sf = Deep ((measure pr `mappend` measure m) `mappend` measure sf) pr m sf

此处的 mappend 是 Haskell 里函数的中缀用法（就是把函数当运算符用）。

此时，我们不需要每次构造树的时候手动维护 \(v\) 类型的数据了，只需要简单把 Deep 替换为 deep 即可。

另外，关于 Measured 本身，我们也可以让 FingerTree 也是 Measured，具体代码如下：

instance (Measured v a) => Measured v (FingerTree v a) where
      measure Empty           =  mempty
      measure (Single x)      =  measure x
      measure (Deep v _ _ _)  =  v

注意到此处使用了 Haskell 被称作模式匹配 (Pattern Match)的特性。（不是模式串匹配啦）把数据结构重新打回了它最开始定义时的样子，并且怎么被构造的就怎么被匹配。(真-打回娘胎)

模式匹配不止可以匹配一层，也可以匹配多层。至于用途嘛..请自行搜索 Haskell 的 20 行红黑树。

可以看到对于 Deep 一类，我们直接使用了其缓存的 \(v\) 类型字段，这样就可以在 \(O(1)\) 时间内得到一颗子树的测度。(如果对单个元素的 measure 也是 \(O(1)\) 的话)

当然 Node 和 Digit 也可以是 Measured，具体实现请自行脑补。

接下来是前插入的定义。

infixr 5 <|
-- | /O(1)/. Add an element to the left end of a sequence.
-- Mnemonic: a triangle with the single element at the pointy end.
(<|) :: Measured v a => a -> FingerTree v a -> FingerTree v a
a <| Empty              =  Single a
a <| Single b           =  deep (One a) Empty (One b)
a <| Deep v (Four b c d e) m sf
    = Deep (measure a `mappend` v) (Two a b) (node3 c d e <| m) sf
a <| Deep v pr m sf     = Deep (measure a `mappend` v) (consDigit a pr) m sf

注意到这里我们自定义了一个运算符，它的优先级是5,并且是右结合的。（不愧是 Haskell，轻易做到了 C++ 做不到的事情。）

consDigit 就是给 pr 前插入一个元素。当然，如果是满的肯定会报错，但是在它之前的模式匹配会避免这一点发生。

类似地还有后插入

infixl 5 .
-- | /O(1)/. Add an element to the right end of a sequence.
-- Mnemonic: a triangle with the single element at the pointy end.
(|>) :: (Measured v a) => FingerTree v a -> a -> FingerTree v a
Empty |> a              =  Single a
Single a |> b           =  deep (One a) Empty (One b)
Deep v pr m (Four a b c d) |> e
    = Deep (v `mappend` measure e) pr (m |> node3 a b c) (Two d e)
Deep v pr m sf |> x     = Deep (v `mappend` measure x) pr m (snocDigit sf x)

可以看到代码基本上和前插入是对称的。（数据结构本身也是对称的，所以这里写作 snocDigit，其中 snoc 正是 cons 的回文）后面还有很多对称的结构，均以左半部分为例。

然后是一个分割原语（当然右侧也是对称的，可以看到又出现了运算符构造子。）

-- | View of the left end of a sequence.
data ViewL s a
     = EmptyL        -- ^ empty sequence
     | a :< s a      -- ^ leftmost element and the rest of the sequence

-- | /O(1)/. Analyse the left end of a sequence.
viewl :: (Measured v a) => FingerTree v a -> ViewL (FingerTree v) a
viewl Empty                     =  EmptyL
viewl (Single x)                =  x :< Empty
viewl (Deep _ (One x) m sf)     =  x :< rotL m sf
viewl (Deep _ pr m sf)          =  lheadDigit pr :< deep (ltailDigit pr) m sf

rotL :: (Measured v a) => FingerTree v (Node v a) -> Digit a -> FingerTree v a
rotL m sf      =   case viewl m of
    EmptyL  ->  digitToTree sf
    a :< m' ->  Deep (measure m `mappend` measure sf) (nodeToDigit a) m' sf

lheadDigit 和 ltailDigit 是指一个 Digit 的最左边元素和剩下的元素，当然如果 Digit 只有一个元素的画 ltail 就会报错，但是前面的模式匹配也避免了这一点。

digitToTree 是一个将 Digit 变为一个 FingerTree 的函数，因为也就常数个元素，所以时间复杂度 \(O(1)\)。

nodeToDigit 也是跟名字异样，将一个 Node(2或3个元素)变成一个 Digit。

case ... of 语法是 Haskell 类似于 C++ 的 switch 语句的地方。不同之处在于其是有返回值的，更像一个多出口的 ?: 运算符。

viewl 函数构造一颗树的左分割，将其切割出最左元素（若没有则用 EmptyL 构造子）。

另外值得注意的是此处的 viewl 和 rotL 是互相调用，也是一种递归哦。

当然其有对称实现 viewr。但不在此赘述。

有了 viewl 之后，我们就可以处理一些 prefix (即 Deep 中第一个 Digit)为空/不存在时对树的构造了

deepL :: (Measured v a) =>
    Maybe (Digit a) -> FingerTree v (Node v a) -> Digit a -> FingerTree v a
deepL Nothing m sf      =   rotL m sf
deepL (Just pr) m sf    =   deep pr m sf

此处的 Nothing 就是指 prefix 不存在的情况，此时需要左旋一波。

当然对于 Just 的情况就直接调用上面的deep了。

那么什么情况下左边/右边为空呢？当然是做分割的时候了。

那么终于，要迎来最后的部分了，搜索，与分割。

data Split t a = Split t a t
data SearchResult v a
    = Position (FingerTree v a) a (FingerTree v a)
        -- ^ A tree opened at a particular element: the prefix to the
       -- left, the element, and the suffix to the right.
   | OnLeft
       -- ^ A position to the left of the sequence, indicating that the
       -- predicate is 'True' at both ends.
   | OnRight
       -- ^ A position to the right of the sequence, indicating that the
       -- predicate is 'False' at both ends.
   | Nowhere
       -- ^ No position in the tree, returned if the predicate is 'True'
       -- at the left end and 'False' at the right end.  This will not
       -- occur if the predicate in monotonic on the tree.

search :: (Measured v a) =>
    (v -> v -> Bool) -> FingerTree v a -> SearchResult v a
search p t
  | p_left && p_right = OnLeft
  | not p_left && p_right = case searchTree p mempty t mempty of
         Split l x r -> Position l x r
  | not p_left && not p_right = OnRight
  | otherwise = Nowhere
   where
     p_left = p mempty vt
     p_right = p vt mempty
     vt = measure t

searchTree :: (Measured v a) =>
     (v -> v -> Bool) -> v -> FingerTree v a -> v -> Split (FingerTree v a) a
searchTree _ _ Empty _ = illegal_argument "searchTree"
searchTree _ _ (Single x) _ = Split Empty x Empty
searchTree p vl (Deep _ pr m sf) vr
  | p vlp vmsr  =  let  Split l x r     =  searchDigit p vl pr vmsr
                   in   Split (maybe Empty digitToTree l) x (deepL r m sf)
  | p vlpm vsr  =  let  Split ml xs mr  =  searchTree p vlp m vsr
                        Split l x r     =  searchNode p (vlp `mappend` measure ml)       xs (measure mr `mappend` vsr)
                   in   Split (deepR pr  ml l) x (deepL r mr sf)
  | otherwise   =  let  Split l x r     =  searchDigit p vlpm sf vr
                   in   Split (deepR pr  m  l) x (maybe Empty digitToTree r)
  where
    vlp     =  vl `mappend` measure pr
    vlpm    =  vlp `mappend` vm
    vmsr    =  vm `mappend` vsr
    vsr     =  measure sf `mappend` vr
    vm      =  measure m

此处只列出了 searchTree 这一子函数，且十分冗长，其实 searchNode 和 searchDigit 也类似，本质上就是为了找到第一个使得对于输入的函数，在值左边的分割为假，右边的为真。一步步细化下去而已。

maybe 函数的类型是 b -> (a -> b) -> Maybe a -> b，看类型签名基本可以猜到功能。所以也不细说。

这里可以看到 where 从句。where 从句和常量定义很像，但却是后置的，而且具有惰性求值的特征（对，自带Lazy，而且实际上如果不做额外标注，整个 Haskell 程序都是惰性求值的）。

到这一步为止，我们只差将原本用于索引的下标整成 Monoid 就好了，并且其和任意类型均可以构成 Measured（因为单个元素大小都是1）

newtype Size = Size Int
newtype Elem a = Elem a
instance Monoid Size where
	mempty = Size 0
	mappend (Size a) (Size b) = Size (a+b)
instance Measured Size (Elem a) where
	measure _ = Size 1

这里注意，由于我们之前使用了 Functional Dependencies，所以我们需要新建一个类型作为容器来容纳我们的类型。所以此处使用了不会导致额外开销的 newtype 关键字替代 data（在当前环境下，二者语义一致）

接下来就可以实现 Seq 了，具体可以参考 container 包的源代码或者论文原文。

1. RPI3B和RPI3B+用的同一款固件，可以通用

2. 用个稍微好一点点的读卡器吧，毕竟也有几百M

   我Surface上的读卡器插两次就扫不到设备了，十分蛇皮

   USB 读卡器又有点点接触不良，刷个几百k就一个读写错误，心累.jpg

3. 如果希望能完全使用TF卡的空间，单纯的resize分区是不行的，还要记得fsck然后跑一遍resize2fs

   不知道为什么我先配完系统之后改大小然后就崩了。

   但是如果在第一次启动前把分区大小调好就没事。

4. WiFi的启用需要等到第一次启动以后，第一次启动的时候会生成配置文件，之后改改就好

5. 如果需要用USB to TTL之类的操作连接PI，那么还要改config.txt，没改成功过，不细说

配置环节

1. 信道填自动就搜不到WiFi了不知道咋回事儿
   • 802.11ac的52-64信道在国内要求DFS/TPC(动态频率选择和传输功率控制)，可能是因为树莓派并没有相应的功能还往这几个信道上挤导致的。
2. wan的接口名一定要小写，一定要小写，一定要小写，或者手动修改为防火墙wan区域
3. 刚配好时opkg镜像不能用https，只能走http，因为里面套件还不全

网络配置

多拨

• 使用mwan3插件
• 前面接个AP模式的路由器
• 使用ip link add link eth0 name vethX type macvlan来添加虚拟网口
• 其中留一个虚拟网口接br-lan接口，其余每个一个PPPoE接口
• 设置mwan3的时候一定要填测试IP，让相应的策略能自动开启