Unbounded CKKS for Bits NTT with Composite Modulus

参考文献：

[CHKKS18] Cheon J H, Han K, Kim A, et al. Bootstrapping for approximate homomorphic encryption[C]//Advances in Cryptology–EUROCRYPT 2018: 37th Annual International Conference on the Theory and Applications of Cryptographic Techniques, Tel Aviv, Israel, April 29-May 3, 2018 Proceedings, Part I 37. Springer International Publishing, 2018: 360-384.
[AAB+20] Aharoni E, Adir A, Baruch M, et al. Helayers: A tile tensors framework for large neural networks on encrypted data[J]. arxiv preprint arxiv:2011.01805, 2020.
[CKK20] Cheon J H, Kim D, Kim D. Efficient homomorphic comparison methods with optimal complexity[C]//Advances in Cryptology–ASIACRYPT 2020: 26th International Conference on the Theory and Application of Cryptology and Information Security, Daejeon, South Korea, December 7–11, 2020, Proceedings, Part II 26. Springer International Publishing, 2020: 221-256.
[CHK+21] Chung C M M, Hwang V, Kannwischer M J, et al. NTT multiplication for NTT-unfriendly rings: New speed records for Saber and NTRU on Cortex-M4 and AVX2[J]. IACR Transactions on Cryptographic Hardware and Embedded Systems, 2021: 159-188.
[LLL+24] Li Z, Liu Y, Lu X, et al. Faster Bootstrapping via Modulus Raising and Composite NTT[J]. IACR Transactions on Cryptographic Hardware and Embedded Systems, 2024, 2024(1): 563-591.
[DMP+24] Drucker N, Moshkowich G, Pelleg T, et al. BLEACH: cleaning errors in discrete computations over CKKS[J]. Journal of Cryptology, 2024, 37(1): 3.
[BCK+24] Bae Y, Cheon J H, Kim J, et al. Bootstrapping Bits with CKKS[C]//Annual International Conference on the Theory and Applications of Cryptographic Techniques. Cham: Springer Nature Switzerland, 2024: 94-123.
近似的同态比较：简单多项式的迭代计算
Key Unrolling，Approximate Gadget Decomposition
常见函数的级数展开及推导
关于浮点数的原理，误差，以及你想知道的一切

文章目录

Clean-up
- Polynomial Approximation of Sign Function
- BLEACH strategy
- Bit decomposition
Tile Tensors
- Tiling
- Operators
CKKS for Bits
- Modulus Engineering for BTS
- BinBoot
- GateBoot
- Experiments
Composite NTT
- NTT with Composite Modulus
- Packing Bootstrapping

CKKS 方案使用的是复数 $\in \mathbb C^{N/2}$ （及其共轭）的定点数编码 $\Delta \cdot iDFT(m) \in \mathbb R_N[X]$ ，对应的解码是 $DFT(f)/\Delta \in \mathbb C^{N/2}$ ，密文的相位是 $f+\epsilon+e \in \mathbb Z_N[X]$ （不取模），其中 $\epsilon \in \mathbb T_N[X]$ 是舍入噪声， $\in \mathbb Z_N[X]$ 是加密噪声，后者的范数占主导。

由于 DFT 满足 scaled 2-norm isometry，具体地说：对于实系数函数 $\forall f \in \mathbb R_N[X]$ ，其频域是复向量，它的范数由典范内积 $\langle x, y\rangle = x^\dagger y$ 所诱导。由于共轭是实数轴对称的， $\overline{f(x)} = f(\bar x), \forall x \in \mathbb C$ ，因此有
$\begin{aligned} f(\zeta^k)\overline{f(\zeta^k)} &= \left(\sum_i f_i\zeta^{ik}\right)\left(\sum_j f_j\bar\zeta^{jk}\right)\\ &= \sum_{i,j} f_if_j\zeta^{(i-j)k}\\ &= \sum_i f_i^2 + \sum_{i \neq j} f_if_j\zeta^{(i-j)k} \end{aligned}$
那么频域的范数平方就是 $\sum_k(\sum_i f_i^2 + \sum_{i \neq j} f_if_j\zeta^{(i-j)k}) = \sum_k\sum_if_i^2 = N \cdot \|f\|_2^2$ ，其中 $\sum_k \zeta^k=0$ 被消除。由于频域的一半是另一半的共轭，因此只考虑有效的明文槽，其范数就是 $\sqrt{N/2} \cdot \|f\|_2$ 。对于带噪明文多项式 $f+\epsilon+e \in \mathbb Z_N[X]$ ，解码获得带噪的复数 $DFT(\epsilon+e)/\Delta \in \mathbb C^{N/2}$ ，噪声的范数是 $\sqrt{N/2} \cdot \|\epsilon+e\|_2/\Delta$ ，因此缩放因子 $\Delta$ 应当比 $m$ 预期的精度增大至少 $\sqrt{N/2}$ 倍。不过 $DFT(\epsilon+e)/\Delta \in \mathbb C^{N/2}$ 仅随着 $\epsilon+e \in \mathbb R_N[X]$ 线性增长， 每当 coeff-side 损失 $1$ 比特精度，那么 slot-side 也恰好损失 $1$ 比特精度。

假设整体相位规模是 $2^{p+t}$ ，噪声规模是 $2^t$ ，那么精度就是 $p$ 比特。CKKS 本质上并不是一个 FHE（在无界计算的意义下），

同态加法： $(f_1+e_1)+(f_2+e_2) = (f_1+f_2) + (e_1+e_2) \in \mathbb Z_N[X]$ ，整体相位增大为 $2^{p+t+1}$ ，噪声增大为 $2^{t+1}$ ，精度保持为 $p$ 比特
同态乘法： $(f_1+e_1) \cdot (f_2+e_2) = f_1f_2 + (f_1e_2+f_2e_1+e_1e_2) \in \mathbb Z_N[X]$ ，整体相位增大为 $2^{2(p+t)}$ ，噪声增大为 $2^{p+2t+1}$ ，精度缩小为 $p - 1$ 比特，需要重缩放 $2^{p+t}$ 因子
同态数乘： $(f_1+e_1) \cdot f_2 = f_1f_2 + f_2e_1 \in \mathbb Z_N[X]$ ，整体相位增大为 $2^{2(p+t)}$ ，噪声增大为 $2^{p+2t}$ ，精度保持为 $p$ 比特，需要重缩放 $2^{p+t}$ 因子

由于编码方式的不同，CKKS 和 BGV/BFV 的不同之处：BGV/BFV 的同态乘法不会导致精度损失；BGV/BFV 的同态数乘基本不消耗模数。它们的自举目标也不同：BGV/BFV 通过 HomDec 来消除噪声，CKKS 仅通过 EvalMod 来增大模数（还引入更多的噪声）。随着 CKKS 电路深度的增加，最终消息会完全淹没在运算噪声和自举噪声内，无法执行任意深度的运算。

其实，计算机中的浮点数也有这个问题。对于高次多项式的计算结果并不可信，例如：

>>> np.e
2.718281828459045

>>> (1+1e-10)**1e10
2.7182820532347876
>>> (1+1e-15)**1e15
3.035035206549262

>>> (1+2**(-53))**(2**53)
1.0
>>> (1+1/(2**53-1))**(2**53-1)
7.389056098930647

当然对于常规的运算，浮点数基本都没什么问题，即使是很深的电路。因为这只是编码误差，而非运算错误。但在 CKKS 中就严重的多了，运算本身还会继续引入额外的噪声，仅仅几十层乘法就把有效精度消耗殆尽。

Clean-up

[DMP+24] 假设 CKKS 编码的消息取自某个先验的离散集合，然后使用阶跃函数将带噪的相位映射到最近的离散点（效果就是减小了噪声），从而可以支持无界深度的电路。

Polynomial Approximation of Sign Function

[CKK20] 把符号函数的关键形状提取出来，然后使用低次多项式来近似。
$\left\{\begin{aligned} 1, && x>0\\ 0, && x=0\\ -1, && x<0 \end{aligned}\right.$
它具有三个重要性质：

原点对称
穿过 $(- 1, - 1), (0, 0), (1, 1)$ 三个点
在 $x=\pm1$ 快速收敛

因此我们找一个近似的多项式，使得它分别满足：

$f (- x) = - f (x)$
$f (- 1) = - 1, f (0) = f (0), f (1) = f (1)$
$\frac{\partial f}{\partial x} = c(1-x)^n(1+x^n)$

[CKK20] 根据这三条性质，定义了一族多项式 ${f_n\}$ ，其中 $f_1(x) = -\frac{1}{2}x^3 + \frac{3}{2}x$ 。为了更加逼近符号函数，他们将 $f_n$ 迭代复合 $d$ 次。

在这里插入图片描述

由于上述的多项式近似对于输入/输出的范围和误差都有要求，因此可以把这个程序记为：
$Sign_{\alpha, \beta}(x) = \left\{\begin{aligned} 1, && -1 \le x <-\alpha\\ -1, && \alpha < x \le 1\\ \text{undefined}, && \text{otherwise} \end{aligned}\right.$
满足：
$|Sign_{\alpha,\beta}(x) - Sign(x)| < \beta,\,\, \forall x \in [-1,-\alpha) \cup (\alpha,1]$
根据 [CKK20]，这个电路的 size 和 depth 分别是
$S(\alpha,\beta) = D(\alpha,\beta) = O(\log(1/\alpha)) + O(\log\log(1/\beta))$
精度越高（ $\alpha$ 控制输入精度， $\beta$ 控制输出精度），那么电路的大小和深度都会增大。

[DMP+24] 把符号函数 $f_1(x) = -0.5x^3+1.5x, \forall x \in [-1,1]$ 转换为阶跃函数 $h_1(x) = -2x^3+3x^2, \forall x \in [0,1]$ （左右/上下平移 + 缩放），两者是完全等价的， $S(\alpha,\beta),D(\alpha,\beta)$ 都不变。

BLEACH strategy

在原始 CKKS 方案下，任意的二元对称布尔门都可以使用二次函数来模拟。

AND Gate： $\cdot y$
OR Gate: $\cdot y$
XOR Gate： $x-y)^2$

对于带噪的 $x'=x+e_x$ 和 $y'=y+e_y$ ，其中 $\in \{0,1\}$ 以及 $e_x,e_y < B < 0.25$ ，那么就有
$∣ G a t e (x^{'}, y^{'}) - G a t e (x, y) ∣ < 5 e$
换句话说，只要输入的误差不太大，那么 CKKS 模拟出的布尔门的输出的误差就不会增长的太多。由于花费了一层乘法，因此还降低了 $1$ -bit 精度（注意区分噪声规模和明文精度，它们是两个无关的东西）。定义布尔值的 $k$ -bit 精度近似 $B_k := \{0,1\} \pm 2^{-k}$ ，那么经过一个布尔运算后的结果落在 $B_{k-1}$ 内，我们需要把 $B_{k-1}$ 提升回 $B_k$

现在，我们考虑 $h_1$ 对于错误的纠正能力：
$\begin{aligned} h_1(0+e) = 0-2e^3 + 3e^2\\ h_1(1+e) = 1-2e^3 - 3e^2\\ \end{aligned}$
计算一下：

>>> e = lambda x: 2*x**3 + 3*x**2
>>> e(0.3)
0.324
>>> e(0.2)
0.136
>>> e(0.1)
0.032
>>> e(0.01)
0.000302

只要噪声小于 $0.2$ ，那么噪声就可以降低。如果噪声小于 $0.01$ ，那么噪声就以大约二次方的速度降低。

[DMP+24] 在每一次 Gate 之后都立即执行 $h_1$ 来清理噪声，称之为 “漂白” 技术，记为 $Cleanup_{(2^{-(k+1)},2^{-k})}(\cdot)$ ，它把 $B_k$ 清理为 $B_{k+1}$ （降低了噪声，提升了精度）。太保守了：噪声被二次方降低，因此大约是把 $B_k$ 清理为了 $B_{2k-2}$ （还有个因子 $3$ 的影响）在这里插入图片描述

另外，由于 CKKS 自举仅仅提升模数，并不清理噪声，可以把这个 clean-up 结合在一起，从而同时实现模数提升和噪声降低。

Bit decomposition

对于更一般的 $N$ -bit 整数集合 $\in \mathbb N \cap [0,2^{N+1})$ ，[DMP+24] 依次提取和清理 MSB，获得各个比特的低噪声模拟，然后再组装回 $N$ -bit 整数的低噪声模拟。

提取 MSB 的算法：

在这里插入图片描述

数字分解的算法：[DMP+24] 的噪声分析写的很乱

在这里插入图片描述

清理整数的算法：

在这里插入图片描述

Tile Tensors

[DMP+24] 使用 Tile Tensors 实现了 Conway’s Game of Life，作为 BLEACH 的性能测试。[AAB+20] 为了简化 API，提出了介于 FHE 和 CNN 之间的一个 “瓷砖张量” 框架。

在这里插入图片描述

Tiling

对于任意的张量 $A[n_1,n_2,\cdots,n_k]$ （一个高维数组），[AAB+20] 把它分成形状 $[t_1,t_2,\cdots,t_k]$ 的张量（必要的填充），称之为 “瓷砖”，每个瓷砖被打包加密在单个密文中。这些瓷砖组成了一个张量 $E[e_1,e_2,\cdots,e_k]$ ，其中 $e_i = \lceil n_i/t_i \rceil$ ，被称为 external tensor。这个过程被记为：
$T_A = pack\left(A, \left[\frac{n_1}{t_1}, \cdots, \frac{n_k}{t_k} \right]\right)$
对应的逆过程记为 $A = unpack(T_A)$

对于张量 $M [5, 6]$ ，可以有不同的打包方式：

在这里插入图片描述

Operators

对于两个张量 $A, B$ ，在运算之前需要保证它们的形状是兼容的：

在这里插入图片描述

首先把两个张量广播到 mutual expanded shape，然后再做 element-wise 加法/乘法。利用这些基本运算，可以搭建出矩阵乘、二维卷积等高级运算。细节请看 [AAB+20]，略。

CKKS for Bits

[DMP+24] 使用原始的 CKKS 方案，自举算法也是以黑盒方式使用的。[BCK+24] 考虑了布尔值明文的特点，对 CKKS 自举给出了专门的优化。

Modulus Engineering for BTS

在 [CHKKS18] 中的 EvalMod 计算的是 $q_0 I \mapsto x$ 函数，其中 $I$ 是有界整数， $x$ 是相对于 $q$ 很小的实数。先使用 Sine 函数来近似模拟这个函数，然后再用 Poly 去模拟 Sine 函数（对于某些小区间的切比雪夫插值）

方便起见，现在只考虑 CKKS 的实数自举（OpenFHE 似乎也仅支持实数的槽打包）。一般来说，不同阶段的噪声增长是不同的，并且自举过程中的噪声增长会更大一些。

为了提高自举精度，在自举之前乘以一个倍率 $c$ ，在自举之后再除以 $c$ 回到原始的缩放因子，这可以把自举噪声相对缩小 $c$ 倍。
- 这里的 $c$ 被选取为二的幂次（例如 $c=2^4$ ），除法可直接使用重缩放，而非定点数编码（避免同态数乘的模数消耗）
- 不过模数 $q_0$ 也要相应的增大，以维持 $x$ 和 $q_0$ 之间的 Gap，保证 Sine 模拟的精度
对于 RNS-CKKS 变体，那些 computation levels 模数选取为 $\Delta$ 规模（乘法之后的重缩放），而那些 bootstrapping levels 模数则被细粒度地选取为各自的明文的规模。
- StC 步骤的相位是 $x$ ，规模大约是 $\Delta$
- CtS 和 EvalMod 步骤的相位是 $x+q_0I \approx q_0I$ ，这远比 $\Delta$ 更大

自举流程是：

在这里插入图片描述

BinBoot

[BCK+24] 仅关注 $\in \{0,1\}$ 的场景，因此可以设置 $\Delta = q_0/2$ ，那么 $\Delta(b+e) +q_0I$ 可以缩放为 $(b + e) /2 + I$ ，现在的目标是计算函数 $\mapsto b$ 。由于 $\in \{0,1\}$ 以及 $\ll 1$ ，函数 $g$ 定义在区间 $(\mathbb Z\pm e) \cup (\mathbb Z+0.5\pm e)$ ，并且 $\mathbb Z\pm e \mapsto 0$ 以及 $\mathbb Z+0.5\pm e \mapsto 1$

这个函数很特殊： $1$ -周期函数，定义域只在 $\cup (I+0.5)$ 附近，值域是二值的。[BCK+24] 使用如下的函数来模拟它：
$\frac{1}{2}(1-\cos(2\pi \cdot x))$
由于 Cosine 在原点的级数是 $\cos(x) = 1-\frac{x^2}{2!}+\frac{x^4}{4!}-\cdots$ ，容易验证：
$f((b+e)/2+I) = b + O(e^2)$
也就是说：函数 $f$ 不仅模拟了函数 $g$ ，而且还平方级别的降低了噪声。

在这里插入图片描述

算法很简单，只需修改 EvalMod 步骤：

在这里插入图片描述

更加精细的噪声分析是：

在这里插入图片描述

其中的 $B_2,B_3,B_{appr}$ 都可以通过调整参数，来降低到远比 $\|\epsilon\|_\infty$ 小的程度。

在原始的 CKKS 自举中，总是要求 $\Delta \ll q_0$ ，以保证 Sine 模拟的精度。一般地，设置 $\Delta \approx q_0 \cdot 2^{-10}$ ，这导致 CtS 和 EvalMod 的模数消耗比其他同态计算过程高了至少 $10$ -bit，由于 CtS 和 EvalMod 需要十层左右的同态乘法，这导致了约 100-bit 的额外模数消耗。而在 BinBoot 中设置了 $\Delta = q_0/2$ ，因此 computation levels 和 bootstrapping levels 可以设置为相似的大小，从而自举后的容量更多。

另外，由于只处理布尔值，因此明文精度也可以设置的很小（保证足以把布尔值和噪声相互分离即可）。假设 BinBoot 之后的容量是 5 层乘法，那么只需要设置明文精度为 10-bit（此时只需要 $\Delta \approx \sqrt{N/2} \cdot 2^{10}$ ），经过 5 层乘法丢失了 5-bit 精度，再利用 BinBoot 把精度拉回 10-bit，如此反复，可以计算无界深度的布尔电路。

GateBoot

类似于 FHEW/TFHE 的思路，[BCK+24] 留出稍大一些的明文空间，在自举之前首先把两个密文做线性运算，然后再执行一次程序自举做非线性运算，从而在自举的同时计算一个布尔门。由于不需要把系数编码在多项式指数上，这里可以设置明文模数是 $3$ 而非 $4$ ，对应的缩放因子是 $\Delta = q_0/3$

现在，自举过程需要计算的函数是： $(b_1+b_2+e)/3 + I \mapsto Gate(b_1,b_2)$ ，其中 $b_1,b_2 \in \{0,1\}$ ， $\ll 1$ ， $\in \mathbb Z$ ，对应的三角函数是：

在这里插入图片描述

但是要注意：三角函数只有局部极值的位置，才具有把噪声平方级缩小的功能。在上述的图像中，容易发现都恰好只有一个明文取值是落在了局部极值上。

自举算法：

在这里插入图片描述

噪声分析：

在这里插入图片描述

为了控制噪声，有三种方法：

对于随机明文，以 $1/3$ 的概率会发生噪声清理，精度加倍；但是不通用。
在合理的位置上，额外使用 [DMP+24] 的 “漂白” 技术，手动地清理噪声，计算 $h_1$ 消耗 $2$ 层模数；[BCK+24] 采用了这个方法。
寻找具有三个局部极值点的其他函数；但是计算复杂度很高。

Experiments

由于 CKKS 自举过程消耗的模数基本不随维度变化，因此维度越高则均摊成本越低。[BCK+24] 给了两组参数，一组用于低延迟的自举，一组用于高吞吐的自举。

选取 $N=2^{14}$ ，BinBoot 和 GateBoot 的计算延迟分别是 $1.36$ 秒和 $1.39$ 秒。

在这里插入图片描述

选取 $N=2^{16}$ ，BinBoot 和 GateBoot 的计算延迟分别是 $23.1$ 秒和 $23.3$ 秒。

在这里插入图片描述

自举之后剩余 $28$ 层乘法深度，

如果使用 BinBoot，每经过 4 层 Gate 再用 $h_1$ 清理噪声，[1-4]+Cleanup，[7-10]+Cleanup，[13-16]+Cleanup，[19-22]+Cleanup，[25-28]+BinBoot，有效的 Gate 层数是 $20$ ，均摊成本 $23.1s \div 2^{16} \div 20 = 17.6 \mu s$
如果使用 GateBoot，每经过 3 层 Gate 再用 $h_1$ 清理噪声，[1-3]+Cleanup，[6-8]+Cleanup，[11-13]+Cleanup，[16-18]+Cleanup，[21-23]+Cleanup，[26-28]+GateBoot，有效层数是 $16 + 1$ ，均摊成本 $23.3\text{ s} \div 2^{16} \div 17 = 20.9 \mu\text{s}$

[CGGI16] 的速度是 $10.5\text{ ms}$ ，因此在均摊成本上加速了 $596$ 倍。

Composite NTT

[BCK+24] 的实际效率提升远没有达到理论预期，他们说这是因为 RNS-CKKS 的模数链选的很小，导致 NTT 数量太多。可以把两个 30 比特左右的素数组合成 60 比特的较大模数（但保持在机器字内），从而减少 NTT 数量。[BCK+24] 没有描述计算细节，[LLL+24] 中给出了 FHEW-like 的一种 RNS 变体，前者没有引用后者。

NTT with Composite Modulus

FHEW/TFHE 使用的模数 $q$ 通常是二的幂次，因此对于二的幂次分圆环，不存在 NTT 所需的本原单位根。利用 [CHK+21] 的技术，把 $\in R_q$ 提升到 $R$ ，它们乘积的系数范围不超过 $Nq^2/4$ ，因此可以选取一些 NTT-friendly 小素数 $Q=\prod_i q_i \ge Nq^2/4$ ，从而快速计算 $R_q$ 上的乘法。

由于 $Q$ 是合数，因此 $\mathbb Z_Q^*$ 不一定是循环群（仅当 $Q=4,p^k,2p^k$ 时才是），所以如何构造 $2 N$ -th 本原根是个问题。可以递归地构造：假设 $Q_1,Q_2$ 下存在 $\zeta_{Q_1},\zeta_{Q_2}$ 都是 $2 N$ -th 本原单位根，那么它们的 CRT 合成
$\begin{aligned} \zeta_Q &= \zeta_{Q_1}Q_2\cdot[Q_2^{-1}]_{Q_1} + \zeta_{Q_2}Q_1\cdot[Q_1^{-1}]_{Q_2}\\ &= \zeta_{Q_1} + \zeta_{Q_2} \cdot [(\zeta_{Q_2}-\zeta_{Q_1}) \cdot Q_2^{-1}]_{Q_1} \end{aligned}$
就是 $Q=Q_1Q_2$ 下的 $2 N$ -th 本原单位根。这可以利用 CRT 来证明。

以二叉树的方式，构造 $\prod_i q_i$ 下的本原单位根：

在这里插入图片描述

使用 $\zeta_Q$ 执行 $\mathbb Z_Q$ 下的 NTT，这很容易实现。可以将两个 32-bit 素数合并为 64-bit 合数，从而一次性完成两个 NTT 运算（但是 64-bit 乘法需要 128-bit 寄存器，这不一定被计算机支持，可能还要用 Schoolbook 算法来模拟）

Packing Bootstrapping

外积运算本质上就是 $R$ -模 $R_Q$ 上的数乘。为了控制噪声，采取了数字分解以及模数提升。忽略后者，我们只看 $R$ -模 $R_Q$ 上的数乘，假如多个 $R_{Q_1},\cdots,R_{Q_l}$ 采用了互素的模数 $Q_1,\cdots,Q_l$ ，那么根据 CRT 定理，设置 $\prod_i Q_i$ ，
$R_{Q} \cong R_{Q_1} \times \cdots \times R_{Q_l}$
因此 $l$ 个数乘运算 $r_1 \cdot M_1, \cdots, r_l \cdot M_l$ ，其中 $r_i \in R$ 以及 $M_i \in R_{Q_i}$ ，可以写成如下的数乘：
$iCRT\Big(CRT_Q([r_1]_{Q_1},\cdots,[r_l]_{Q_l}) \cdot CRT_Q(M_1,\cdots,M_l)\Big)$
[LLL+24] 利用这个关系，将两个 FHEW/TFHE 自举（模数 $P_iQ_i$ 都在 $32$ -bit 以内？这合理么？）打包起来，加速了 1.7 倍。打包处理的 Key Unrolling 优化的 CMux-based Blind Rotation 算法如下：