参考文献:
- [BV11] Brakerski Z, Vaikuntanathan V. Fully homomorphic encryption from ring-LWE and security for key dependent messages[C]//Annual cryptology conference. Berlin, Heidelberg: Springer Berlin Heidelberg, 2011: 505-524.
- [BEHZ16] Bajard J C, Eynard J, Hasan M A, et al. A full RNS variant of FV like somewhat homomorphic encryption schemes[C]//International Conference on Selected Areas in Cryptography. Cham: Springer International Publishing, 2016: 423-442.
- [HPS19] Halevi S, Polyakov Y, Shoup V. An improved RNS variant of the BFV homomorphic encryption scheme[C]//Topics in Cryptology–CT-RSA 2019: The Cryptographers’ Track at the RSA Conference 2019, San Francisco, CA, USA, March 4–8, 2019, Proceedings. Springer International Publishing, 2019: 83-105.
- [HK20] Han K, Ki D. Better bootstrapping for approximate homomorphic encryption[C]//Cryptographers’ Track at the RSA Conference. Cham: Springer International Publishing, 2020: 364-390.
- [KLSS23] Kim, M., Lee, D., Seo, J., Song, Y. (2023). Accelerating HE Operations from Key Decomposition Technique. In: Handschuh, H., Lysyanskaya, A. (eds) Advances in Cryptology – CRYPTO 2023. CRYPTO 2023. Lecture Notes in Computer Science, vol 14084. Springer, Cham.
- Full-RNS BGV/BFV
- Full-RNS CKKS
文章目录
[KLSS23] 改进了 Full-RNS BGV/BFV/CKKS 中的 Key-Switch 过程,通过额外的数字分解,将线性同态运算中数据的规模大幅降低,从而不必对 RNS 表示中的每一个分量都执行 NTT/INTT,从而减少了 KS 的计算复杂性。
Gadget Decomposition and External Product
在各种 FHE 中,gadget toolkit 被广泛用于噪声的控制。
首先,我们定义 Gadget 分解:
这里的向量 g g g 一般有两种选择方式,
- [BV11] 提出的数字分解:选取 base B B B,定义 g = ( 1 , B , B 2 , ⋯ , B l − 1 ) g = (1,B,B^2,\cdots,B^{l-1}) g=(1,B,B2,⋯,Bl−1),其中 l = log B Q l = \log_B Q l=logBQ
- [BEHZ16] 提出的 RNS 分解:选取 primes Q = ∏ i = 0 l − 1 q i Q=\prod_{i=0}^{l-1} q_i Q=∏i=0l−1qi,定义 g = ( q ^ 0 q 0 ∗ , q ^ 1 q 1 ∗ , ⋯ , q ^ l − 1 q l − 1 ∗ ) g = (\hat q_0 q_0^*, \hat q_1 q_1^*, \cdots, \hat q_{l-1} q_{l-1}^*) g=(q^0q0∗,q^1q1∗,⋯,q^l−1ql−1∗),其中 q ^ i ∗ = Q / q i \hat q_i^* = Q/q_i q^i∗=Q/qi 以及 q i ∗ = [ q ^ i − 1 ] q i q_i^* = [\hat q_i^{-1}]_{q_i} qi∗=[q^i−1]qi
[KLSS23] 同时使用 [BV11] 的分解技术以及 [GHS12] 的提升技术,定义了所谓的 “外积” 运算(分解 + 内积),它是 KS 过程的基础运算。注意到 R Q ~ R_{\tilde Q} RQ~ 是一个 R R R-module,因此内积 ⟨ h ( a ) , u ⃗ ⟩ \langle h(a), \vec u\rangle ⟨h(a),u⟩ 是良定义的。
下面我们只考虑外积的快速实现,不再区分是使用了 BGV、BFV、CKKS 加密方案。
A New External Product Method
[KLSS23] 的设计思路为:
- 外积运算本身使用了某个 Gadget 向量 g = ( g 0 , g 1 , ⋯ , g d − 1 ) ∈ R Q d g=(g_0,g_1,\cdots,g_{d-1}) \in R_{Q}^d g=(g0,g1,⋯,gd−1)∈RQd 及其对应的 Gadget 分解函数 h : R Q → R d h: R_{Q} \to R^d h:RQ→Rd
- 给定某元素 a ∈ R Q a \in R_Q a∈RQ,把它分解为行矢 b ⃗ = h ( a ) = ( b 0 , ⋯ , b d − 1 ) ∈ R d \vec b=h(a)=(b_0,\cdots,b_{d-1}) \in R^d b=h(a)=(b0,⋯,bd−1)∈Rd
- 我们额外再使用一个 Gadget 向量 g ~ = ( g ~ 0 , g ~ 1 , ⋯ , g ~ d ~ − 1 ) ∈ R Q ~ d ~ \tilde g=(\tilde g_0,\tilde g_1,\cdots,\tilde g_{\tilde d-1}) \in R_{\tilde Q}^{\tilde d} g~=(g~0,g~1,⋯,g~d~−1)∈RQ~d~ 及其对应的 Gadget 分解函数 h ~ : R Q ~ → R d ~ \tilde h: R_{\tilde Q} \to R^{\tilde d} h~:RQ~→Rd~
- 给定某列矢 u ⃗ ∈ R Q ~ d \vec u \in R_{\tilde Q}^d u∈RQ~d,把它分解为矩阵 V = h ( u ⃗ ) = ( v ⃗ 0 , ⋯ , v ⃗ d ~ − 1 ) ∈ R d × d ~ V=h(\vec u)=(\vec v_0,\cdots,\vec v_{\tilde d-1}) \in R^{d \times \tilde d} V=h(u)=(v0,⋯,vd~−1)∈Rd×d~
现在,我们已知 a = b ⃗ ⋅ g ( m o d Q ) a = \vec b \cdot g \pmod{Q} a=b⋅g(modQ) 以及 u ⃗ = V ⋅ g ~ ( m o d Q ~ ) \vec u = V\cdot \tilde g \pmod{\tilde Q} u=V⋅g~(modQ~),因此外积运算可以写作:
注意这里的计算结果的模数不是
Q
Q
Q 而是
Q
~
=
P
Q
\tilde Q=PQ
Q~=PQ。假设函数
h
h
h 分解出的范数上界是
B
B
B,而函数
h
~
\tilde h
h~ 分解出的范数上界是
B
~
\tilde B
B~,那么系数
⟨
h
(
a
)
,
h
~
(
u
⃗
)
j
⟩
\langle h(a), \tilde h(\vec u)_j\rangle
⟨h(a),h~(u)j⟩ 的范数上界是(最坏的,能否改成平均的?):
∥
⟨
b
⃗
,
v
⃗
j
⟩
∥
∞
≤
d
N
⋅
∥
b
∥
∞
⋅
∥
v
⃗
j
∥
∞
≤
d
N
⋅
B
B
~
\| \langle \vec b, \vec v_j\rangle \|_\infty \le dN \cdot \|b\|_\infty \cdot \|\vec v_j\|_\infty \le dN \cdot B\tilde B
∥⟨b,vj⟩∥∞≤dN⋅∥b∥∞⋅∥vj∥∞≤dN⋅BB~
因此行矢
b
⃗
∈
R
d
\vec b \in R^d
b∈Rd 以及列矢
v
⃗
j
∈
R
d
\vec v_j \in R^d
vj∈Rd 可以嵌入到
R
B
′
d
R_{B'}^d
RB′d 中计算内积,只要满足
B
′
>
d
N
⋅
B
B
~
B' > dN\cdot B\tilde B
B′>dN⋅BB~ 即可。选取合适的
h
,
h
~
h,\tilde h
h,h~,使得
B
′
≪
Q
~
B' \ll \tilde Q
B′≪Q~,然后执行
R
B
′
R_{B'}
RB′ 上的 Double-CRT 运算,所需的 NTT/INTT 数量大幅减少。
因为这完全是算法上的改进,因此对噪声增长没有任何影响。
RNS-based Gadget Decomposition
最早由 [BEHZ16] 提出 RNS 分解,它是 RNS-friendly 的一种 Gadget 分解方法。他们直接使用 Q = q 0 ⋯ q l − 1 Q=q_0\cdots q_{l-1} Q=q0⋯ql−1 对应的 RNS 表示 [ a ] Q = ( [ a ] q 0 , ⋯ , [ a ] q l − 1 ) ∈ R l [a]_Q = ([a]_{q_0}, \cdots, [a]_{q_{l-1}}) \in R^{l} [a]Q=([a]q0,⋯,[a]ql−1)∈Rl 作为分解形式,但这导致 KSK 的规模扩张了 l l l 倍(分别加密 P s 2 ⋅ g i Ps^2 \cdot g_i Ps2⋅gi 或者 P ⋅ τ t ( s ) ⋅ g i P\cdot\tau_t(s) \cdot g_i P⋅τt(s)⋅gi),并且计算效率降低。
[HK20] 指出我们不必完全分解到各个素数,而是将它们分组为若干个数字。确切地说,
- 模数 Q Q Q 的 RNS base 是 B = { q 0 , ⋯ , q l − 1 } \mathcal B = \{q_0,\cdots,q_{l-1}\} B={q0,⋯,ql−1},指标集 I = [ l ] I = [l] I=[l]
- 指标集分解为 d d d 个子集的不交并 I = ∪ j I j I = \cup_j I_j I=∪jIj,对应的 RNS base 分别是 B j = { q k ∣ k ∈ I k } \mathcal B_j = \{q_k \mid k \in I_k\} Bj={qk∣k∈Ik},那么 D j = ∏ k ∈ I j q k D_j = \prod_{k \in I_j} q_k Dj=∏k∈Ijqk 是互素的 digits,满足 Q = ∏ j D j Q = \prod_j D_j Q=∏jDj,我们称 ∣ I j ∣ |I_j| ∣Ij∣ 是 D j D_j Dj 的长度
我们定义 Gadget 分解函数
h
:
R
Q
→
R
d
h: R_Q \to R^d
h:RQ→Rd,
h
:
a
↦
b
⃗
:
=
(
b
j
=
[
a
]
D
j
)
j
=
0
d
−
1
h: a \mapsto \vec b := \big(b_j=[a]_{D_j}\big)_{j=0}^{d-1}
h:a↦b:=(bj=[a]Dj)j=0d−1
简记
D
^
j
=
Q
/
D
j
\hat D_j = Q/D_j
D^j=Q/Dj 以及
D
j
∗
=
[
D
^
j
−
1
]
D
j
D_j^* = [\hat D_j^{-1}]_{D_j}
Dj∗=[D^j−1]Dj,这个分解函数对应的 Gadget 向量是:
g
⃗
:
=
(
g
j
=
D
^
j
D
j
∗
)
j
=
0
d
−
1
\vec g := \big( g_j=\hat D_jD_j^* \big)_{j=0}^{d-1}
g:=(gj=D^jDj∗)j=0d−1
容易验证
g
j
=
1
(
m
o
d
D
j
)
g_j=1 \pmod{D_j}
gj=1(modDj) 以及
g
j
=
0
(
m
o
d
D
j
′
)
,
∀
j
′
≠
j
g_j = 0 \pmod{D_{j'}}, \forall j' \neq j
gj=0(modDj′),∀j′=j,因此
g
⃗
\vec g
g 构成了一组 CRT 基底,使得
a
=
⟨
h
(
a
)
,
g
⃗
⟩
a = \langle h(a),\vec g\rangle
a=⟨h(a),g⟩。我们令
h
h
h 的范数上界为
B
=
1
2
max
0
≤
j
<
d
{
D
j
}
B = \frac{1}{2} \max_{0 \le j<d}\{D_j\}
B=21max0≤j<d{Dj}
在 RNS 下计算上述的 Gadget 分解是平凡的:给定元素 a ∈ R Q a \in R_Q a∈RQ 的 RNS 表示 [ a ] Q = ( [ a ] q i ) 0 ≤ i < l ∈ R Q l [a]_Q = ([a]_{q_i})_{0 \le i < l} \in R_Q^l [a]Q=([a]qi)0≤i<l∈RQl,那么把这个向量简单分组为 [ a ] Q = ( [ a ] D j ) 0 ≤ j < d [a]_Q = ([a]_{D_j})_{0 \le j < d} [a]Q=([a]Dj)0≤j<d 即可,其中的每一个 [ a ] D j = ( [ a ] q k ) k ∈ I j ∈ R ∣ I j ∣ [a]_{D_j} = ([a]_{q_k})_{k \in I_j} \in R^{|I_j|} [a]Dj=([a]qk)k∈Ij∈R∣Ij∣ 也都是 RNS 向量表示。
External Product over RNS
我们使用 [HK20] 的分解技术实现 External Product 中使用的两个 h , h ~ h,\tilde h h,h~ 分解函数,前者分解 Q Q Q 成为 D i , 0 ≤ i < d D_i, 0\le i <d Di,0≤i<d,后者分解 Q ~ \tilde Q Q~ 成为 D ~ j , 0 ≤ j < d ~ \tilde D_j, 0 \le j<\tilde d D~j,0≤j<d~。当计算内积 ⟨ b ⃗ , v ⃗ j ⟩ , 0 ≤ j < d ~ \langle \vec b, \vec v_j\rangle, 0\le j<\tilde d ⟨b,vj⟩,0≤j<d~ 的时候,其中 b ⃗ = h ( a ) ∈ R d \vec b = h(a) \in R^d b=h(a)∈Rd 以及 v ⃗ j = h ~ ( u ⃗ ) j ∈ R d \vec v_j = \tilde h(\vec u)_j \in R^d vj=h~(u)j∈Rd,其中的分量 b i = [ a ] D i , 0 ≤ i < d b_i = [a]_{D_i}, 0 \le i<d bi=[a]Di,0≤i<d 以及 v j i = [ v ⃗ j ] D ~ i v_{ji} = [\vec v_j]_{\tilde D_i} vji=[vj]D~i 都是短向量,我们将它们嵌入到 R B ′ d R_{B'}^d RB′d 中模拟 R d R^d Rd 运算。
这需要用到 [BEHZ16] 提出的 Fast Base Conversion 技术。为了消除 overflow 的影响,可以采用 [HPS19] 的浮点数算法。我们以
b
i
=
[
a
]
D
i
=
(
a
k
)
k
∈
R
∣
I
i
∣
b_i=[a]_{D_i}=(a_k)_k \in R^{|I_i|}
bi=[a]Di=(ak)k∈R∣Ii∣ 为例,定义
q
^
k
=
D
i
/
q
k
\hat q_k=D_i/q_k
q^k=Di/qk 以及
q
k
∗
=
[
q
^
k
−
1
]
q
k
q_k^*=[\hat q_k^{-1}]_{q_k}
qk∗=[q^k−1]qk,可以写出(根据 CRT 定理,并不真的去计算):
b
i
=
∑
k
∈
I
i
[
a
k
⋅
q
k
∗
]
q
k
⋅
q
^
k
−
D
i
z
i
∈
R
D
i
b_i = \sum_{k \in I_i} [a_k \cdot q_k^*]_{q_k} \cdot \hat q_k - D_iz_i \in R_{D_i}
bi=k∈Ii∑[ak⋅qk∗]qk⋅q^k−Dizi∈RDi
其中
z
i
z_i
zi 是使用浮点算术得到的,一般情况下 IEEE-754 double
就足够了,
z
i
=
⌊
∑
k
∈
I
i
[
a
k
⋅
q
k
∗
]
q
k
⋅
q
^
k
D
i
⌉
=
⌊
∑
k
∈
I
i
[
a
k
⋅
q
k
∗
]
q
k
q
k
⌉
z_i = \left\lfloor \frac{\sum_{k \in I_i} [a_k \cdot q_k^*]_{q_k} \cdot \hat q_k}{D_i} \right\rceil = \left\lfloor \sum_{k \in I_i} \frac{ [a_k \cdot q_k^*]_{q_k} }{q_k} \right\rceil
zi=⌊Di∑k∈Ii[ak⋅qk∗]qk⋅q^k⌉=⌊k∈Ii∑qk[ak⋅qk∗]qk⌉
假设
B
′
=
∏
q
′
B' = \prod q'
B′=∏q′,那么就有(直接根据
a
k
=
[
a
]
q
k
a_k=[a]_{q_k}
ak=[a]qk 计算):
[
b
i
]
q
′
=
∑
k
∈
I
i
[
a
k
⋅
q
k
∗
]
q
k
⋅
[
q
^
k
]
q
′
−
z
i
⋅
[
D
i
]
q
′
∈
R
q
′
[b_i]_{q'} = \sum_{k \in I_i} [a_k \cdot q_k^*]_{q_k} \cdot [\hat q_k]_{q'} - z_i \cdot [D_i]_{q'} \in R_{q'}
[bi]q′=k∈Ii∑[ak⋅qk∗]qk⋅[q^k]q′−zi⋅[Di]q′∈Rq′
其中的
[
q
^
k
]
q
′
[\hat q_k]_{q'}
[q^k]q′ 以及
[
D
i
]
q
′
[D_i]_{q'}
[Di]q′ 都是预计算的。这样就实现了
b
i
=
[
a
]
D
i
b_i=[a]_{D_i}
bi=[a]Di 到
[
b
i
]
B
′
[b_i]_{B'}
[bi]B′ 的转换,对于
v
j
i
=
[
v
⃗
j
]
D
~
i
v_{ji} = [\vec v_j]_{\tilde D_i}
vji=[vj]D~i 同理,于是我们可以在
R
B
′
d
R_{B'}^d
RB′d 中计算两者的内积。
最终,再次使用 Fast Base Conversion 把内积结果
r
j
=
⟨
b
⃗
,
v
⃗
j
⟩
∈
R
B
′
r_j = \langle \vec b, \vec v_j\rangle \in R_{B'}
rj=⟨b,vj⟩∈RB′(可以正确提升为
R
R
R 再取模)转换到
[
r
j
]
D
~
j
∈
R
D
~
j
[r_j]_{\tilde D_j} \in R_{\tilde D_j}
[rj]D~j∈RD~j(注意不是
D
i
∣
Q
D_i\mid Q
Di∣Q 而是
D
~
j
∣
Q
~
\tilde D_j \mid \tilde Q
D~j∣Q~)。此时有:
⟨
h
(
a
)
,
u
⟩
=
∑
i
=
0
d
−
1
b
i
⋅
u
i
=
∑
j
=
0
d
~
−
1
[
r
j
]
D
~
j
⋅
g
~
j
(
m
o
d
Q
~
)
\langle h(a),u\rangle = \sum_{i=0}^{d-1} b_i \cdot u_i = \sum_{j=0}^{\tilde d-1} [r_j]_{\tilde D_j} \cdot \tilde g_j \pmod{\tilde Q}
⟨h(a),u⟩=i=0∑d−1bi⋅ui=j=0∑d~−1[rj]D~j⋅g~j(modQ~)
由于
g
~
j
=
1
(
m
o
d
D
~
j
)
\tilde g_j = 1 \pmod{\tilde D_j}
g~j=1(modD~j) 以及
g
~
j
=
0
(
m
o
d
D
~
j
′
)
,
∀
j
′
≠
j
\tilde g_j = 0 \pmod{\tilde D_{j'}}, \forall j' \neq j
g~j=0(modD~j′),∀j′=j,因此简单地把这些
[
r
j
]
D
~
j
,
0
≤
j
<
d
~
[r_j]_{\tilde D_j}, 0\le j<\tilde d
[rj]D~j,0≤j<d~ 级联起来,就得到了内积
⟨
b
,
u
⟩
(
m
o
d
Q
~
)
\langle b,u\rangle \pmod{\tilde Q}
⟨b,u⟩(modQ~) 的 RNS 表示。最后的模切换
Q
~
→
Q
\tilde Q \to Q
Q~→Q,在 RNS 上也是容易的。
Previous Key-switching Method
[KLSS23] 测试发现,Full-RNS 中占主导开销的就是 NTT/INTT,
- 在同态乘法中,密钥切换的开销占比为 86 − 93 % 86 - 93\% 86−93%
- 在自同构中,密钥切换的开销占比为 90 − 95 % 90 - 95\% 90−95%
- 在密钥切换中,NTT/INTT 的开销占比为 47 − 73 % 47 - 73\% 47−73%
假设 Q = q 0 q 1 ⋯ q l − 1 Q = q_0q_1 \cdots q_{l-1} Q=q0q1⋯ql−1 以及 P = q l q l + 1 ⋯ q l ~ − 1 P = q_{l}q_{l+1}\cdots q_{\tilde l-1} P=qlql+1⋯ql~−1 分别是 ciphertext modulus 和 special modulus,这里 q i q_i qi 都是 word-size 素数。将模数 Q Q Q 分解为 d d d 个长度 r r r 的数字 D j D_j Dj, 使用它所对应的 RNS 分解函数 h h h。
- 先计算 h ( a ) ∈ R d h(a) \in R^d h(a)∈Rd,然后再把每个 b j = [ a ] D j b_j=[a]_{D_j} bj=[a]Dj 都扩展到模数 Q ~ \tilde Q Q~ 对应的 RNS 表示。KSK 以 Double-CRT 的形式给出,模数是 Q ~ \tilde Q Q~。
- 接着把这 d d d 个长度 l ~ \tilde l l~ 的多项式 [ b j ] Q ~ [b_j]_{\tilde Q} [bj]Q~ 都转换到 NTT Form,再和 KSK 做内积(线性解密)。
- 把计算出的两个密文分量转换回 Coeff Form,执行模切换。
如图所示:
计算复杂度:
- NTT/INTT 数量:内积之前需要 d l ~ d\tilde l dl~ 次 NTT,内积之后需要 2 l ~ 2\tilde l 2l~ 次 INTT,共计为 ( d + 2 ) l ~ (d+2)\tilde l (d+2)l~
- Hadamard product 数量:
- 当 r ≠ 1 r \neq 1 r=1 时,把各个 [ a ] D j [a]_{D_j} [a]Dj 扩展到 Q ~ \tilde Q Q~ 需要 d r ( l ~ − r ) ≤ l 2 dr(\tilde l-r) \le l^2 dr(l~−r)≤l2 次 Hadamard product(请看 [ b i ] q ′ [b_i]_{q'} [bi]q′ 计算公式),内积需要 2 d l ~ 2d\tilde l 2dl~ 次 Hadamard product,共计为 l 2 + 2 d l ~ l^2+2d\tilde l l2+2dl~
- 当 r = 1 r=1 r=1 时,把各个 [ a ] D j [a]_{D_j} [a]Dj 扩展到 Q ~ \tilde Q Q~ 就不再需要 Hadamard product,共计为 2 d l ~ 2d\tilde l 2dl~
New Key-switching Method
使用 [KLSS23] 提出的新外积算法,可以把 NTT/INTT 的开销降低 4-9 倍,使得密钥切换中的 NTT/INTT 开销占比降低到 25 − 27 % 25 - 27\% 25−27%
除了分解 Q Q Q 为 D i D_i Di 对应的函数 h h h,再使用分解 Q ~ = P Q \tilde Q=PQ Q~=PQ 为 D ~ j , 0 ≤ j < d ~ \tilde D_j, 0 \le j<\tilde d D~j,0≤j<d~ 对应的函数 h ~ \tilde h h~,假设 D ~ j \tilde D_j D~j 的长度都是 r ~ \tilde r r~。选取合适的 B ′ B' B′,它的长度为 r ′ r' r′。
- 先计算 h ( a ) ∈ R d h(a) \in R^d h(a)∈Rd,然后再把每个 b j = [ a ] D j b_j=[a]_{D_j} bj=[a]Dj 都扩展到模数 B ′ B' B′ 对应的 RNS 表示。KSK 已经被关于 h ~ \tilde h h~ 分解,并以对应的 Double-CRT 的形式给出,模数是 B ′ B' B′。
- 接着把这 d d d 个长度 r ′ r' r′ 的多项式 [ b j ] B ′ [b_j]_{B'} [bj]B′ 都转换到 NTT form,再和 KSK 做内积(线性解密),两个密文分量都各对应 d ~ \tilde d d~ 个内积。
- 把计算出的系数都转换回 Coeff Form(模数 B ′ B' B′),并各自转换到 D ~ j \tilde D_j D~j 模数,最后执行模切换。
如图所示:
计算复杂度:
- NTT/INTT 数量:内积之前需要 d r ′ dr' dr′ 次 NTT,内积之后需要 2 d ~ r ′ 2\tilde dr' 2d~r′ 次 INTT,共计为 ( d + 2 d ~ ) r ′ (d+2\tilde d)r' (d+2d~)r′
- Hadamard product 数量:
- 当 r ≠ 1 r \neq 1 r=1 时,把各个 [ a ] D j [a]_{D_j} [a]Dj 扩展到 B ′ B' B′ 需要 d r r ′ ≤ l r ′ drr' \le lr' drr′≤lr′ 次 Hadamard product(请看 [ b i ] q ′ [b_i]_{q'} [bi]q′ 计算公式),内积需要 2 d d ~ r ′ 2d\tilde dr' 2dd~r′ 次 Hadamard product,最后从 B ′ B' B′ 转换回 Q ~ \tilde Q Q~ 还需要 2 d ~ r ~ r ′ = 2 l ~ r ′ 2\tilde d\tilde rr'=2\tilde lr' 2d~r~r′=2l~r′ 次 Hadamard product,共计为 ( l + 2 d d ~ + 2 l ~ ) r ′ (l+2d\tilde d+2\tilde l)r' (l+2dd~+2l~)r′
- 当 r = 1 r=1 r=1 时,把各个 [ a ] D j [a]_{D_j} [a]Dj 扩展到 Q ~ \tilde Q Q~ 就不再需要 Hadamard product,共计为 ( 2 d d ~ + 2 l ~ ) r ′ (2d\tilde d+2\tilde l)r' (2dd~+2l~)r′
Complexity Comparison
汇总一下,[KLSS23] 所需的 NTT/INTT 数量大幅减低,而 Hadamard product 数量也有所降低。如果假设 r , r ~ , r ′ ∈ O ( 1 ) r,\tilde r,r' \in O(1) r,r~,r′∈O(1) 以及 d , d ~ ∈ O ( l ) d,\tilde d \in O(l) d,d~∈O(l),此时 l ~ = r ~ d ~ = O ( l ) \tilde l=\tilde r\tilde d=O(l) l~=r~d~=O(l),那么在渐进的意义下:
- 旧的 KS 需要 O ( l 2 ) O(l^2) O(l2) 次 NTT/INTT,新的 KS 只需要 O ( l ) O(l) O(l) 次 NTT/INTT
- 旧的和新的 KS 都需要 O ( l 2 ) O(l^2) O(l2) 次 Hadamard product
问题是实际中真的设置 r ∈ O ( 1 ) r \in O(1) r∈O(1) 和 d = O ( l ) d=O(l) d=O(l) 嘛?对于 Hybrid KS(噪声还被除以 P P P,不必分解的很细),通常是选取 d = 2 , 3 d=2,3 d=2,3 吧?那样的话,原始 KS 本身也是线性复杂度的 NTT/INTT,改进就没有这么明显了。
可以看出,随着 r r r 的增大(也就是 d d d 的减小),原始 KS 的表现越来越好,且 [KLSS23] 的改进幅度越来越小。此外 [KLSS23] 还声称新算法对于 l , r l,r l,r 的依赖相对较弱。
在他们选取的参数下,NTT 的占比大幅下降了: