Clouder's Blog

一夜速成密码学

Thu, 07 Nov 2024 18:42:14 GMT

后天下午要考试了，或者说明天下午。所以开始学密码学。明日事今日毕。

言简意赅，点到为止，力求及格。

PS：笔记没写完，但及格问题不大。

1 密码学基础

了解即可。

推动近代密码学发展的重要理论著作：1949 香农《The Communication Theory of Secret Systems》

推动现代密码学中公钥密码思想的重要论文：1976 Diffie & Hellman 《密码学的新方向》非对称密码学。

2 古典密码学

代换密码都无法避免统计分析攻击。

单字母单表密码
- 最简单的加密，普遍形式 $C_i=f(M_i),M_i=f^{-1}(C_i)$ ， $f$ 为固定一一映射。
- Caesar：
  - $C_i=(M_i+k)\bmod 26, M_i=(C_i-k)\bmod 26$ ，约定密钥 $k$ .
- Affine Cipher：
  - $C_i=(aM_i+b)\bmod 26, M_i=a^{-1}(C_i-b)\bmod 26$ ，约定密钥 $a,b$
- Mixed Alphabetic Cipher：
  - 给定字母一一映射，进行加密。
单字母多表密码
- 让 $f$ 随着输入变动。即 $f_i=F(i,M_0,\cdots,M_{i-1})$ ， $C_i=f_i(M_i)$ .
- Vigenere
  - $C_i=(M_i + k_{i \bmod l})\bmod 26$ ， $M_i=(C_i - k_{i \bmod l})\bmod 26$
  - 将 Caesar 的 $k$ 改成了依赖于字母位置的 $k_{i\bmod l}$ .
- Rotor Machine 轮转密码机
  - 具体原理比较抽象，大概就是每输入一个字母就会改变若干转子状态，从而换一个表。需要输入初始状态和密文进行解密。
- One Time Pad(OTP) 一次一密
  - 密钥和明文一样长，密钥不可重复使用，一次一密。
  - $C_i =M_i\oplus K_i, M_i=C_i \oplus K_i$
  - 可以提供 perfect security,但不实用。
    - 产生大规模的随机密钥是困难的。
    - 对于每一条发送的消息，需要提供发送方和接收方等长度的密钥，导致庞
      大的密钥分发(key distribution)问题。
  - 若密钥重复使用，若攻击者可发动选择明文攻击，则可获得密钥解密其他密文。
  - 若获取明文异或结果，可利用信息攻击。
多字母密码
- Playfair
  - 挑选单词作为密钥。字母去重后依次填入矩阵。ij 当成一个字母。(因为 5*5=25<26)
  - 剩余格按顺序填入未出现字母，得密钥矩阵。
  - 加密：
    - 明文依次取两字符为一组。若一组字母相同，中间插入 x
    - 在矩阵上：
      - 若两字符同行，取各自右侧字符 $c_{i,j+1 \bmod 5}$ .
      - 若两字符同列，取各自下侧字符 $c_{i+1 \bmod 5,j}$ .
      - 否则，取构成的子矩阵中，各自的对角字符。取第一个的行、第二个的列，及第二个的行、第一个的列。
      - 如：ra 变 mr，ab 变 bi，er 变 km.
  - 解密：
    - 两两分组解密。
    - 同行取各自左侧，同列取各自上侧。
    - 否则，子矩阵中，取第一个的行、第二个的列及第二个的行、第一个的列。
    - 删去 x. 判别 i/j.
    - 合并。
- Hill 密码(矩阵加密)
  - $\mathbf{C}=\mathbf{KM}\bmod 26,\mathbf{M}=\mathbf{K}^{-1}\mathbf{C}\bmod 26$ ， $\mathbf{K}\in\mathbb{R}^{n\times n}$
置换密码
- 打乱明文的顺序。
- 栅栏密码
  - 原密码串 $M=M_0M_1\cdots M_{n-1}$ .
  - 加密串 $C=M_0M_2\cdots M_1 M _3\cdots$
  - 例如：012345 变成 024135
- 列移位密码
  - 固定列宽 $m$ ，明文依次填入宽为 $m$ 的矩阵。
  - 给定长为 $m$ 的置换作为密钥，交换矩阵的列，读出交换后的矩阵。
  - 注意：加密按行写置换后按列读，解密按列写逆置换后按行读。

密码学攻击方法
- 穷举攻击：增大密钥。
- 统计分析攻击：减少明文与密文的统计相关性。
- 解密变化攻击：算法复杂化。
密码攻击环境
- 唯密文攻击(COA)：只知道密文。
- 已知明文攻击(KPA)：只知道部分明文和对应密文。
- 选择明文攻击(CPA)：选择一些明文得到对应密文。
- 选择密文攻击(CCA)：选择一些密文得到对应明文。
密码学五大性质
- 机密性：保密信息不泄露，加密算法保证。
- 完整性：检测篡改。指纹校验。
- 认证性：身份(来源和消息本身)确认(密钥和认证函数相结合)。
- 不可否认性：无法否认信息生成、签名、接收行为。（数字签名）
- 可用性：信息资源可以随时提供服务。

3 数据加密标准(DES)

对称密码分为分组密码和流密码。

分组密码：对明文消息分组，按分组加密。
流密码：对明文信息按比特或字节逐个加密。

分组密码设计准则
- 目标：阻止分析出密钥和明文。
- 混淆(confusion)：使密文和密钥的统计关系变得复杂。即使攻击者得到密文的统计关系，也无法得到密钥。
- 扩散(diffusion)：将明文的统计特性散布到密文中，明文的每位影响密文多位，密文无法获得明文统计信息。
乘积密码思想：顺序执行多个密码变换(Substitution & Permutation)，产生的密码系统强度高于每个基本密码系统。
- Substitution 对应 S-box，Permutation 对应 P-box.
- S-box 起 confusion 效果，P-box 起 diffusion 效果。
Feistel 网络
- 每组明文分成左右两半 $\text{LE}_0,\text{RE}_0$ .
- 第 $i$ 轮输入为 $\text{LE}_i,\text{RE}_i$ ，则：
  - $\text{LE}_i=\text{RE}_{i-1}$ ， $\text{RE}_i = \text{LE}_{i-1}\oplus F(\text{RE}_{i-1},K_i)$
  - 其中 $K_i$ 为第 $i$ 轮子密钥。
  - $F$ 为轮函数(Round Function).
- Substition: 每轮中， $\text{RE}_{i-1}$ 经过轮函数，再与 $\text{LE}_{i-1}$ 异或
- Permutation: 代换完成后，交换左右两边。
- 解密：
  - 基本一致，但使用子密钥的次序相反。先用 $K_n$ ，再用 $K_{n-1},\cdots$
  - $\text{LD}_1 = \text{RD}_0 = \text{LE}_n=\text{RE}_{n-1}$ ， $\text{RD}_1=\text{LD}_0\oplus F(\text{RD}_0,K_n) = \text{RE}_n \oplus F(\text{LE}_n,K_n)=\text{LE}_{n-1}$
  - 利用二次异或抵消。
  - 最终 $\text{LD}_n=\text{RE}_0,\text{RD}_n=\text{LE}_0$ ，交换即可得到原始明文。
- 参数与特性关联：
  - 分组长度：越长越安全，但计算越慢。
  - 密钥长度：越长越安全，但越慢。
  - 迭代轮数
  - 子密钥生成算法
  - 轮函数

DES，极为流行的数据加密标准。分组密码算法。

加密
- 64bits 明文。56bits key.
- 初始置换重排序。
- 进行 16 轮变换。
- 结果左右交换，进行逆初始置换得到 64bits 密文。
- 子密钥生成：
  - 初始时，密钥进入置换函数。
  - 每一轮，通过左循环移位。置换选择产生一个 subkey.
  - 左循环移位经过进入下一轮输入。
- 每轮加密：输入 64bits 和 48bits subkey
  - $L_i=R_{i-1},R_i=L_{i-1}\oplus F(R_{i-1},K_i)$ .
  - 根据拓展表，将 $R_{i-1}$ 重复某些 bits，扩展为 48bits. 与 subkey 异或，结果通过 S-box 产生 32bits，再通过 P-box 即为 $F(R_{i-1},K_i)$ .
  - Substitution 有 8 个 S-box,输入 6bits,输出 4bits. 最高位最低为选行，其余选列。
  - P-box 就是一个 Permutation.
雪崩效应：明文或密钥的某一位变化，导致很多位发生变化。DES 具有雪崩效应。

对应的若干种攻击方式：

穷举攻击，密钥 $2^{56}$ .
差分密码分析：攻击迭代分组密码的选择明文攻击。
- 通过分析明文对的差值对密文对的差值的影响来恢复某些密钥比特。
- 给定明文差分 $\Delta_P=P_1 \oplus P_2$ ，密文差分 $\Delta_C =C_1\oplus C_2$ 的概率分布可能泄露密钥比特信息。
- DES 可以抵抗。
线性分析：已知明文攻击。
- 寻找能够刻画分组密码整体变换的有效线性近似。
- DES 可以抵抗。
穷举攻击仍是最直接有效的 DES 攻击方式。

DES 弱密钥：加密两次恢复原文的密钥。弱密钥使得 DES 中每一轮的子密钥相同。
四个弱密钥：

0000000 0000000
0000000 FFFFFFF
FFFFFFF 0000000
FFFFFFF FFFFFFF

多重 DES：多个密钥加密多次。解密时按逆序解密即可。

二重 DES：用两个密钥顺序加密两次，强度并不等价于 112bits,因为可以中途相遇攻击。类似于双向搜索。给定明文密文，一边枚举加密结果，存入表中。另一边枚举解密结果，寻找表中匹配项即可。

三重 DES 三次加密可使得明文攻击量级增加到 $2^{112}$ . 但密钥长度变成了 168bits.
一种方法为：使用两个密钥，K1 加密-K2 解密-K3 加密。简记为 EDE.

4 高级加密标准(AES)

明文密文分组长度为 128bits.
无 Feistel 结构。
密钥长度可变，有 AES-128 AES-192 AES-256 等。不同长度有对应不同轮数。

AES 流程：

代换和置换都将整个分组当成单一矩阵处理。
只在轮密钥加中使用密钥。算法以轮密钥加开始，以轮密钥加结束。
加密算法和解密算法不同。

将 16bytes 看作 $4\times 4$ 的状态矩阵。
密钥看作 $4\times4$ 或 $4\times6$ 或 $4\times 8$ 的状态矩阵。

字节代换就是一个映射而已。不过 AES 的 S-box 有代数意义。
输入的 8bits 考虑为有限域 $GF(2^8)$ 的一个元素，求逆 $B_i'$ 后仿射变换得到 $B_i$ .

行移位很简单：第一行不变，第二行循环左移 1,第三行循环左移 2,第四行循环左移 3.

列混淆：状态矩阵左乘上一个固定的混淆矩阵。乘法在有限域 $GF(2^8)$ 上进行，使用的固定不可约多项式为 $x^8+x^4+x^3+x+1$ .

轮密钥加则为：子密钥矩阵异或当前状态矩阵，得到更新的状态矩阵。

子密钥通过输入密钥扩展得来。若轮数为 $n$ ，则生成 $n+1$ 个子密钥！

AES 密钥拓展以 32bits 1word 为单位。
所有子密钥存储在一个密钥拓展数组 $W$ 中。对于 10 轮的 AES128,生成 44 个 words, $|W|=44$ .

输入的密钥首先填充开头，随后：

W_{4i}=W_{4(i-1)}\oplus g(W_{4i-1})\\ W_{4i+j}=W_{4i+j-1}\oplus W_{4i+j-4}

函数 g:

输入 1word.
RotWord：循环左移 1byte.
SubWord：使用 S-box 对 byte 做代换。
将输出的第一个 byte 与轮常量 $RC_i$ 异或得到输出。

目的：增加密钥拓展过程的 non-linearity. 防止不同轮的轮密钥生成方式上的对称性或相似性。

解密时，每层都是加密过程中的逆。

需要实现轮密钥加、列混淆、行移位、字节代换的逆变换。
轮密钥加和行移位是显然的。

列混淆：求相乘矩阵的逆矩阵即可。
字节代换：求解仿射变换的逆和有限域乘法逆。

目前为止对完整版本的 AES 没有比穷举攻击复杂度更低的密码分析攻击。

5 分组密码操作模式

分组加密算法一次只加密一个分组。实际应用中，待加密消息数据量不固定。
如果使用相同密钥加密多个分组，会引发许多安全问题。
需要采用适当的操作模式。

明文信息填充：不为分组长度整数倍时，需要 padding.

PKCS5：设需要填充 $N$ bytes，加上 $N$ 个值为 $N$ 的 byte.
7字节：FD FD FD FD FD FD FD —
填充1字节后: FD FD FD FD FD FD FD 01
8字节： FD FD FD FD FD FD FD FD
填充8字节后: FD FD FD FD FD FD FD FD 08 08 08 08 08 08 08 08

OneAndZeroes Padding：填充一个 1bit,然后填充 0bits.

电子密码本，ECB
- 在给定密钥下，对每个明文分组独立加密。
- 优点：实现简单。可并行。
- 缺点：相同明文对应相同密文，无法隐蔽明文分组统计规律。无法抵挡替换攻击。
- 通常只用于短数据加密。
密码分组链接，CBC
- 加密函数输入：当前明文分组和前一次密文分组的异或。
- 相同明文分组产生不同密文分组。
- 给定初始向量 IV. 每次消息加密应当使用新的 IV.
  - 使用中需要防止 IV 被篡改。
  - 攻击者伪造 IV，已知第一个分组明文时，可以让解密方的第一个分组解密结果为任意值，实现篡改。 $P_1=D_K(C_1)\oplus IV$ .
- $C_1=E_K(IV\oplus P_1)$ ， $C_2=E_K(C_1\oplus P_2)$ …
- 解密时， $P_1=D_K(C_1)\oplus IV$ ， $P_2=D_K(C_2)\oplus C_1$ ，以此类推。
- 优点：
  - 隐蔽明文数据模式。
  - 明文一组有错，后续无法解密。可用于数据完整性验证。
- 缺点：
  - 加密顺序执行，无法并行。解密时若所有密文分组都已经收到，解密本身可以并行。
  - 错误传播导致一个分组出错会影响所有后续分组。
实现将分组密码作为流密码使用：
密文反馈，CFB
- 传输数据最小单元 s bits，加密函数输入 b bits，是一个移位寄存器，给定初始值 IV.
- 加密函数输入 b bits，输出的最高 s bis 和明文的第一个单元 $P_1$ xor 产生第一个密文单元 $C_1$ 传输出去。
- 寄存器 lshift s bits，低位填充 $C_1$ ，再次加密…
- 实际上是将加密算法作为一个密钥流产生器。
- 解密时，使用的依然是分组算法的加密函数。
- $C_1=P_1\oplus \text{MSB}_s(E(K,IV))$
- $P_1=C_1\oplus \text{MSB}_s(E(K,IV))$
- $C_2=P_2\oplus \text{MSB}_s(E(K,IV\ll s \mid C_1))$
- $P_2=C_2\oplus \text{MSB}_s(E(K,IV\ll s \mid C_1))$
- 优点：
  - 可以按最小传输单元加密。
  - 相同明文产生不同密文。
- 缺点：
  - 加密无法并行。解密可以并行。
  - 错误传播。一个地方出错影响后续所有。
输出反馈，OFB
- CFB 将每个明文单元产生密文单元反馈到下一个加密函数的输入。
- OFB 将加密函数的输出反馈到下一个加密函数的输入。
- 实际上，整个密钥、加密算法输入输出都是独立的。只是生成若干的 $O_i$ 和明文异或而已。感觉和随机数生成器没区别。
- 解密也一样生成 $O_i$ 然后异或即可。
- 优点：
  - 无错误传播。
  - 可以预计算加密的密钥流。
- 缺点：
  - 实时加解密无法并行计算。
计数器，CTR
- 什么纯粹的随机数发生器。。。这样的好处是可以并行了。而且可以随机访问。
- 但为什么我不直接用随机数生成器呢？

感觉需要掌握几种图的画法。

6 流密码

PRNG：伪随机数发生器，固定种子输入。

随机性
- 分布独立性：位分布均匀，01 频率大约相等。
- 独立性：任何子序列不能由其他子序列推导出。
不可预测性：
- 给定部分序列，无法预测后续序列部分。

RC4：可变密钥长度、面向字节操作的流密码。以随机置换为基础，实现简单且快。

反馈移位寄存器：大多数新型流密码基于 Feedback Shift Register.

LFSR：

初始为 $a_n,\cdots,a_1$ ，则输出顺序为 $a_1,\cdots,a_n,a_{n+1},\cdots$

对于整数 $t\ge 1$ ， $a_{n+t}=c_na_t \oplus c_{n-1}a_{t+1}\oplus \cdots \oplus c_1 a_{t+n-1}$ .
特征多项式 $p(x)=1+c_1x^1+\cdots + c_nx^n$ .

输出周期与状态周期相等。最大周期为 $N=2^n-1$ .
最大周期条件：特征多项式不可约，为本原多项式。

7 有限域

群： $G$ 定义了二元运算 $\cdot$ 的集合，满足：

单位元： $\exists e\in G, \text{ s.t. }\forall g\in G, g\cdot e=e\cdot g$
逆元： $\forall g \in G, \exists g' \text{ s.t. } g \cdot g' = e = g' \cdot g$
封闭性： $\forall g,h\in G, g\cdot h \in G$
结合率： $\forall g_1,g_2,g_3\in G, (g_1\cdot g_2)\cdot g_3 = g_1\cdot (g_2\cdot g_3)$

环： $R$ 定义了两个二元运算 $+,\times$ 的集合，满足：

$R$ 关于 $+$ 为交换群。对于该加法群，用 $0$ 表示单位元， $-a$ 表示 $a$ 的逆元。
乘法封闭性： $\forall a,b\in R,a\times b \in R$
乘法结合律： $\forall a,b,c\in R,(a\times b)\times c=a\times(b\times c)$
乘法交换律： $a\times b = b\times a$
乘法单位元1：存在元素 $1$ 使得 $\forall a\in R,a\times1=1\times a=a$
无零因子： $\forall a,b\in R,a\times b=0\implies a=0\vee b=0$
分配律： $a\times (b+c)=a\times b + a\times c$ ， $(a+b)\times c = a\times c + b\times c$

环没有规定每个元素有乘法逆元！

域： $F$ 定义了两个二元运算 $+,\times$ ，满足环的性质，此外存在乘法逆元：

$\forall a \in F, a \neq 0 \implies (\exists a^{-1} \in F)(a\times a^{-1}=1)$

有限域的阶(元素个数)是素数幂，记为 $GF(p^n)$ . 一般密码学中使用 $GF(2^n)$ .
其运算为 $\bmod p^n$ 的整数运算。

$\mathbb{Z}_p$ 上的多项式集合 $S$ 包含 $f(x)=\sum \limits _{i=0}^{n-1}a_ix^i$ ， $a_i=0,1,\cdots,p-1$ .
共 $p^n$ 个。

定义运算使得多项式集合 $S$ 构成有限域：

系数运算 $\bmod p$ .
若乘法运算结果得到次数 $>n-1$ 的多项式，将其除以某个次数为 $n$ 的不可约多项式 $m(x)$ 并取余式。 $r(x)=f(x)\bmod m(x)$ .

$GF(2^n)$ 中的多项式 $f(x)=\sum \limits _{i=0}^{n-1}a_ix^i$ ， $a_i=0/1$ 可以按位表示。

加法等效于位异或。乘法有一种巧妙的算法。

例如 $m(x)=x^8+x^4+x^3+x+1$ ， $x^8\bmod m(x) = x^4+x^3+x+1$ .

考虑 $f(x) \cdot x = b_7x^8+\cdots + b_0x$ ，若 $b_7=0$ 结果为 $(b_6,b_5,\cdots,0)$ .
否则，就要加上 $x^8\bmod m(x)$ . 结果为 $(b_6,b_5,\cdots,0)\oplus (00011011)$ .

递推可以得到 $f(x)\cdot x^k$ .

8 数论基础

高中残存的记忆。

欧几里德算法： $\gcd(a,b)=\gcd(b,a\bmod b)$ .

拓展欧几里德算法：求解 $ax+by=\gcd(a,b)$ 的方程。

这玩意手算怎么算呢？以 $a \times 6107 + b \times 8832 = 1$ 为例。

首先把 gcd 的计算全部写出来：

(8832, 6107)
(6107, 2725)
(2725, 657)
(657, 97)
(97, 75)
(75, 22)
(22, 9)
(9, 4)
(4, 1)
(1, 0)

然后加上末尾项：

(8832, 6107)
(6107, 2725)
(2725, 657)
(657, 97)
(97, 75)
(75, 22)
(22, 9)
(9, 4)
(4, 1)
(1, 0) 1, 0

然后每次：交换 $x,y$ ，随后 $y:=y-a/b \times x$ .

(8832, 6107)
(6107, 2725)
(2725, 657)
(657, 97)
(97, 75) …
(75, 22) 5, -17
(22, 9) -2, 5
(9, 4) 1, -2
(4, 1) 0, 1
(1, 0) 1, 0

费马小定律： $p$ 素数， $a$ 正整数， $a^{p-1}\equiv 1\pmod p$ .

欧拉函数： $\phi(n)$ 为小于 $n$ 中和 $n$ 互素的正整数个数。
欧拉函数满足积性，若 $n=pq$ 且 $\gcd(p,q)=1$ ，则 $\phi(n)=\phi(p)\phi(q)$ .

欧拉定理： $\gcd(a,n)=1$ 则 $a^{\phi(n)}\equiv 1 \pmod n$ .
另一种表述：任意 $a,n$ ， $a^{\phi(n)+1}\equiv a\pmod n$
拓展了费马小定律，应用于非素模数。

Miller-Rabin 素性测试。

Lemma1: $p$ 为奇素数，则 $x^2\equiv 1\pmod p$ 的解为 $x\equiv 1 \pmod p$ 或 $x\equiv p-1 \pmod p$ .

Lemma2: $p$ 为奇素数，则 $p-1=2^kq,k > 0$ ， $q$ 为奇数。设 $a\in(1,p-1)$ 且为整数，下面两个条件之一成立： $a^q\equiv 1 \pmod p$ ， $\exists 1 \le j \le k , a^{2^{j-1}q}\equiv p-1\pmod p$ .

测试 $n$ 是否为奇数，我们可以：

首先 $n-1=2^k q$ ，不断除以 $2$ 得出 $k,q$ .
选取 $a\in(1,n-1) \cap \mathbb{N}$ .
若 $a^q\bmod n \neq 1 \wedge a^q\bmod n \neq n-1$ ，断定为合数。
枚举 $j=1,2,\cdots$ ，若 $a^{2^j q} \bmod n \neq n-1$ ，断定为合数。
经过检测，断定为素数。

一般选取若干个基底，进行若干次检测。

中国剩余定理：模数两两互素 $m_1,\cdots,m_k$ ，同余方程组：

\begin{cases} x\equiv a_1\pmod {m_1}\\ \cdots \\ x\equiv a_k\pmod {m_k} \end{cases}

对模 $M=\prod m_i$ 有唯一解。即 $x \equiv \sum a_iM_i e_i \pmod M$ .
其中 $M_i=M\div m_i$ ， $e_i$ 定义为 $e_i M_i\equiv 1 \pmod {m_i}$ .

模数 $n$ 的本原根 $a$ 满足 $a^1,\cdots,a^{\varphi(n)}$ 互不相同且与 $n$ 互素。

对于素数 $p$ ，其本原根 $a$ 的幂能产生模 $p$ 下的非零整数集 $(1,2,\cdots,p-1)$ .

不是所有整数都有本原根。

离散对数：对于素数 $p$ 的本原根 $a$ ，任意整数都有唯一幂次满足 $b \equiv a^i \pmod p, i \in[1,p-1]$ .
称 $i=\operatorname{dlog}_{a,p}(b)$ ，为 $b$ 的离散对数。

给定 $a,i,p$ 容易求 $b$ ，但反过来求解幂次是很难的。BSGS 也只能做到根号级别。

9 公钥密码与 RSA

RSA 参见RSA.

10 其他公钥加密体制

DH 密钥交换： $p$ 为大素数， $g$ 为本原根， $p,g$ 公开。
用户 A 选择保密整数 $a$ ，发送 $Y_A=g^a\bmod p$ .
用户 B 选择保密整数 $b$ ，发送 $Y_B=g^b\bmod p$ .
双方使用自己的保密整数 $x$ ，和收到的 $Y$ ，计算 $K=Y^x=g^{ab}\bmod p$ 作为密钥。

只有 $p,g,Y_A,Y_B$ 公开，要想得到 $K$ 只能求离散对数。

DH 密钥交换容易受到中间人攻击。

ElGamal 密码体制，选定素数 $p$ ，本原根 $g$ .
随机生成 $sk_A=a\in [2,\cdots,p-2)$ ，计算 $pk_A=g^A\bmod p$ .
私钥为 $sk_A$ ，公钥为 $pk_A$ .
用户向 A 发送消息 $M$ 时：随机选择整数 $k\in[2,p-2]$ ，计算 $C_1=g^k\bmod p$ .
计算一次性密钥 $K=pk_A^k \bmod p = g^{ak}\bmod p$ .
计算 $C_2= KM \bmod p$ .
发送 $(C_1,C_2) = (g^k, M \cdot g^{ak})$ 给 A.

A 收到后，利用 $C_1=g^k$ 计算 $g^{ak}$ ，求逆乘上 $C_2$ 得 $M$ .

若待加密数据分组后使用 ElGamal 加密，则每组需要使用不同的整数 $k$ .
否则若泄露其中一个明文分组，可直接在不知道私钥的情况下破译其他明文分组。

椭圆曲线密码体制：基于广义离散对数问题。

ECC 中，椭圆曲线方程为 $y^2=x^3+ax+b$ .

由方程 $y^2=x^3+ax+b$ 确定的椭圆曲线记为 $E(a,b)$ ，包含满足该方程的所有点和无穷远点 $O$ .
当 $4a^3+27b^2 \neq0$ 时，可以基于集合 $E(a,b)$ 定义二元运算，使其成为一个交换群。用加法 $+$ 表示。

$O$ 为加法单位元，对于椭圆曲线上任一点， $P+O=P$ .
对于一点 $P=(x_P,y_P)$ ，其加法逆元为 $-P=(x_P,-y_P)$ ， $P+(-P)=P-P=O$ .
给定两点及坐标 $P=(x_P,y_P),Q(x_Q,y_Q)$ ，加法定义为：
- 当 $P,Q$ 不同时，计算 $PQ$ 与椭圆曲线的交点关于 $x$ 轴的对称点 $R$ ，为 $P+Q=R$ .
- $P,Q$ 相同时，即为切线交点的对称点。

对于不互为逆元的两点 $P(x_P,y_P),Q(x_Q,y_Q)$ ，直线斜率为 $\Delta=(y_Q-y_P)\div (x_Q-x_P)$ ，计算得到 $x_R=\Delta^2 - x_P - x_Q$ ， $y_R=\Delta(x_P-x_R)-y_P$ .

切线自己算吧。跟 $a$ 有关。

在有限域上定义椭圆曲线， $y^2\equiv x^3+ax+b\pmod p$ .

运算是类似的，除了除法要用逆元算。

椭圆曲线上离散对数问题求解困难，即 $Q=kP$ ，给定 $k,P$ 算 $Q$ 是容易的，但给定 $P,Q$ 算 $k$ 是困难的。

求 $kP$ 可以用快速乘的思想。

11 哈希函数

高中写过了一些相关内容。哈希表字符串哈希

哈希函数的要求
- 单向性：已知 $x$ ，求 $h=H(x)$ 容易。已知 $h$ 求 $x$ 是不可行的。
- 抗弱碰撞性：已知 $x$ ，求 $y \neq x$ 满足 $H(x)=H(y)$ 在计算上是不可行的。
- 抗强碰撞性：找出任意两个不同的 $x \neq x'$ 满足 $H(x)=H(x')$ 在计算上是不可行的。

……后面的大概扫了一眼，不想详细写了。还有 MAC 啊数字签名之类的。

基于 Astro 与 Directus 的新时代 JAMStack 博客实践

Thu, 07 Nov 2024 18:40:58 GMT

最近投入了大量摸鱼时间重构博客。现在大概告一段落了，向大家介绍一下整体的技术选型和具体实现的简要思路。

TLDR：JAMStack 实践，使用最新最潮的前端元框架 Astro，魔改 Astro Paper 主题，搭配 Headless CMS Directus，直通对接思源笔记内容同步，自建 SeaweedFS 分布式文件系统暴露 S3 API 作为图床后端，使用 WebP Server 作为图床前端反代，部署 Cloudflare Pages，实现高度客制化的博客体验。

你可以从这里开始访问我的博客：https://clouder0.com/zh-cn/posts/my-new-blog

Introduction

一路走来，我的博客架构换了一茬又一茬，虽然内容好像更新地也不是很勤快……不，其实还是有持续输出内容的吧！

但是，我现在越来越忙了，~~也可能是越来越懒了~~，手动更新博客显然不是什么好的方案，毕竟我目前的内容创作主要集中于：

在思源笔记中写一点为自己记录的内容。顺便，写作是思考的媒介，我也很习惯边写东西边做研究。
写完之后，可能随手复制粘贴发到知乎上。

复制粘贴发送到知乎上，和复制粘贴发送到博客上有什么区别呢，好像也没什么区别，但如果想要支援多平台的话，感觉就很麻烦了。而且我确实很讨厌把差不多的事情重复做很多次。

所以还是来点纯粹的自动化吧！

History

那么讲一讲我博客的历史……曾经用过的方案包括：

WordPress，感觉已经是上个时代的产物了。庞大、臃肿，功能过于丰富，破事很多，成本也不低。而且商业化气息浓厚，各种付费主题插件之类的，总之对个人博客场景感觉不是很好的选择。
- BTW，我对 PHP 没什么好感(
typecho，相比 WordPress 当然是清爽简洁了许多，但是……动态博客对个人场景来说还是比较 overhead，因为主体静态内容明明是可以随便 CDN 分发的才对。而且感觉功能又有点过于简陋了。
- 同样也是上个时代的产物了。唉，PHP.
Hexo，静态博客是一阵风啊，突如其来地席卷了大江南北。当然，Hexo 是好的，但当初还是遇到了一些问题，主要是：构建时间长。
- 对于现在的我来说，不使用 Hexo 的主要原因可能是……定制化没那么方便？基于模板的方案，不是很自由。
- 主要就是不是很自由吧。
Hugo，构建速度非常的神清气爽啊，上个博客就是这个版本的。
- 主要问题还是定制不太方便，用的是 Golang 的模板语法，原来尝试改过一点主题，真是令人痛苦万分啊。

Arch

那么，归纳一下我的需求：

以静态为主，但要能够结合一些动态内容。最好能直接渲染成 HTML，但支持在里面内嵌一些 Component，走前后端分离架构那套玩法来添加一点动态内容。
高度可定制化，需要什么小功能就能自己搓。

当初我听说过有一个框架叫做 Gatsby，不过现在更流行的是 Astro. Astro 虽然可以用来做博客，不过更多时候会拿来做一些企业的 Landing Page. 它的设计架构非常的漂亮，整体上说：

同时支持 Server Component 和 Client Component，可以混合动静态内容。
使用类似 JSX 的语法，写起来令人倍感亲切，比学奇奇怪怪的模板方便多了。
在 Static Site Generation 阶段，可以直接执行 JavaScript 代码，调用给出的 API 即可，非常非常灵活啊。

是的，所以理论上在 Astro 里面我们可以做到这样的事情：

在 build 阶段，调用 API 拉取 CMS 的内容。根据 API 调用返回值直接构建静态网站。

而如果你不想静态构建的话，Server Side Rendering 也是改个配置的事情。非常好文明。

Implementation

在实际的搭建过程中，顺序大概是这样的：

先用 Astro 把博客的前端跑起来。
搭建 Directus，折腾 Astro 成功对接 Directus 的后端内容。
手搓一个小工具，实现思源笔记导出内容至 Directus 中。
手搓博客的 i18n、评论区、RSS、OgImage 等功能。
跑 SeaweedFS，跑 WebP Server 把图床跑起来。
使用思源笔记的发布插件对接 S3 Backend 方便上传图片。

Astro

虽然 Astro 挺好的，主要是它可以非常方便地结合前端技术栈，爱用啥用啥。但还是有一些 Drawbacks，目前我注意到的几点不足是：

拉取 Remote Content 的 Content Layer API 还不是很成熟，许多文档缺失。虽然已经可以用了，但官方没有暴露方便的 Markdown Render 接口，导致拉取了远端的 Markdown 内容还要自己想办法渲染。
- 渲染 Remote Markdown 最后的解决方案是我在官方 Discord Channel 的聊天记录里找到的…
Incremental Build 虽然有，但只支持本地 Markdown 文件，只要打开增量构建，Remote Content 会直接消失。果然是非常 Experimental 的 Feature 啊。
默认没有异步构建，或者说默认的 Concurrent Number 为 1,导致如果你的 Single Page Build 过程中有阻塞工作，总构建时长就会非常令人感叹。
开放的 API 感觉缺了不少东西，比如说缺少为使用者提供的 Cache API 之类的，只能自己脏脏地乱写。
没有足够开箱即用的 i18n 支持，虽然有 i18n router，但是灵活度差强人意，而且文档中给的方案也并不好。

Whatever，里面的大部分问题都被我想办法解决掉了。

i18n

具体探索掠过不谈，直接讲目前的 Solution：

使用 paraglidejs，一个 i18n 库，在 yml 中写翻译，然后 compile 成 js 文件，就可以直接在 Astro 中调用了。

但你依然需要为不同的语言生成不同的 static files，要做到这一点的话，可以添加一层路由：

然后在 export static path 的时候：

import { availableLanguageTags, languageTag } from "paraglide/runtime";

import * as m from "paraglide/messages.js";
const posts = [
  ...(await getCollection("blog")),
  ...(await getCollection("directus_blog")),
];

const tags = getUniqueTags(posts.filter(p => p.data.lang === languageTag()));

export function getStaticPaths() {
  return availableLanguageTags.map(lang => ({ params: { lang } }));
}

大概是这么个意思，为不同的 language 生成不同的路由。

需要注意：Astro 默认的 Content 必须有 unique slug，而这意味着 [lang]/[slug] 这样的路由会导致 zh-cn/mypost 和 en/mypost 只能指向同一个 mypost.md，这个时候一个解决方案是：写文件的时候把 slug 开头加上 [lang]-，然后生成路由的时候删掉。

for (const lang of ["zh-cn", "en"]) {
   if (o.slug.startsWith(`${lang}-`)) {
     return o.slug.slice(lang.length + 1);
   }
 }
return o.slug;

我自己搓了一个简单的切换 language 的小组件。还有各种乱七八糟的细节，这里就不展开了，这个方向是能走通的。

评论区

评论区使用了 Giscus，说实话体验舒适不算好啊草。我尝试 Self Host，但是——

一个小小的评论区就有 2000+ 个依赖包？构建出来的 Docker Image 直接上 G？属实是非常的操蛋啊。

Anyway，还是使用了。放弃了 self host，因为没跑起来，我怀疑是不支持 Bun runtime. 使用了官方构建的版本。

官方的内嵌 script 跟 Astro 搭配比较灵车，建议使用 React 版本。

我自己附加包了一层根据全局的 language 切换 Giscus 语言的功能，当然还有主题切换的时候需要跟着切换，这也是一个样式小细节。用 useEffect 注册一个 Event Listener，在 theme switch 的时候 emit event 就行了。

这里曾经遇到了一些灵车的问题，后来发现是 Cloudflare Rocket Loader 会导致 Astro 在 view transition 时 js 脚本执行异常，关了 Rocket Loader 就行。

Content Layer & Remote Markdown

现在推荐的拉取远端资源的方法是使用 Content Layer，不仅可以定义 schema、接入 Astro 的 Content 生态，而且有很方便的内置方法实现 Incremental Loading，不过渲染似乎没法省略掉。

拉取的 Markdown 内容要接入 Astro 中显示，还得自己处理渲染成 HTML. Astro 目前没有给出公开的、能够使用框架配置的 Markdown Render 方法，官方文档中建议使用第三方的 Markdown 渲染。。。但我在 Discord 上学到了这种做法：

import { createMarkdownProcessor } from "@astrojs/markdown-remark";
const preprocessor = await createMarkdownProcessor(ctx.config.markdown);
const rendered = await preprocessor.render(post.content);

Content Loader 这部分的文档还不是很详细，提供一个拉取 Directus 的例子：

export const directusLoader = (conf: {
  url: string;
  username: string;
  password: string;
}): Loader => {
  const client = createDirectus<DirectusSchema>(conf.url)
    .with(rest())
    .with(authentication());
  return {
    name: "directus_loader",
    load: async ctx => {
      // ctx.store.clear();
      // ctx.meta.delete("last-modified");
      await client.login(conf.username, conf.password);
      const last_modified =
        ctx.meta.get("last-modified") ?? new Date(1900, 0, 0).toISOString();
      ctx.logger.info(`Last modified: ${last_modified}`);
      const res = (
        await client.request(
          readItems("BlogPosts", {
            filter: {
              _or: [
                {
                  date_created: {
                    _gt: last_modified,
                  },
                },
                {
                  date_updated: {
                    _gt: last_modified,
                  },
                },
              ],
            },
          })
        )
      ).map(x => ({
        ...x,
        date_created: new Date(x.date_created),
        date_updated: x.date_updated ? new Date(x.date_updated) : null,
      }));
      console.log(res);
      const preprocessor = await createMarkdownProcessor(ctx.config.markdown);
      for (const post of res) {
        const data = await ctx.parseData({ id: post.id, data: post });
        const digest = ctx.generateDigest(data);
        const rendered = await preprocessor.render(post.content);
        ctx.store.set({
          id: post.id,
          data: data,
          body: post.content,
          rendered: {
            html: rendered.code,
            metadata: {
              frontmatter: rendered.metadata.frontmatter,
              headings: rendered.metadata.headings,
              imagePaths: [...rendered.metadata.imagePaths],
            },
          },
          digest: digest,
        });
        ctx.logger.info(`Fetched post: ${post.title}`);
      }
      ctx.meta.set("last-modified", new Date().toISOString());
    },
    schema: directusSchema,
  };
};

然后在 Content Collection 配置中写：

const directus_blog = defineCollection({
  type: "content_layer",
  loader: directusLoader({
    url: DIRECTUS.url,
    username: DIRECTUS.user,
    password: DIRECTUS.password,
  }),
});

Open Graph Image

Astro Paper 内置了相关的功能，但有两个主要的 Drawback：

每次生成的时候都会去动态拉取 Google Fonts，在国内网络环境下非常灵车，而且比较缓慢。
每次都动态生成 OgImage，但实际上这种 Pure Function 明明很方便缓存。

因此自己搓了一个缓存层，并且切换成了使用本地字体，然后切换成使用 Noto Serif，因为原版字体不支持中文。

Astro 没有给开发者提供 Cache 相关的 API，所以我决定直接写到系统 tmp 文件夹里面去。

这里注意，如果存在 Concurrency，有可能两个相同的 key 同时判定 Cache 不存在，然后进入了生成流程，然后开始写入，此时发生 race condition. 解决方案是在第一个 check cache 后决定需要生成就加上锁，让后续的那个不再生成，而是等待前者生成然后直接读取。

不过实际上没有测试过，自我感觉没问题。Coroutine 还是比 Multithread 好处理很多，但并不意味着我们可以瞎几把写，异步该有的问题还是会有。

什么，Astro 默认单 Coroutine 处理？那没事了。

import * as os from "node:os";
import * as crypto from "node:crypto";
import * as fs from "node:fs/promises";

const key_locks = new Map<string, Promise<Buffer>>();
export const useCache = () => {
  const path_prefix = `${os.tmpdir()}/blogcache`;
  return {
    read: (key: object, genenrator: () => Promise<Buffer>) => {
      return (async () => {
        const sha256 = crypto.createHash("sha256");
        sha256.update(JSON.stringify(key));
        const shakey = sha256.digest("hex");
        if (key_locks.has(shakey)) {
          const res = await key_locks.get(shakey);
          // console.log("HIT MEM CACHE")
          return res;
        }
        const path = `${path_prefix}/${shakey}`;
        try {
          const res = await fs.readFile(path);
          // console.log("HIT DISK CACHE")
          return res;
        } catch (e) {
          const res = genenrator();
          key_locks.set(shakey, res);
          const awaited_res = await res;
          // console.log("generate success")
          // make dir first
          await fs.mkdir(path_prefix, { recursive: true });
          await fs.writeFile(path, awaited_res);
          // console.log("WRITE DISK CACHE")
          return awaited_res;
        }
      })();回车。
    },
  };
};

KaTeX

KaTeX 接入的话，实际上我们可以做 Server Side Rendering，只需要接入 KaTeX 的 css 就能完美渲染了。用 remark rehype 的插件就行，这部分没什么特殊的，略过了。

Astro 这边暂且主要就做了这些工作，还有一些细小的工作没有写出来。

Directus

选用 Directus 作为我的 Headless CMS. 为什么需要一个 Headless CMS？

我的内容需要有一个中心化的 Source of Truth.
我希望能够从各种各样的信息源输出内容。比如笔记软件同步文章，比如随手记的 idea. 简单的说，我希望将多个信息源的内容通过 API 调用上传到 Headless CMS 做集中，然后博客再直接从 Headless CMS 渲染内容。
我不太喜欢使用 Git 管理一切内容，因为需要管理 commits，比较麻烦，而且不是很方便 API 接入。一般而言，我并没有管理内容版本的需求。

可以说这是一层 Abstraction Layer. 如果不使用 Headless CMS 的话，当然我也可以直接在 Astro 中写从信息源拉数据、渲染的功能。但这就非常脏，支持多个信息源的时候也没那么方便，而且拉信息源的构建过程就必须对信息源有访问权限。比如跑 CI/CD 构建的时候，Actor 就对我本地的笔记软件 Backend 没有访问权限，所以不是一个很好的方案。

Directus 在这里扮演的主要是一个简单的数据库的功能。虽然有一个 Admin Panel，理论上我也可以在里面修改内容……但其实思源笔记才是我主要的内容输出端。

当然，以后可能会接入更多的内容输入。

读读官方文档就会用了，还是很好上手的。不过嘛，功能本身也不多，只是一个 thin wrapper.

思源笔记发布

Oneway sync，做一个简单的增量更新就可以了。

整体思路是：

使用 directus-last-update 这个自定义属性来判断是否已经更新至 Directus.
若某个 Document Block 在思源笔记的更新时间晚于其被标注的 directus-last-update 属性值，则将其同步至 Directus，并覆写时间戳。

当然，实际上我还加入了一些 metadata 相关的属性项，以便在思源笔记这边向 directus 写入属性。不过这里就涉及到一个 two-way sync 的问题，如果在 Directus 上更新内容的话就一定会被思源笔记这边覆写了，除非做一个 directus2siyuan 的写回，有点麻烦，暂且不管。

把核心的 SQL 语句放出来吧，其他的都是 trivial work：

SELECT * FROM 'blocks' b INNER JOIN 
        (SELECT block_id, value AS 'last_update' FROM 'attributes' WHERE name == 'custom-directus-last-update') a  
        ON b.id  == a.block_id AND b.updated > a.last_update AND b.type == 'd'

图床

自建 S3，Minio 有点太重了，我选择使用 SeaweedFS 和 Filer.

暴露出 S3 API 之后，用 WebP Server 包一层，可以做自动转 webp 之类的优化操作，然后再接入 caddy.

思源这边的话，有一个 PicGo 插件可以接入 S3 Backend，上传图片也很方便。

Deploy

目前的 Deploy 主要分四步：

在思源这边更新好 metadata.
调用脚本同步至 Directus.
根据 Directus 内容构建 Static Site.
上传至 Cloudflare Pages.

前两步因为需要访问思源笔记的数据，只能在我的本地完成，或者说我倾向于在本地完成。后两步则不一定。

考虑过是否要作 CD，不过想了想还是大道至简，在我的某台 vps 上搭好了环境，然后 alias 一条命令 SSH 上去执行就完事了。

最终日常的博客更新流程就是：

按 F12 打开我的 Drop Down Terminal.
输入 s2d && blogdeploy.
回车。
完成。

Additional Notes…

强烈推荐使用思源笔记的发布插件，一键发布多平台，虽然感觉有一些方面做得还略有不足，但已经算是可用了。

目前知乎内容均由该插件直接上传。

‍

4 Empirical Properties of Limit Order Books

Sat, 02 Nov 2024 14:39:15 GMT

LOB 可以揭露很多有趣的微观信息，近年来也有许多研究。但需要注意：高频交易的进化速度极快，让这些研究很多时候比较过时。

Originally Posted at: https://clouder0.com/zh-cn/posts/lob-empirical-properties/

总结性的来说，作者发现了这些特点：

每日交易量大概占市值的 $0.5\%$ . 从 1995 到 2015,这个比例近乎翻倍了。
在 midprice $1\%$ 附近的 volumes(差不多是 daily volatility 的一半的范围)占当日总交易量的 $1\% \sim 3\%$ .
best quotes 的活动在 ms 级别，large tick 的活动更加频繁。
trade-through market orders(吃了 LOB 多档的订单)，在 small tick assets 上只有一小部分，而在 large-tick stocks 上则非常稀有。

在任意时刻，LOB 上揭露的订单都只是当天活动的很小一部分。

order flow 和 LOB 的很多属性都有着强烈的 intra-day patterns. 每天的不同时段表现是不同的。

比如就成交量而言，每天接近开盘、收盘的时候交易异常活跃。前者可能是为了消化隔夜的信息，而后者则是为了尽快完成当日的交易(比如说规避持仓过夜的风险等)。此外，也有可能有许多交易者选择在流动性好的时候进行交易，从而进一步促成了交易的聚集。

large tick stocks 在开盘的交易量小，相比之下 small tick stocks 就大很多。emmm，这是普遍的吗？

Spread 在开盘时较大，而后持续减小。这可以从 Liquidity Providers 面临的 Adverse Selection 来考虑。
开盘时 Overnight News 让 Market Maker 面临强烈的 Adverse Selection 风险，因而需要增加 Spread. 随着交易逐渐消化掉了这部分的信息影响，Spread 就会逐渐缩小。

Liquidity 在开盘时相当稀有，而在收盘时相当充裕。这也意味着如果我们想干票大的、又不想承担太多的 Price Impact，可以选择在接近收盘的时候交易。

不同类型的 stocks 的 Spread Distribution 还是有所不同的。对于 large-tick stocks 而言，大部分时候 Spread 就是 1tick，在少数情况下会更大。

而对于 small-tick stocks 而言，取值就更加广泛了。

或许是因为 Spread 代表的是 Maker 的 Profit. 如果按 Spread 占市值的 Percentage 来算的话，也许会相对接近一些？

注意 bid-ask distribution 在不同的采样方式下结果是不同的。如果选择在 before-transaction 时统计，得到的 spread distribution 会比随机采样更 narrow 一些。这是因为 Liquidity Takers 会择时下单。

所以一个简单的 Taker 执行策略就是：当 Spread 较大的时候少下( 但是为什么？一般而言，如果假定 FairPrice 处于 MidPrice，那么 Taker 去拿 Best Quotes 就需要付出 Half Spread Cost，当 Spread 较大的时候，意味着这个 Cost 也较大。而这个 Cost 就是 Maker 的 Profit.

当然，如果用更 Fair 的 Price Prediction 来衡量这个 Cost，会更好一些。

可以观察 Limit Orders 挂单的分布。same-side quote-relative prices 的定义参见上篇文章 3 Limit Order Books。在 Best Quotes 处的挂单总是最多的，但更深的地方也存在不少。

在 small-tick stocks 中，有更多的挂单会选择挂在 Spread 上，这可能是因为很多时候 spread 相对较大。

根据作者的说法，撤单的分布和挂单非常相似，这可能是因为很多订单都是挂了之后，如果没成交就撤。

挂单的 Order Size 呢？这个的分布其实是相当广泛的，注意这是对数坐标。可以发现 OrderSize 没有呈现出 Cluster 聚集的状况，而是越大越少地广泛分布。

best quotes 上的 volume 分布：

可以发现 tail 和上面的 Order Size 有点像，这可能是因为一个 Large Limit Order 几乎总是会留在 LOB 上被观察到。

Queue Volumes 也可以从 calendar-time、event-time 和 before-transaction 三个角度来考察。

对于 small-tick stocks，在交易发生前 best quote 处的 volume 更大，说明 liquidity taker 更愿意在 opposite volume 相对较高时出手。
对于 large-tick stocks，在交易前的 volume 较小。Queue Volume 自身就带有跟未来价格方向有关的信息，当 ask 的流动性少、bid 流动性大时，价格一般向上移动，liquidity takers 抢着把最后剩的一点流动性拿干净。

接下来是 LOB 上的 Volume Profile：这次使用的是 opposite-side price distance，这是为了避免在 0 处的巨大 peak.

可以发现即使在相当远的位置也有许多的流动性，同时，在 small-tick stocks 上可以观察到强烈的 round-number effects：大家比较喜欢挂单在整数上。

当然，要注意，这里的 Volume Profile 是平均值，那么在一个 snapshot 的分布究竟是怎么样的呢？

可以发现在 small-tick stocks 上，LOB 实际上稀疏得多，很多时候是因为平均了才显得比较连续。

Tick size 如何影响市场呢？

首先观察：spread 和 stock price 基本上是成比例关系。由于 $\theta=0.01$ 就是最低价了，mean stock price < 10 的离群点没法继续往下。对比较贵的 stocks 相关性还是比较强。

tick size 小的话，在 best quote 处的成交量就更少，best quote 处的 depth 也较小。

都是一些 stylized facts. 暂且还没有太反直觉的地方。

‍

3 Limit Order Books

Fri, 01 Nov 2024 12:27:11 GMT

Limit Order Book 的简单描述。

Ref: https://clouder0.com/zh-cn/posts/limit-order-books/

The Mechanics of LOB Trading

与传统的 Quote-Driven 系统不同，基于 LOB 的系统是完全由 submissions 和 cancellations 驱动的。

一个 order 可以由以下四个属性描述：

方向， $\varepsilon_x = \pm 1$ . 对于 buy order 为 $+1$ .
价格， $p_x$ .
大小， $v_x > 0$ .
提交时间 $t_x$ .

记为：

x:=(\varepsilon_x, p_x, v_x,t_x)

每当一个 buy order $x$ 提交后，LOB 的 trade-matching algorithm 开始检查是否存在 sell order $y$ 满足 $p_y \le p_x$ .
如果有，那么这笔订单将被撮合成交。如果还剩下一部分 $x$ 尚未被满足，则自动留在 LOB 的价格档位 $p_x$ 上。

提交后直接成交的订单叫做 market orders. 其他的叫做 limit orders. LOB 是公开的、未被满足的交易意愿的集合。可以将其划分为 Bid Orders $\mathcal{B}(t)$ 和 Ask Orders $\mathcal{A}(t)$ .

在本书中，考虑在时间 $t$ 提交的订单不属于 $\mathcal{L}(t)$ ，但属于 $\mathcal{L}(t+\mathrm{d}t), \mathrm{d} t \to 0$ .

提交 Limit Order 可以视作：Trader 向 Market 提供了一个在挂单价格成交的机会。也就是提供了流动性。当然，这种情况下也就会面临 Adverse Selection 的风险。
Limit Orders 一般在 mean-revert 时获取收益，在 trend 时承受损失。

在时间 $t$ ，bid-price 指的是所有 buy limit orders 中最高的价格，ask-price 则是所有 sell limit orders 中最低的价格。

\begin{aligned} b(t) := \max \limits _{x\in \mathcal{B}(t)}p_x \\ a(t) := \min _{x\in \mathcal{A}(t)}p_x \end{aligned}

在任意时刻， $b(t) < a(t)$ ，否则将直接撮合成交。

mid-price 定义为：

m(t) := \dfrac{1}{2}\left[a(t) +b(t)\right]

spread 定义为：

s(t) := a(t)-b(t)>0

使用 overline notation 来标记某个时刻后的瞬间的属性：

\overline{m}(t) = \lim \limits_{t' \downarrow t} m(t')

lot size $v_0$ 是最小的 volume 单位，所有的订单必须满足 $v_x \in \{kv_0\mid k = 1,2,\cdots\}$ .

tick size $\theta$ 是最小的 price 单位，所有价格必须满足 $p_x\in\{k \theta \mid k = 1,2,\cdots\}$ .

$v_0,\theta$ 被称为市场的 resolution parameters. 不同的市场会有不同的设置。这两个参数在各种方面都会影响交易。

研究 LOB 时，常常使用 same-side quote-relative coordinates.

d(p_x,t) :=\begin{cases} b(t) - p_x, \text{if } x \text{ is a buy limit order}\\ p_x - a(t), \text{if } x \text{ is a sell limit order} \end{cases}

很多时候，使用 opposite-side quote-relative coordinates 是更好的：

d^\dagger(p_x,t) :=\begin{cases} a(t) - p_x, \text{if } x \text{ is a buy limit order}\\ p_x - b(t), \text{if } x \text{ is a sell limit order} \end{cases}

有：

d^\dagger(p_x,t) = d(p_x,t) + s(t)

大部分时候，我们通过 volume profile 来观察 LOB. 在价格 $p$ 时间 $t$ 的 buy-side volume 记为：

V_+(p,t) := \sum \limits _{\{x \in \mathcal{B}(t) \mid p_x=p\}} v_x

位于时间 $t$ 的 Volume Profile 定义为 $\{V _\pm (p,t)\}$ .

进行撮合时，同一个价格上可能有多笔订单。此时需要确定 priority.

最常见的是 price-time priority. 先比较价格，再比较时间。

还有另一种常用的方法是 pro-rata priority，当某个价格档位发生成交时，所有相关的 Limit Order 根据其在该价格档位所占的 Volume Size 分到一部分的成交。
在这个撮合机制中，有一个有趣的手法：如果你希望尽快成交，可以提交比你实际需求更大的 Volume，这样可以在撮合匹配时抢到更大的份额。

Price-time priority 鼓励 Traders 尽早提交，抢先以更高的价格提交从而减小 Spread、增加流动性。Pro-rata priority 则鼓励 Traders 提交更大的订单，从而在 best quotes 提供更大的深度。

Traders 在 LOB 上的行为可以被拆解为 elementary size $v_0$ 大小的订单。

例如：当我在 $p_x=1.5$ 提交 $v_x = 10v_0$ 的 buy order 时，实际上等效于在 $p_x=1.5$ 提交 10 笔 $v_x=v_0$ 的 buy orders. 在做研究时，为了方便，经常直接考虑 elementary size $v_0$ 的单位订单。

但实际上订单的种类多种多样：

Stop orders：止损订单，当价格达到某个位置后触发自动挂单。
Iceberg orders：用于隐藏真实意图的冰山订单，只有一小部分 peak volume 被公开挂在 LOB 上，而每次这部分成交后，继续挂单保持 peak volume，直到 hidden volume 被执行完毕。
Immediate-or-cancel orders：提交订单，撮合并立即成交能成交的那部分，随后自动撤掉未成交的部分。如果一点都没有成交，等效于没有提交订单。不会在 LOB 上留下痕迹。
Fill-or-kill orders：和 IOC 类似，但这种情况要么全部成交，要么全部撤单。
…

有一些市场还有 opening & closing auctions：在开盘、收盘的一段时间中，可以挂单，但不发生撮合成交。直到最终截止的时候再一次性撮合。在这个过程中，Traders 可以提交订单，提交的订单也会显示在 LOB 上，同时还会有一个 auction price，即使总成交量最大的最优撮合价格。

‍

2 The Statistics of Price Changes

Fri, 01 Nov 2024 12:21:20 GMT

金融市场的 Random Walk Model 以及 stylized facts. 阅读 Trades, Quotes and Prices 的第二章。

数学，统计学，机器学习，人们总是用各种各样的办法研究金融市场。

Originally Posted at: https://clouder0.com/zh-cn/posts/price-change-statistics/

The Random Walk Model

一个相当流行的模型，是将价格变动看作是 Gaussian random walks，即 $\mathrm{d} p \sim \text{Gaussian}$ ，价格变动服从 i.i.d. 独立同分布的高斯随机变量。价格是 martingales，对明天价格最好的预测就是今天的价格，价格变动是 mean 为 0 的 Gaussian Random Variable.

Bachelier’s First Law：price variogram 关于时间 $\tau$ 线性增长。

\mathcal{V}(\tau) := \mathbb{E}[(p_{t+\tau} - p_t)^2] = D\tau

后续的很多 empirical studies 认为，价格变动应当是一个相乘的关系，或者说关于比例线性。这意味着使用 geometric Brownnian motion 来代替 Brownian motion. 实际上，从 1960 年代开始，这已经成为了金融数学领域的标准模型。

但是在较短的时间尺度上，也有 empirical evidence 认为价格变动更接近于 additive 而非 multiplicative. 一个重要的原因是，市场常常规定了最小价格变动的 ticksize.

在这本书中，因为主要考察短时间，还是会使用 additive model.

但是还是介绍一下另一种：定义 volatility $\sigma_r$ :

D := \sigma_r^2 \overline{p}^2

其中 $\overline{p}$ 为当前价格或者某段时间的平均价格。

现在，如果价格变动并不是独立的呢？比如我们知道，一段时间内总是可能出现单边趋势或者反弹。

考虑价格序列：

p_t = p_0 + \overline{p}\sum \limits _{t'=0}^{t-1}r_{t'}

其中 return 序列 $r_t$ 是 time-stationary 的，且 mean 为 0:

\mathbb{E}[r_t]=0

variance：

\mathbb{E}[r_t^2] - \mathbb{E}[r_t]^2 = \sigma_r^2

可以用 covariance 来表达 dependence：

\operatorname{Cov}(r_{t'}, r_{t''}) := \mathbb{E}[r_{t'}r_{t''}] - \mathbb{E}[r_{t'}] - \mathbb{E}[r_{t''}] = \mathbb{E}[r_{t'}r_{t''}]

考虑到 return series 是 time-stationary 的，这个 covariance 只与 time lag $|t'-t''|$ 有关。一个常见的考察是 autocorrelation function(ACF)：

C_r(\tau) := \dfrac{\operatorname{Cov}(r_t, r_{t+\tau})}{\sigma_r^2}

在 random walk 中， $C_r(\tau) = \delta_{\tau,0}$ ，其中 $\delta_{\tau,0}$ 是 Kronecker delta function：

\delta_{i,j} = \begin{cases} 1, \text{if }i = j\\ 0, \text{otherwise} \end{cases}

也就是除了 $\tau=0$ 时为 $1$ ，其他时候为 $0$ .

对于 $\tau>0$ ，一个单边趋势往往有着 $C_r(\tau) >0$ ，也就是价格上涨。而 mean reverting 则有着 $C_r(\tau) < 0$ .

volatility 本身也和我们采样的时间有关，如果我们每 $\tau$ 秒采样一个价格，相应的 volatility 为：

\sigma^2(\tau) := \dfrac{\mathcal{V}(\tau)}{\tau \overline{p}^2}

#TODO# 这个式子不知道是怎么来的。当 $\tau=1$ 时，有 $\sigma^2(1) = \sigma^2_r$ .

代入可以得到：

\sigma^2(\tau) = \sigma^2_r \left[ 1 + 2 \sum \limits _{u=1}^\tau \left(1 - \dfrac{u}{\tau} \right) C_r(u) \right]

‍

$\sigma(\tau)$ 关于 $\tau$ 的图像称为 volatility signature plot.

图中的例子是一个指数衰减的 ACF $C_r(u) = \rho^u$ 画出的。接近直线说明价格的 autocorrelation 不强。

现在假设价格还受到一些 high frequency noise 的影响：

p_t = p_0 + \overline{p} \sum \limits _{t'=0}^{t-1}r_{t'} + \eta_t

其中 noise $\eta_t$ 是 mean 为 0、variance 为 $\sigma_{\eta}^2$ 且与 $r_t$ 无关的随机变量，但是自相关，并且 ACF 为：

C_{\eta}(\tau) := \dfrac{\operatorname{Cov}(\eta_t, \eta_{t+\tau})}{\sigma^2_{\eta}} = e^{-\tau/ \tau_{\eta}}

其中 $\tau_{\eta}$ 是 noise 的自相关时间。

The noise $\eta$ is often called an Ornstein–Uhlenbeck process, see, e.g., Gardiner, C. W. (1985). Stochastic methods. Springer, Berlin-Heidelberg.

可以将这个模型解读为：市场价格有时候会偏离真实价格，这个偏离是一个 random error term，在时间尺度 $\tau_{\eta}$ 下会 mean-reverts. 另一种解读是，microstructure noise 来自我们对 true price 的估计不准的 error term，也就是我们的 predicted true price 总是和 true price 有一定的偏差，但这个 bias 也会 mean-reverts. 这被称为 bid-ask bounce effect.

加入这项 noise 之后，我们观察到的 square volatility 变成了：

\sigma^2(\tau) \to \sigma^2(\tau) + \dfrac{2\sigma^2_{\eta}}{\tau} \left( 1 - e^{-\tau/\tau_{\eta}} \right)

这个额外的项在 $\tau=0$ 时，等于 $2\sigma^2_{\eta}/\tau$ ，在 $\tau \to \infty$ 时衰减至 0.这主要会增大短期的 volatility.

Bachelier’s first law 假设价格变动之间无关，这对应的是一根直线的 volatility signature plot.

实际上好像大部分时候确实接近一根直线。

Jumps and Intermittency in Financial Markets

Heavy Tails

很多模型假设 return 服从 Guassian Distribution，但大量研究表明，Gaussian 不是一个好的 model. 实际上的 return 具有更加 heavy 的 tails.

在较短的时间尺度上，unconditional return 的 empirical density function 可以用 stsudent’s t distribution 较好地拟合，其 PDF 为：

f_r(r) = \dfrac{1}{\sqrt{\pi}} \dfrac{\Gamma[(1+\mu)/2]}{\Gamma[\mu/2]}\dfrac{a^\mu}{(r^2 + a^2)^{(1+\mu)/2}}

其中 $\mu$ 为 tail parameter， $a$ 则与 distribution 的 variance 有关： $\sigma^2 = a^2/(\mu - 2)$ .
tail parameter $\mu$ 被发现一般在 $3$ 附近。

当 $|r| \gg a$ 时， $f_r(r) \to \dfrac{a^{\mu}}{|r|^{1+\mu}}$ . 当 $\mu \to \infty$ 时，又变成了 Gaussian distribution.

Student’s t distribution 的 tail 比 Gaussian 重得多，这意味着罕见事件并没有那么罕见。使用 Gaussian Distribution 会低估低概率事件的风险。

Volatility Clustering

我们说：returns 看上去几乎是 uncorrelated 的。但它们肯定不是 IID 的。

这里再次区分一下 uncorrelated 和 independence：uncorrelated 仅仅表明不存在线性关系，而 independence 则是不存在任何关系。

假如 return 是 IID 的，那么根据大数定律，在足够多的观察下，其 distribution 一定会向 Gaussian Distribution 收敛。但实际上 returns 几乎总是 non-Gaussian 的。

实际上，金融市场是高度 inermittent 的。有的时候市场很活跃，有的时候市场很冷清。volatility 本身也是一个 dynamic variable.

returns 可以被分解为一个与时间有关的 volatility 项 $\sigma_t$ 和一个 directional component $\xi_t$ ：

r_t := \sigma_t \xi_t

在这个表达中， $\xi_t$ 是具有 unit variance 的 IID random variable，也就是方向和大小是相对随机的。但 $\sigma_t$ 是一个正的波动率指标。 $\sigma_t$ 被发现具有 long memory.

令 $\sigma_t = \sigma_0 e^{\omega_t}$ ，其中 $\sigma_0$ 是设置 volatility scale 的常量， $\omega_t$ 的 variogram 被发现可以用 Gaussian random variable 近似：

\mathcal{V}_\omega(\tau) = \left < (\omega_{t+\tau} - \omega_t)^2 \right > \approxeq \chi^2_0 \ln [1+\min(\tau,T)]

其中 $T$ 是一个很长的 cut-off time，一般以年为单位。 $\chi_0$ 设定了 log-volatility 波动的大小，经常被称为 volatility of the volatility(vol of vol). 对于大多数 assets， $\chi^2_0 \approxeq 0.05$ .

long memory 给出的 variogram 形式和 Ornstein-Uhlenbeck log-volatility process 听不一样的。后者使用一个 relaxation time $\tau_\omega$ 刻画：

\mathcal{V}_\omega(\tau) = \chi^2_0 \left( 1 - e^{-\tau / \tau_\omega} \right)

金融市场中的 volatility fluctuations 具有多重时间尺度。

volatility $\sigma$ 和 scaled return $\xi$ 并不是独立的，过去的正收益会减小未来的 volatility，而过去的负收益会增加未来的 volatility. 这被称为 leverage effect.

\tau >0, \left< \xi_t \sigma_{t+\tau} \right> <0

但是过去的 volatility 基本上无法预测未来的 return sign：

\tau < 0, \left< \xi_t \sigma_{t+\tau} \right> \approxeq 0

Activity Clustering

Market Activity 往往成堆出现。

midprice change 都有这么强的 clustering 吗(

假设价格每次只能变动一个 tick $\theta$ ，每单位时间变动频率 $\varphi$ ，相应的 variance 就是：

\sigma^2 = \varphi \theta^2

一个更精确的刻画是，选择一个时间 $t$ 以及一小段时间 $\mathrm{d} t$ ，考察这段时间内 price changes 的数量 $\mathrm{d} N_t$ ，当 midprice 发生了变动 $\mathrm{d} N_t = 1$ ，否则 $\mathrm{d} N_t=0$ . 由此可以得到平均市场活动 $\overline{\varphi}$ 的定义：

\left< \mathrm{d} N_t \right> := \overline{\varphi} \mathrm{d} t

其 covariance $\operatorname{Cov}\left[ \dfrac{\mathrm{d} N_t}{\mathrm{d}t}, \dfrac{\mathrm{d} N_{t+\tau}}{\mathrm{d}t} \right]$ 刻画了市场波动的短期结构。

市场活动既由 long memory 影响，也由短期的波动影响。

上面对市场价格变动的描述具有局限性。比如它无法刻画价格大部分时间稳定、但少数时间剧烈变动的情况。而实际市场中的价格往往具有两种波动：高频小波动和罕见的极端波动。

假设 return 遵循 Student’s t distribution，那么在 $4\sigma$ 外的极端事件贡献了 $30\%$ 的 total variance，这是相当大的一部分波动。而且很多大变动实际上也跟 news 无关，似乎是市场自发涌现的特性。

这两种事件微妙地相互联系。在时间 $t$ 增加的波动率，会倾向于在时间 $t+\tau$ 引发更多的市场活动。比如说一个大的 price jump 往往跟随着一段市场活跃时间。似乎存在某种 self-excitation 的现象。

Why Do Prices Move?

为什么价格会变动？为什么会出现 random walks 的表现？

直觉地考虑，市场价格似乎是这样变化的：

当某种 news 到来时，informed traders 参与买卖，使得价格快速移动以匹配其基本面。
随后，价格进行小幅度的、高频的波动，直到下一次 news 的到来。

但实际上，新闻的频率远远比大幅价格变动的频率低。大部分的 large price moves 似乎与 news 无关，而更像是交易活动的自发涌现。

这被称为 excess-volatility puzzle：实际上的波动率，和围绕 fundamental value 的波动相比，显著高得多。

此外，虽然消化 news 的影响、确定新的价格需要一段时间，金融市场似乎很少表现出 under-reaction(会创造趋势) 和 over-reaction(会创造 mean-reversion)，使得 signalture plots 几乎是平的。

一个观点是，高度优化的执行算法和做市算法，积极地寻找 return series 中的 correlation 并加以利用。这些算法因而抹去了 signature plots 中的不规则部分。

高频算法从低频策略产生的 inefficiency 中获利，从而使 return 在任意时间尺度上都呈现出纯粹的随机性。

price efficiency 也有两种考察方式：

fundamentally efficient：市场价格总是接近基本面。
statistically efficient：在基于技术分析的交易行为中，任何可预测的模式都被完全利用。

根据 Black 的理论，fundamental values 的锚定效用只有在 random fluctuations $\sigma\sqrt{T}$ 的影响降低到至少 50% 的时候，才能在时间尺度 $T$ 上观察到。对于 $\sigma= 20\%$ 的 stock market，这需要六年的时间(?

怎么感觉这么奇怪。Whatever，这本书主要考察的是 statistical efficiency.

Overview

在各种时间尺度下，price changes 都是高度 uncorrelated 的。当然，uncorrelated 不代表 independence.

市场的交易活动会使价格自发涌现出各种表现，而并不一定依赖于外部的新闻。
quantitative volatility/activity feedback models(例如 ARCH-type models、hawkes process) 认为至少 80% 的 price variance 是由 self-referential effects 引起的。

这意味着大部分的价格变动都可以用市场本身的 microstructure view 来解释，而不依赖于宏观基本面分析。这些微观结构在各种各样的 liquidity market 都是类似的。

感觉还有很多内容没有消化，以后再回来看吧。

References to Read

Bachelier, L. (1900). Théorie de la spéculation. Gauthier-Villars.
- 提出 Random Walk Model 的最早论文。
Empirical properties of asset returns: stylized facts and statistical issues
- 简述了几条 stylized facts.
The distribution of realised stock return volatility
- 用于理解 return volatility 的一篇文章。
Volatility is rough
- 还是关于 volatility.
Power laws in economics and finance. Annual Review of Economics
On the correlation structure of microstructure noise: A financial economic approach.
The endogenous dynamics of markets: Price impact, feedback loops and instabilities.
Reconciling Efficient Markets with Behavioral Finance: The Adaptive Markets Hypothesis

‍

1 The Ecology of Financial Market

Fri, 01 Nov 2024 09:28:40 GMT

为什么交易得以发生，市场的参与者们。阅读 Trades, Quotes and Prices 的第一章。

Originally Posted at: https://clouder0.com/zh-cn/posts/financial-market-ecology/

How Trade Happens

Traditional Way

金融市场都有哪些参与者？他们的各自的目的是什么？

任何交易，总是有两个参与方：Buyer & Seller. 买入的数量和卖出的数量总是相等。

价格由供需驱动。想象以下场景：

Buyer: 你这玩意卖多少钱？
Seller: 五块钱。
Buyer: 好，我要买它。
Seller: 现在卖六块钱了。
Buyer: ？？？逗我玩呢。
Seller: 因为我知道你要买了嘛。
Buyer: 但我要买一百个！便宜点呗。
Seller: 啊哈，那现在十块钱一个了。
Buyer: ？？？
Seller: 你就说你买不卖吧。

交易的双方总是希望自己能获得最大的利益。Seller 总是希望以 Buyer 能接受的最高价格成交，而 Buyer 总是希望以 Seller 可接受的最低价格成交。

既然如此，为什么大家能达成一致呢？每次交易的达成，似乎就总是意味着：有人做出了妥协。如果 Seller 一路提价至 Buyer 的承受极限并成交，那么 Buyer 就妥协并付出了更多的成本。反之亦然。

在这种博弈情形下，一个经典的策略是：

假如我是 Buyer，不论我最终愿意出多少，先报一个极低的价格。
然后通过反复拉扯试探，找到 Seller 愿意卖出的最低价格。
假如我是 Seller，不论 Buyer 如何报价，总是狮子大开口加价一大堆。
通过反复试探拉扯，找到 Buyer 愿意买入的最高价格。

在这个交易协商过程中，双方通过反复的报价缩小价格边界，并最终达成交易。

这是传统线下购物的主流拉扯手法，在七大姑八大姨去买东西的时候很常见(

形式化地，Buyer 最高可接受价格为 $\text{bid}$ ，Seller 最低可接受价格为 $\text{ask}$ ，当 $\text{bid} \ge \text{ask}$ 时，存在成交的可能。

此时 $p \in [\text{ask}, \text{bid}]$ 都是合法的价格。当 $p$ 较为接近 $\text{ask}$ 时，价格偏低，Buyer 占优。当 $p$ 较为接近 $\text{bid}$ 时，价格偏高，Seller 占优。

但是这样考虑有一个问题：比如图中在接近于 $\text{bid}$ 的位置成交，但实际上，我作为 Buyer，哪怕我实际上已经愿意出这个价格，我依然希望能尽量地压低成本，那么我会——继续报低价！

这类似于：我可以妥协，但我不愿意妥协，想逼你妥协。那么价格会进一步收敛。

…听起来很神奇对吧？为什么大家最终能够达成交易，这个交易的价格又到底是什么呢？

在实际的博弈中，总是有其他的因素考量：

时间成本。磨磨唧唧，你不买有的是人买。
……

理论上讲，一个理性人总是应当愿意做任何有利可图的交易，无论这个交易的利润多少。哪怕已经付出了很多时间扯皮，但在最终的时间点，只要依然能赚钱，哪怕利润微薄，都愿意卖出。

这似乎给了 Buyer 相当的议价自由。毕竟只要你卖就能赚，无非是赚多赚少，只要你能赚就应该和我 trade. 除非有别的 Buyer 出现。

……

是的，交易就是如此的困难。在金融市场中，哪怕是一个简单的交易，在双方都希望利益最大化的情况下，都需要如此拉扯，实在是太麻烦了。如何让交易高效地进行，并尽可能满足双方的利益，这就是金融学的一个重要研究目标。

Walrasian Auction

在刚刚的例子中，之所以长时间无法达成交易的主要原因是：双方总是通过连续报价来争取自己的利益，并试探对方的意图。

Walrasian Auction 对此给出的解决方案是：一锤子买卖。

引入中间商，收集 Buyer 和 Seller 的意图。Buyer 和 Seller 报单时，承诺一定会按这个价格达成交易。这种 commitment 在现代金融市场的语言中，被称为 liquidity provision.

Walrasian auctioneer 将这些报单收集到 orderbook 中，形成两个 $(\text{price}, \text{volume})$ 序列，然后进行撮合成交。一旦报单发生，Buyer & Seller 将不再能更改它们报出去的单，也就无法根据别人的报单而更改报价，从而避免了反复扯皮。

这形成了两个曲线，Supply Curve 和 Demand Curve：

\begin{aligned} S(p) = \sum \limits _{p' \le p} \text{AskVolume}(p') \\ D(p) = \sum \limits _{p' \ge p} \text{BidVolume}(p') \\ \end{aligned}

分别对应的是：愿意以 $p$ 价格卖出的数量，以及愿意以 $p$ 价格买入的数量。
当然，愿意以低于 $p$ 的价格 $p'$ 卖出的 Seller 一定也愿意以价格 $p$ 卖出，反之亦然，因此做一个累加。

可以看到，随着 $p$ 增大， $S(p) \uparrow$ ，而 $D(p) \downarrow$ .

我们最终可以找到一个全局最优的价格，让最多的交易得以发生。

Q(p^*) = \max \limits _p \min \left[S(p), D(P)\right]

注意，只有当 $\text{maxbid} \ge \text{minask}$ 时，才有可能有交易发生。当这个条件不满足，也就是 Best Bid 依然小于 Best Ask 时，不会发生交易。

如果 $S(p),D(p)$ 是连续的，那么在最优价格 $p^*$ 总是有 $S(p) = D(p)$ .

当然，实际上价格是离散的。那么，哪怕报单是相同的价格，也一定会有一些 Buyer/Seller 的需求无法得到满足。

这个时候，谁能成交，成交多少，就要根据具体的撮合机制判断了。常见的是按先来后到的顺序进行撮合。

Walrasian Auction 解决了成交的问题，但带来了一个新的问题：交易者无法根据市场上的信息动态地调整了。

Market Makers

随着信息技术的发展，传统的 Walrasian Auction 也被数字化改造了。

现在负责促成交易的是 Market Makers，他们主要做两方面工作：

Quoting: 在任意时刻，maker 必须承诺，他们将以 bidprice $b$ 成交至少 $V_b$ 手，并将以 askprice $a$ 成交至少 $V_a$ 手。
Clearing: 当 Buyers & Sellers 向 Maker 提交订单后，Maker 进行撮合，选择最优价格 $p^*$ 进行交易。

相比于传统的 Walrasian Auction，这套机制的最大不同点在于：Market Maker 给出了成交的承诺。这有两方面的好处：

让 Taker 能够以一个合理的市场价格，付出一定可控的额外成本来成交。这类似于下市价单。
提供了价格锚定，让 Buyer & Seller 能够合理地报价。

Market Maker 在特定的时刻进行撮合，找到成交量最大的 Best Price. 也就是找到 $p'$ 使得：

\sum \limits _{p' \ge p} \text{BidVolume}(p) = \sum \limits _{p' \le p} \text{AskVolume}(p)

Market Maker 的 initial quotes 也会包含在这个式子中，有的时候还会根据市场的报单额外再加一点，用来管理仓位、避免大幅价格波动之类的。

在这套系统中，Market Maker 处于特殊的地位。

Continuous-Time Double Auctions

而到了如今，基本上已经没有这种持有特权的 Market Maker 了。

现在，大家使用的是 Limit Order Book 撮合机制。Buyer & Seller 分别在对应的价格报单，并在极小的时间窗口中实时撮合。

例如，一个 Buyer 报单出现时，如果 Limit Order Book 上存在 $\text{ask} \le \text{bid}$ ，那么就会让这个 Buyer 和相应的 Seller 成交。一般遵循价格时间规则，当多个 Seller 满足 $\text{ask} \le \text{bid}$ ，则以最低价、次低价依次成交。当价格相同，再按时间先来后到，直到交易完成。

Ecology

当一个交易发生时，至少存在一个 Buyer，一个 Seller. 有人愿意买，有人愿意卖。

但价格总是会发生波动，也就意味着：总有一方吃亏，一方得利。买卖双方完成交易，转身互道一声傻 X. ……总是这样吗？

市场上的交易行为通常分为：

Informed trades，知道内部信息的 Trader 希望通过交易获利。
Uninformed trades，对未来价格没有预测的 Trader，有可能是为了流动性套现离场，有可能是为了降低仓位减小风险…这种交易被称为 noise trades，因为它们跟未来价格变动没什么关系。

但是，哪来的那么多内部信息呢，实际上 informed trades 更接近于：Traders 通过某种观察，要么是 Fundamental analysis 基本面分析，要么是 Quantitative analysis 技术分析，对未来的价格有了一些微弱的预测，然后进行交易。

这些 information 确实跟未来的价格有关，但——相关性一般都很小，而且时间尺度不一样。有的人做长线，看重几个月甚至几年的收益。有的人做短线超短线或者高频。做长线的交易者，愿意(或者说不得不)付出一定的成本给成功的短线交易者。类似这样，不同的需求、不同的策略、不同的生态，构建出了一个丰富的交易市场。

To Trade or Not to Trade?

交易是有成本的。Transaction Costs.

很多交易者频繁交易而付出了巨大的成本，这很多时候是因为他们高估了自己的 Signal 的准确率。

实际上，简单的考虑价格随机游走的情况，在任何时刻随便开一单，在任意的时间尺度上，总是有一半的概率能获利。这导致我们很难区分技术和运气。

Liquidity Providers

大部分交易策略试图预测未来价格并获利。但 Makers 不同，他们通过提供市场流动性获利。

一般而言，Makers 总是试图维持接近 0 的 net inventory，也就是持有相同的多仓空仓。在两侧挂单，吃 bid-ask spread 买卖价差：

s := a-b

如果价格相对稳定，那么当某个时刻，一个 Buyer 在 $a$ 价格成交，过了一会，一个 Seller 在 $b$ 价格成交，那么 Maker 就净赚了 $a-b$ .

听起来，Maker 似乎稳赚不赔，但现实当然并非如此。Maker 的 Risk 是什么呢？

最重要的是 adverse selection. 因为 Maker 总是两侧公开挂单并等待成交，而对未来价格有更好预测的 Taker 就会吃单，而他们的成交和未来的价格移动是存在相关性的。

比如说：当一个公司爆出重大利好，价格会急剧上涨，此时 Maker 提供流动性进行了大量的 Sell，然后价格上涨了，Maker 巨亏离场。

价格波动时，Maker 当然会动态调整两侧挂单价格、挂单量或者 Spread.

Maker 适合震荡行情，在单边行情中不那么合适。

当 Maker 观察到 order-flow imbalance，也就是买卖订单不平衡时，往往他需要相应地调整挂单价格。如果他收到了更多的 buy orders，那么他就会提高 askprice $a$ 来减少 buy orders、提高 bidprice $b$ 来增加 sell orders.

这也就意味着，成交存在 price impact. Buy order 使价格上升，Sell order 使价格下降。

m:= \dfrac{a+b}{2}

$m$ 记为 midprice. $\mathbb{E}[m_{\infty}]$ 为 $m$ 的未来预期值。由于少量交易是 informed trades，跟未来的价格存在相关性，这意味着当一个 buy order 成交后，期望会上升一点点。一个 sell order 成交后，期望会下降一点点。

将 $\varepsilon$ 记为交易的方向，对于 buy trade $\varepsilon = +1$ ，对于 sell trade $\varepsilon = -1$ ， $\mathcal{R}_\infty$ 代表交易的 long-term impact，则有：

\mathcal{R}_\infty := \mathbb{E}[\varepsilon \cdot (m_\infty - m)]

只要交易和未来价格移动有正向的关联， $\mathcal{R}_\infty > 0$ .

现在考虑，Maker 成交时，每笔成交本来应当赚到 Half Spread $\dfrac{s}{2}$ ，但实际上因为存在 price impact，实际的收益是 $s/2 - \mathcal{R}_\infty$ .

那么 Spread 必须要足够大，满足 $s \ge 2 \times \mathcal{R}_\infty$ ，Maker 才有利可图。当然，这里还忽略了 Transaction Costs 之类的。

不幸的是，大量的小交易都含有一定的信息，让 Maker 付出一定的 impact cost. 而少数时候，有一些订单和未来价格高度相关，从而造成 Maker 的大幅亏损。

考虑一个简单的例子：

到来的订单有 $\phi$ 的概率是 informed，成功预测了未来的 $\pm J$ 的价格移动。剩余的是 uninformed.
假设所有交易独立，那么有 $\mathcal{R}_\infty = \phi J$ ，Maker 至少需要设置 $s=2\phi J$ .

Liquidity providers 一般不会放很大的 Volume 在 LOB 上，因为有可能被 informed trader 干一票大的。所以市场上存在少量的 revealed liquidity 和大量的 latent liquidity.

那么，当较大的交易发生时，一般都不得不拆成很多的小单，以避免产生过大的 Price Impact 而拉高成本。在这种情况下，LOB 上的信息总是并不揭示全部的真实信息，imbalance 也可能是潜藏的。Equilibrium 似乎总是一种遥不可及的、像是完美的圆那样的存在。

Blog build in progress...

Wed, 30 Oct 2024 14:34:26 GMT

Brand new blog: https://clouder0.com

目前进度：

图片测试：

PageSpeed Insights

拿下！

Docker 自建 Registry

Wed, 30 Oct 2024 12:44:11 GMT

如果你需要保存自己的镜像，但又不想直接公开出来，那么可以选择自建 Registry.

如果想要加速国内访问，可以选择自建 Docker Proxy，或者使用 https://dockerproxy.net.

本文发表于 https://clouder0.com/zh-cn/posts/docker-registry-self-host/.

需要把我自己打包的 image 部署出来，自建一个 registry.

参考资料：https://distribution.github.io/distribution/about/deploying/

首先生成一个账号密码：

mkdir auth
docker run --entrypoint htpasswd httpd:2 -Bbn testuser testpassword > auth/htpasswd

然后写 docker-compose：

registry:
  restart: always
  image: registry:2
  ports:
    - 5000:5000
  environment:
    REGISTRY_AUTH: htpasswd
    REGISTRY_AUTH_HTPASSWD_PATH: /auth/htpasswd
    REGISTRY_AUTH_HTPASSWD_REALM: Registry Realm
  volumes:
    - ./data:/var/lib/registry
    - ./auth:/auth

进行一个测试：

docker login localhost:5000

登录上就行了。

然后反代，我使用 Caddy：

example.com:5001 {
        reverse_proxy localhost:5000
        tls yourmail@outlook.com
}

Done.

之后就可以用 docker login example.com:5001 来登录了。

Usage

之后怎么使用呢？

比如我们本地有一个叫做 test 的 image，那我们首先给它打上标签：

docker tag test example.com:5001/test

然后再 push 过去：

docker push example.com:5001/test

在另一边，也是同样的：

docker pull example.com:5001/test

当然，也可以在 compose file 里使用。

‍

Useful Tool Notes

Wed, 30 Oct 2024 09:43:13 GMT

我决定汇总一下我觉得值得记忆的各种小工具。这是一个 TLDR.

Python

环境项目管理：uv
formatter & linter：ruff
多版本集成测试：nox
数据处理相关
- polars: better than pandas
- sklearn: 好东西。
- seaborn: 为 matplotlib 擦屁股
- PyGWalker: 探索 DataFrame feature
- pandas-profile: EDA 工具，探索 feature. 比上面那个好用。
- Lux: 挖掘 feature 趋势
- cufflinks: plotly 封装
- plotly: dynamic plotting
- plotnine: ggplot2 for python
- lets-plot: ggplot2 for python again
scalene: module time consumption record
prettyerrors
dash: build ML web app

Linux

使用 ArchLinux，of course.

考虑过其他的选项，比如 NixOS. 但是 Nix 有其固有的缺陷，Steep Learning Curve，还有并不明显的收益。Reproducible Build 真的那么重要吗？对于 Personal Daily Use 来说，我觉得 AUR is somewhat more important. Dirty but just works.

Btrfs 文件系统，建各种 subvolumes. 没必要做分区了。
Timeshift 配合 btrfs 做 snapshots.
Paru，AUR package manager. 或者用 yay，感觉差不多。
Fish Shell，装好之后跑一遍 fish_config 做一些配置，主要是调整一下 Prompt. 开箱即用了，体验还是不错的。
KDE Plasma6，虽然稍微考虑过 Hyprland 之类的，但是因为有 RTX 独显，担心存在兼容性问题，所以还是算了。
Fcitx5，输入法，无需多言。自带的双拼已经满足我了，装一个词库就行了。
Tmux，日常使用的东西。
ov，Pager，用来取代 less 的玩意，感觉差不多。
ripgrep，搜索工具。可以用来搜索某个目录下的文件，支持 in-file search.
zoxide，z 快速到达经常访问的文件夹。zi 可以 interactive select.
fzf，fuzzy find tool.
fastfetch，emmm，neofetch alternative？看着玩的。
bat，better cat alternative.
neovim，我的日常编辑器。
- vim 大家都很熟悉了(?，复制粘贴可能要留意一下，用 "+y 拷贝到 + 寄存器里面，也就是系统 Clipboard. 注意要先安装一个 xclip 之类的。
#TODO# zed，感觉很 promising.
vscode，我的日常 light weight IDE。
devbox，用来管理开发环境的小东西。各种语言的具体环境都用它来做管理了。
- 目前不怎么用了，too much overhead. 每个语言都有自己的解决方案。
Yakuake，我个人习惯使用的 Drop Down Terminal，也是我在 Windows 下最怀念的东西之一。
SiyuanNote，我的常用笔记软件。
QQ，得益于 Electron 的流行，我们现在终于有 Linux Native QQ 可以使用了，Congrats！
- 当然还是没有微信。
Okular，PDF 阅读器，这个其实已经挺好用的了。
Ark，解压缩工具。
Xpipe，一个管理各种 Servers 的工具，挺好用的。

DevOps

哪吒监控，一个小探针，没什么好说的，拉起来挺方便。
Dockge，uptime kuma 作者出的一个轻量化容器管理平台，支持 Agent，可以把多个服务器的 docker compose 放在一起管。比 Portainer 轻量一些。
Docker-Proxy，一个能够自建 Docker Mirror 的工具。
- 不过实际上我建议使用：https://ghp.ci 和 https://dockerproxy.net.
‍
#TODO# SeaweedFS，一个优雅的分布式文件系统，可以提供 S3 API，充分利用各种小鸡。
Tailscale，令人愉悦的异地组网工具。
- 国内安装可以使用：curl -fsSL https://ts-mirror.xedge.cc/install.sh | sh
- xedge 是一个国人的 Tailscale 二开。
#TODO# Prometheus Grafana
#TODO# k3s
#TODO# Argo.CD
#TODO# airflow/prefect
#TODO# ansible
新 vps 到手工作流

Productivity

SiyuanNote，我的常用笔记软件。
LinkWarden，一个漂亮的 bookmark 管理工具，带 browser extension，支持公开分享。
VaultWarden，bitwarden 的 selfhost 版本。

Frontend

Bun，NodeJS alternative，开箱即用非常爽。
BiomeJS，eslint alternative，跑得很快。
Preact，react 的小小代替品，主要卖点是比较小。
solidjs，戏称为 react done right.
TailwindCSS，基本上是现在的事实标准了。
#TODO# UnoCSS，后起之秀。
Astro，动态内容相对较少的时候很好用，感觉比 next.js 之流清爽。目前我的博客由 Astro 驱动。
#TODO# expressive-code，看起来比 shiki 更成熟的一个高亮代码显示。

Backend

Directus，Backend as a Service 或者说 headless CMS，可以快速提供一个还算能用的后台页面，出活方便。

Blog

Giscus，基于 GitHub Discussion 的评论框架。不过感觉有点灵车。
Utterance，基于 GitHub Issues 的评论框架。

‍

DecisionTree

Mon, 28 Oct 2024 20:44:49 GMT

DecisionTree，决策树，是一种 non-parametric supervised learning 方法，应该说是 Machine Learning 中相当流行的方法了。

当我们人在做决策的时候，我们是如何思考的？

如果 X，则…

很合理。实际上，对于任意的决策，都有一系列的思考路径 A->B->C->…，将每一个思考并选择的事件视作是一种分叉节点，得到最终思考结果的位置作为叶子，我们就得到了一棵决策树。决策树本身结构很简单，但表达力是极强的，理论上可以拟合任意的决策过程。

当然，只是理论上。实际上决策树的训练采用的是启发式贪心算法，所以也没那么厉害。

决策树有许多的优点。它非常灵活，可以拟合非线性关系，可以可视化出每一个节点，还算可以理解。对数据没什么要求，拿起来就能用。能处理 Classification 和 Regression，能处理 numerical variable 和 categorical variable. 可以处理 multi output…

sounds great，那么，代价是什么呢？

由于决策树过于灵活，很容易出现 overfit. 一般 DecisionTree 会作为 Base Method，采用 Ensemble 方法去做 RandomForest、GradientBoosting 之类的。
决策树的预测输出是不连续的，这意味着它在 Extrapolation 上表现是比较差的。
求解最佳决策树是 NPC 问题，一般都采用启发式的训练方法。
有一些关系是树模型比较难以学习的，比如 XOR、parity、multiplexer 之类的。
如果训练集的 class 不均匀，可能会产生 biased trees.
在表达变量之间的 interaction 时有局限性。或者说 Decision Boundaries 必须垂直于坐标轴，表达斜线之类的比较困难，但也可以一定程度上表达出来。

一般而言，决策树适用于：

样本量相对较大。
对可解释性有一定要求，但又不是那么有要求。
对泛化能力要求相对不那么高，或者说样本足够覆盖我们在乎的常见情况。

决策树相对而言还是没那么好用，但其衍生的随机森林之类的 Ensemble Methods 可以说是超级流行的 ML 算法了。

Algorithms

Model

决策树的基本思想是：每个节点是一个 condition，比如说 $x_1 > 0.5$ ，又比如 $x_2 < 0.3$ . 组成的一棵树，最终的叶子节点就是 output.

决策树递归地划分 feature space.

设被归类至节点 m 处的数据为 $Q_m$ ，包含 $n_m$ 个样本，对于每一个可能的 split $\theta = (j, t_m)$ ，代表选择第 $j$ 个 feature，设置阈值为 $t_m$ ，即在这个节点使用条件 $x_j \le t_m$ 划分样本。

如果 split 选定了，就可以划分得到：

\begin{aligned} Q^{\text{left}}_m(\theta) = \{(\mathbf{x},y) \mid x_j \le t_m \} \\ Q^{\text{right}}_m(\theta) = \{(\mathbf{x},y) \mid x_j > t_m \} \end{aligned}

可以使用 impurity function 或者 loss function $H()$ 来评估划分的质量。这里的评估需要根据具体问题来选择， classification 和 regression 是不一样的。可以表述为：

G(Q_m, \theta) = \dfrac{n^{\text{left}}_m}{n_m} H\left( Q^{\text{left}}_m(\theta) \right) + \dfrac{n^{\text{right}}_m}{n_m} H\left( Q^{\text{right}}_m(\theta) \right)

选择最优的参数使 impurity 最小：

\theta^* = \argmin _\theta G(Q_m, \theta)

递归处理子集直到达到最大深度。

如果是 Classification 问题的话，分类结果可能为 $0,1,\cdots,K-1$ ，对于节点 $m$ ，记：

p_{mk} = \dfrac{1}{n_m}\sum \limits _{y\in Q_m} I(y=k)

为 class $k$ 在节点 $m$ 中的数量。若 $m$ 是一个终止节点，则相应的 class probability 设置为 $p_{mk}$ .

常用的 impurity 度量：

Gini:

H(Q_m) = \sum \limits _k p_{mk}(1-p_{mk})

Log Loss 或 Entropy:

H(Q_m) = - \sum \limits _k p_{mk} \log (p_{mk})

使用信息熵等价于最小化 Log Loss.

如果是 Regression 的话，常用的指标包括 MSE、Mean Poisson deviance 和 Mean Absolute Error.

Training

一般而言，大家使用的是迭代式的贪心算法。常见的实现包括 CART、C5.0、ID3.

不管了，我自己写一个吧。

在每一个节点，对于每一个 feature $x_i$ ，都有一系列可能的取值。排序去重后，得到一个 $\bm{v}_i$ .

对于 numerical variable， $v_{ij} \in \mathbb{R}$ ，对于 categorical， $v_{ij}$ 则是一个 class. 这两种需要分开看待。

对于 numerical feature，我们需要遍历可能的阈值 $t$ ，筛选 $(\bm{x},y) \text{ satisfies } x_i \le v_{it}$ ，并且选择最优的 $t$ 使得 loss 最小。

对于 categorical feature，我们需要遍历所有可能的 class $t \in \bm{v}_i$ ，筛选 $x_i = t$ 和 $x_i \neq t$ 两个分类，然后选择最优的 $t$ 使得 loss 最小。

每一步都如此操作，就需要遍历 $O(|\text{features}| \times n_m)$ 次，过程中 loss 是可以动态更新的。总的复杂度为 $O(|\text{features}| \times n \times \text{depth})$ .

实现的时候，每个 feature 逐个设置 threshold,更新 left tree 的 class counts. 排序这里可以预处理离散化，然后用桶排序做到线性，如果直接排序的话总复杂度会退化到 $O(|\text{features}| \times n\log n \times \text{depth})$ .

为了省事，还是这么做了。实现得很粗糙。

一般大家还会设置一些常用的限制，比如 max depth、min samples split、min samples leaf、min purity decrease 等。

std::unique_ptr<TreeNode> DecisionTree::_fit(size_t n, Sample *samples,
                                             int depth) {
  #ifdef DEBUG
  puts("");
  puts("");
  printf("fitting with %lu samples\n", n);
  #endif
  std::vector<size_t> counts;
  std::vector<size_t> now_counts;
  counts.resize(this->labels);

  // count all labels
  for (size_t idx = 0; idx < n; ++idx) {
    counts[samples[idx].label]++;
  }

  // check if all labels are the same
  size_t most_freq = 0;
  for (size_t idx = 0; idx < this->labels; ++idx) {
    if (counts[idx] == n) {
      return std::make_unique<TreeNode>(leaf_node(idx));
    }
    if (counts[idx] > counts[most_freq]) {
      most_freq = idx;
    }
  }

  if (depth >= this->options.max_depth ||
      n <= this->options.min_samples_split) {
    return std::make_unique<TreeNode>(leaf_node(most_freq));
  }
  int split_type = 0; // 1 for num, 2 for cat
  size_t feat_idx = 0;
  double threshold = 0;
  int cate = 0;

  double minloss = 1e20;
  double init_loss = 0;
  for (size_t k = 0; k < this->labels; ++k) {
    init_loss -= (counts[k] * 1.0 / n) * log(counts[k] * 1.0 / n);
  }

  if (this->feat_nums > 0) {
    now_counts.resize(this->labels);
    for (size_t idx = 0; idx < this->feat_nums; ++idx) {
      // sort by this feature
      std::sort(samples, samples + n, [&](Sample const &a, Sample const &b) {
        return a.nums[idx] < b.nums[idx];
      });
      // now calculate loss dynamically
      double loss = 0;
      // reset to zero
      std::memset(now_counts.data(), 0, sizeof(size_t) * this->labels);
      double last = samples[0].nums[idx];
      for (size_t i = 0; i < n; ++i) {
        // split between [0, i] and (i, n)
        // only ends on unique values
        now_counts[samples[i].label]++;
        while (i + 1 < n && samples[i + 1].nums[idx] == samples[i].nums[idx]) {
          ++i;
          now_counts[samples[i].label]++;
        }
        // all nodes in left tree, break
        if (i >= n - 1)
          break;
        // left tree size i + 1, right tree size n - i - -1
        loss = 0;
        #ifdef DEBUG
        std::print("NUM split at feat {} num {}\n", idx, samples[i].nums[idx]);
        #endif 
        for (size_t k = 0; k < this->labels; ++k) {
          // left
        #ifdef DEBUG
          std::print("class {}, now counts {}\n", k, now_counts[k]);
        #endif 
          if (now_counts[k] > 0) {
            auto pmf_left = 1.0 * now_counts[k] / (i + 1);
            loss -= 1.0*(i+1)/n * pmf_left * std::log(pmf_left);
        #ifdef DEBUG
            std::print("left total {}, class {}, loss contri {}\n", i + 1,
                       now_counts[k], -pmf_left * std::log(pmf_left));
        #endif 
          }
          // right
          if (counts[k] - now_counts[k] > 0) {
            auto pmf_right = 1.0 * (counts[k] - now_counts[k]) / (n - i - 1);
            loss -= 1.0*(n-i-1)/n * pmf_right * std::log(pmf_right);
        #ifdef DEBUG
            std::print("right total {}, class {}, loss contri {}\n", n - i - 1,
                       n - now_counts[k], -pmf_right * std::log(pmf_right));
        #endif 
          }
        }
        #ifdef DEBUG
        std::print("init loss {} split at feat {} num {}, loss {}\n", init_loss,
                   idx, samples[i].nums[idx], loss);
        puts("");
        #endif 
        if (loss < minloss) {
          minloss = loss;
          split_type = 1;
          threshold = samples[i].nums[idx];
          feat_idx = idx;
        }
      }
    }
  }
  if (this->feat_cats > 0) {
    now_counts.resize(this->labels);
    for (size_t idx = 0; idx < this->feat_cats; ++idx) {
      // sort by this feature
      std::sort(samples, samples + n, [&](Sample const &a, Sample const &b) {
        return a.cats[idx] < b.cats[idx];
      });
      // now calculate loss dynamically
      double loss = 0;
      // reset to zero
      for (size_t i = 0; i < n; ++i) {
        #ifdef DEBUG
        std::print("CAT split at feat {} cate {}\n", idx, samples[i].cats[idx]);
        #endif
        std::memset(now_counts.data(), 0, sizeof(size_t) * this->labels);
        // calculate counts in this cateogry
        now_counts[samples[i].label]++;
        size_t to = i;
        while (to + 1 < n &&
               samples[to + 1].cats[idx] == samples[to].cats[idx]) {
          ++to;
          now_counts[samples[to].label]++;
        }
        auto now_size = to - i + 1;
        auto remain_size = n - now_size;
        i = to;
        loss = 0;
        for (size_t k = 0; k < this->labels; ++k) {
        #ifdef DEBUG
          std::print("nowcount[{}] = {}, counts[{}] = {}\n", k, now_counts[k], k, counts[k]);
          #endif
          if (now_counts[k] > 0) {
            auto pmf_now = 1.0 * now_counts[k] / now_size;
            loss -= 1.0 * now_size / n * pmf_now * std::log(pmf_now);
        #ifdef DEBUG
            std::print("left total {}, class {}, loss contri {}\n", now_size,
                       now_counts[k], -pmf_now * std::log(pmf_now));
            #endif
          }
          if (counts[k] - now_counts[k] > 0) {
            auto pmf_remain = 1.0 * (counts[k] - now_counts[k]) / remain_size;
            loss -= 1.0 * remain_size / n * pmf_remain * std::log(pmf_remain);
        #ifdef DEBUG
            std::print("right total {}, class {}, loss contri {}\n", remain_size,
                       counts[k] - now_counts[k], -pmf_remain * std::log(pmf_remain));
            #endif
          }
        }
        if (loss < minloss) {
          minloss = loss;
          split_type = 2;
          cate = samples[i].cats[idx];
          feat_idx = idx;
        }
      }
    }
  }
  if ((1.0*(init_loss - minloss)/init_loss <= this->options.min_purity_decrease)) {
    #ifdef DEBUG
    std::print("init {}, min {} purged by purity", init_loss, minloss);
    #endif
    return std::make_unique<TreeNode>(leaf_node(most_freq));
  }
  if (split_type == 1) {
    // partition samples by threshold
    size_t p = 0, q = 1;
    while (samples[p].nums[feat_idx] <= threshold)
      ++p;
    q = p + 1;
    while (q < n) {
      if (samples[q].nums[feat_idx] <= threshold) {
        std::swap(samples[p], samples[q]);
        ++p;
      }
      ++q;
    }
    #ifdef DEBUG
    std::print("Best NUM, threshold {} feat {} minloss {}\n", threshold, feat_idx, minloss);
    #endif
    if (p < this->options.min_samples_leaf ||
        n - p < this->options.min_samples_leaf) {
      return std::make_unique<TreeNode>(leaf_node(most_freq));
    }
    // now [0, p) <= threshold, [p, n) > threshold
    auto cur = std::make_unique<TreeNode>(num_node(feat_idx, threshold));
    cur->ls = this->_fit(p, samples, depth + 1);
    cur->rs = this->_fit(n - p, samples + p, depth + 1);
    return cur;
  }
  // partition sample by category
  size_t p = 0, q = 1;
  while (q < n) {
    if (samples[q].cats[feat_idx] == cate) {
      std::swap(samples[p], samples[q]);
      ++p;
    }
    ++q;
  }
  #ifdef DEBUG
  std::print("Best CAT, cateogry {} feat {} minloss {}\n", cate, feat_idx, minloss);
  #endif
  if (p < this->options.min_samples_leaf ||
      n - p < this->options.min_samples_leaf) {
    return std::make_unique<TreeNode>(leaf_node(most_freq));
  }
  auto cur = std::make_unique<TreeNode>(cat_node(feat_idx, cate));
  cur->ls = this->_fit(p, samples, depth + 1);
  cur->rs = this->_fit(n - p, samples + p, depth + 1);
  return cur;
}

‍

RSA

Mon, 28 Oct 2024 20:30:59 GMT

RSA，Rivest-Shamir-Adleman 算法，是一个常见的非对称加密算法。本文将简明扼要通俗易懂地介绍 RSA 的原理，并给出 Python 实现。

本文同步发表于我的博客 https://clouder0.com/zh-cn/posts/rsa/

Why we need RSA？

加密的需求大家都很熟悉，但非对称加密呢？我们为什么需要非对称加密？

想象以下的场景：

数字签名： 你希望以你的名义发送一封邮件(或者发布任何的数据内容)，并且向公众公开。
- 但是，你不希望有其他人能够以你的名义发布内容。
- 这个时候，公众可以解密，你可以加密。你持有私钥，公众持有公钥。私钥签名，公钥验签。
加密通讯： 你建了一个小网站，你希望用户的数据在传输到你的网站的过程中是安全的。也就是说，用户发送加密后的数据，你解密数据。
- 这个时候，用户持有公钥进行加密，你持有私钥进行解密。
- 任何人都可以向你发送加密内容，但只有持有私钥的你才能解密。

这是非对称加密的两大经典应用场景。

如果只才能对称加密的话，这两种场景都是无法实现的：数字签名自然不必说，加密通讯的话，由于你需要让公众具有加密的能力，但又不希望他们能够解密，自然也需要非对称。

How is this possible？为什么还能做出这种「有两种密码，一个加密一个解密」的神奇算法呢？

这一般都是利用了非对称性。例如：将两个质数乘起来得到结果是简单的，但想要对某个大数做质因数分解，复杂度则极其高。

How RSA works…

RSA 利用的就是质因数分解复杂度的非对称性。

我们首先选择两个足够大的质数，记为 $p,q$ ，然后：

计算 $n=pq$ ，这将用作模数。 $n$ 的长度被称为 key length，现在比较流行的是 512/2048/4096bits.
计算 $\lambda(n)$ ，即 $n$ 的 Carmichael’s totient function. 也就是找到最小的正整数 $m$ 使得 $a^m \equiv 1 \pmod n$ 对任意 $a$ 都成立。
- 在原教旨 RSA 中，选取的 $\lambda(n)$ 实际上是 Euler’s totient function，不是最小的正数 $m$ ，会比较大，但也是能用。
- 现在一般选用 $\lambda(n) = \operatorname{lcm}(p-1,q-1)$ . 证明等会再说。
选择一个整数 $e$ ，满足 $e \in (1,\lambda(n))$ 且 $\gcd(e, \lambda(n)) = 1$ .
- $e$ 最好具有较短的 bit-length 和较小的 hamming weight，大家经常选用的是 $e=2^{16}+1= 65537$ .
计算 $d \equiv e^{-1} \pmod {\lambda(n)}$ ，也就是 $e$ 的乘法逆元。

好的，密钥生成部分结束了。

接下来，我们将 $(n, e)$ 作为加密密钥， $(n,d)$ 作为解密密钥。而剩下的 $p,q,\lambda(n)$ 应当保密或者直接扔掉。

然后就是加密了，加密相当的简单啊，加入我们想要传递原文 $M$ ，首先使用 padding 将其变成 $m$ ，满足 $0 \le m < n$ . 这里的 padding 只要是一种可逆的变换就行了。

然后计算： $c \equiv m^e \pmod n$ ，这里的 $c$ 就是我们的加密结果了。

使用快速幂，可以在较短的时间内完成计算。

解密也相当的简单，我们持有密文 $c$ ，想要获得 padded 后的原文 $m$ ，那么：

c^d \equiv (m^e)^d \equiv m \pmod n

这里利用的核心原理是： $ed \equiv 1 \pmod n$ ，实际上这就是 $d$ 的定义式。

相信大家已经完全理解 RSA 了，笑。

Math behind the scene

让我们思考一下，RSA 算法的执行流程已经讲完了，但它为什么能保证安全性、为什么能保证正确性呢？

RSA 的核心原理是： $e$ 和 $d$ 只有一个公开。而 $m^{ed} \equiv m^{\lambda(n)} \equiv m \pmod n$ .
这里 $ed \equiv \lambda(n) \pmod n$ 就是解密密钥 $d$ 的定义式。而 $m^{\lambda(n)} \equiv m \pmod n$ 就是 $\lambda(n)$ 的定义式。

实际上， $e$ 和 $d$ 是相当对称的。假如持有 $e$ 进行加密，加密后 $c=m^e$ ，则 $c^d \equiv m$ . 用 $d$ 加密也是一样的： $c=m^d, c^e = m$ .

也就是——实际上持有公钥的用户也可以既加密、又解密……吗？比如我们原本约定好公钥加密，私钥解密，that’s fine. 但哪天你抽风了说我们换换位置，公钥解密私钥加密，那也是无缝切换。

当然，工程实践上公钥经常取固定的 $e=65537$ ，嘛。

接下来还有一个问题， $\lambda(n) = \operatorname{lcm}(p-1,q-1)$ ，为什么就有 $m^{\lambda(n)} \equiv m \pmod n$ ？

根据众所周知的费马小定理，我们知道：当 $p$ 为素数时， $a^{p-1} \equiv 1 \pmod p$ .

而当 $n=pq$ 时，显然 $n$ 就不是素数了，我们要找到 $a^{\lambda(n)} \equiv 1 \pmod n$ ，这个时候可以使用欧拉定理：

a^b \equiv \begin{cases} a^{b \bmod \varphi(p)},b < \varphi(p) \\ a^{b \bmod \varphi(p) + \varphi(p)},b \geq \varphi(p) \end{cases} \pmod{p}

其中 $\varphi(p)$ 为欧拉函数。欧拉函数满足积性，也就是 $\varphi(pq) = \varphi(p) \times \varphi(q)$ . 并且有对于素数 $p$ ， $\varphi(p) = p-1$ .

那么 $\varphi(n) = \varphi(pq) = \varphi(p) \times \varphi(q) = (p-1)(q-1)$ ，非常 reasonable.

那么显然，我们就可以得到：

a^{\varphi(n)} \equiv a^0 \equiv 1 \pmod n

这就算是求出了一个满足需要的 $\lambda(n)$ …了吗？注意到我们的定义是最小的 $m$ 使得 $a^m \equiv 1 \pmod n$ ，这里的 $\varphi(n)$ 未必是最小的。

当然，实际上是不是最小的其实对 RSA 影响不大。

接下来就是 Carmichael function，其计算如下：

\lambda(n) = \begin{cases} \varphi(n), &\text{if } n \text{ is }1,2,3,4 \text{ or an odd prime power} \\ \dfrac{1}{2}\varphi(n), &\text{ if } n = 2^r, r \ge 3 \\ \operatorname{lcm}\left( \lambda(n_1),\cdots,\lambda(n_k) \right), &\text{ if } n = n_1n_2\cdots n_k, \text{ where } n_i \text{ are}\\ &\text{ power of distinct prime numbers} \end{cases}

在这里，因为 $n=pq$ 且 $p,q$ 都是质数，那么 $\lambda(pq) = \operatorname{lcm}(\varphi(p),\varphi(q))= \operatorname{lcm}(p-1,q-1)$ .

Implementation

涉及到大数运算，人生苦短，我用 Python.

但是 Python 确实不是很快，我决定使用稍微短一些的 pq. 1024bits 吧，这样最终的 $n$ 就是 2048bits.

以下是核心代码：

import random


def miller_rabin(n: int, k: int):
    """use miller rabin method to test prime."""
  
    if n == 2:
        return True

    if n % 2 == 0:
        return False

    r, s = 0, n - 1
    while s % 2 == 0:
        r += 1
        s //= 2
    for _ in range(k):
        a = random.randrange(2, n - 1)
        x = pow(a, s, n)
        if x == 1 or x == n - 1:
            continue
        for _ in range(r - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    return True


def exgcd(a: int, b: int):
    """exgcd to cacl inverse."""
    if b == 0:
        return a, 1, 0
    d, x, y = exgcd(b, a % b)
    x, y = y, x - (a // b) * y
    return d, x, y


def is_prime(n: int) -> bool:
    return miller_rabin(n, 40)

def inv(a: int, m: int) -> int:
    """calc modular inverse."""
    d, x, y = exgcd(a, m)
    if d != 1:
        raise RuntimeError("modular inverse does not exist")
    return x % m


def rsa_encrypt(m: int, e: int, n: int) -> int:
    return pow(m, e, n)


def rsa_decrypt(c: int, d: int, n: int) -> int:
    return pow(c, d, n)


def gcd(a: int, b: int) -> int:
    if b == 0:
        return a
    return gcd(b, a % b)


def lcm(a: int, b: int) -> int:
    return a * b // gcd(a, b)


def rsa_gen(p: int, q: int) -> tuple[int, int, int]:
    n = p * q
    l = lcm(p - 1, q - 1)
    e = 65537
    d = inv(e, l)
    return n, e, d


def get_big_prime():
    while True:
        p = random.getrandbits(1024)
        if is_prime(p):
            return p


def get_pq() -> tuple[int, int]:
    return get_big_prime(), get_big_prime()

def main():
    n, e, d = rsa_gen(*get_pq())
    print("n =", n)
    print("e =", e)
    print("d =", d)
    origin = int(input("origin: "))
    c = rsa_encrypt(origin, e, n)
    print("c =", c)
    print("origin =", rsa_decrypt(c, d, n))

    assert origin == rsa_decrypt(c, d, n)

    print("OK")


if __name__ == "__main__":
    main()

一般而言，RSA 的速度较为缓慢，我们可以将 RSA 和对称加密配合使用，比如说用 RSA 传递对称加密的密钥，以实现加密通讯。

处理的长度过长的时候，需要分块。emmm,注意到计算在 $\bmod n$ 下进行，需要分块后比 $n$ 小。

def encrypt_file(n, e):
    with open("input.txt", "rb") as f:
        data = f.read()
    # chunking by 255 bytes
    chunks = [data[i : i + 255] for i in range(0, len(data), 255)]

    with open("output.txt", "wb") as f:
        for chunk in chunks:
            m = int.from_bytes(chunk, "little")
            c = rsa_encrypt(m, e, n).to_bytes(512, "little")
            f.write(c)


def decrypt_file(n, d):
    with open("output.txt", "rb") as f:
        data = f.read()

    chunks = [data[i : i + 512] for i in range(0, len(data), 512)]
  
    with open("output_de.txt", "wb") as f:
        for chunk in chunks[:-1]:
            c = int.from_bytes(chunk, "little")
            m = rsa_decrypt(c, d, n).to_bytes(255, "little")
            f.write(m)

        c = int.from_bytes(chunks[-1], "little")
        m = rsa_decrypt(c, d, n).to_bytes(255, "little")
        # trim trailing zeros
        while m[-1] == 0:
            m = m[:-1]
        f.write(m)
          
def test_file():
    n, e, d = rsa_gen(*get_pq())
    encrypt_file(n, e)
    decrypt_file(n, d)

‍

test

Sat, 26 Oct 2024 22:58:12 GMT

这是一个测试文档。siyuan://blocks/20210725161402-m41l7ao

用于测试你想测试的东西。1

比如引用

按下 / 可以呼出功能菜单。

‍

可以查看 ((20200923234011-ieuun1p ‘Please Start Here’)) 的用户手册，由于系统是英文的，手册也是英文的。

列表
可以折叠
- 像这样
善用 Tab 与 Shift+Tab
- 有趣的 Feature
可以移动列表项：Ctrl+Shift+up/down
不知道 Mac 上快捷键长啥样、、、

加粗

删除

$\LaTeX$

LONG \LaTeX

\ce{Cl2 + H2 ->[CCP] Au + Ag}

还有一个封装的客户端，支持 Windows/Mac/Linux 但需要单独分发，有需要再上传吧、、、

标题

111

子标题

11123

子子标题

hmm

引用内容：极化恒等式

嵌入内容：

证明调和级数 $\sum \limits _{i=1}^n \dfrac{1}{i}\le \ln n + 1$ ：令 $f(x) = x + \ln (1-x)$ ，求导有 $f'(x) = - \dfrac{x}{1-x}$ ，当 $x \in (0,1)$ 时 $f(x)$ 单调递减。 $f(\dfrac{1}{i}) = \dfrac{1}{i} + \ln \dfrac{i-1}{i} \le f(0) = 0 \iff \dfrac{1}{i} \le \ln \dfrac{i}{i-1}$ . 则 $\sum \limits _{i=1}^n \dfrac{1}{i} = 1 + \sum \limits _{i=2}^n \dfrac{1}{i} < 1 + \ln n$ ，证毕。且： $\sum \limits _{i=L}^R \dfrac{1}{i} \le \ln \dfrac{R}{L-1}$ .

INFO STYLE

ERROR STYLE

SUCCESS STYLE

WARNING STYLE

Title

Fold This

高考互助组构想

tesaasasdsaddasdsad

asdasdsaddasddasdasdsadasd

dsa

‍

Hello, Astro!

Sun, 29 Sep 2024 10:20:00 GMT

有趣吧，我的小博客终于又要死灰复燃了。这次选择了使用 Astro，一个日益流行的前端 meta framework.

虽然在博客这边的生态依然很不成熟，这是实实在在的。但是我会 TypeScript，对前端也有一些了解，所以手搓一点自定义也可以接受。

那么，再次出发吧！

a $a+b=c$ b b b

\begin{aligned} a+b=c\\ d+e=f \end{aligned}