TFHE拓展：Programmable Bootstrapping

Improved Programmable Bootstrapping with Larger Precision and Efficient Arithmetic Circuits for TFHE（对TFHE优化的可编程同态刷新的方案，拥有高精度和高效率）

摘要

TFHE的Bootstrapping（同态刷新），除了减少噪音外，还可以运算一个单变量函数（用查找表LUT的方式）。然而，它需要预先知道明文的最高位，从而导致损失了一个位的空间来存储信息。此外，在许多使用情况下，它的计算开销很大。

在本文中，我们提出了一个解决方案来克服上述限制，我们称之为可编程的无填充同态刷新（Programmable Bootstrapping Without Padding WoP-PBS）。这种方法依赖于两个构建模块。第一个是BFV乘法，我们将其纳入TFHE。有充分的噪声分析来证明，使用TFHE的参数可以正确的进行BFV乘法。第二个构件是本文介绍的TFHE同态刷新的一般化。它提供了灵活性，可以在同态刷新过程中选择加密明文中的任何块位。当工作的精度足够小时，它还能同时评估许多LUT。所有这些改进在一些应用中特别有帮助，如布尔电路的评估（在每个被评估的门中不再需要自举），更普遍的是，即使有大的整数，也能有效评估算术电路。这些结果也改善了TFHE电路的同态刷新。此外，我们还表明，现在可以使用比TFHE的参数小得多的参数来同态刷新大精度的整数。

引言

TFHE是一种支持高效同态刷新的(R)LWE-based FHE方案。最初是对FHEW方案的一种优化，后来也加入了别的一些技术来提高效率。TFHE的高效性来自于他们选取的参数是非常小的，支持使用CPU内带的64位整形来表示出来，因此可以达到非常好的效率。

TFHE

TFHE加密形式：

TFHE使用将加密的消息放在最高位，对于消息$m\in \mathbb{Z}$，加噪后的明文看起来就是$\Delta \cdot m+e\mathrm{mod}q$。其中$m$的精度位大小为$p={\log }_2(\frac{q}{\Delta })$。可以通过下图来形式化地理解一下：

在这里$p=7$，最高位(蓝色部分)为消息，最低位(红色部分)为噪声。

$\mathbf{PBS}$

可编程同态刷新（Programmable Bootstrapping $\mathbf{PBS}$）：

TFHE的同态刷新过程很高效，但其实也同时是可编程的，也就是说，可以在降低密文的噪声的同时，对明文运算一个单变量的函数$f$。类似$\mathsf{LWE}(m+e)\stackrel{\mathbf{PBS}}{\to }\mathsf{LWE}(f(m+e)+e^{\prime })$，因为使用LUT进行刷新，这里的$f$可以是任意的函数（不局限于多项式）。具体的方法是将$f$的LUT编码为一个多项式，然后通过同态地旋转查找表来得到$f(m+e)$，通常在$\mathbf{PBS}$中，需要将LUT中的临近的几位设置为相同的系数，使得$f(m+e)=f(m)$。

一次同态刷新运算多个函数：

文章¹中有提到一种在一个密文上同时运算多个函数的技术， { f i } i \{f_i\}_i {fi​}i​，每个函数都被编码为一个多项式$P_i$，可以生成一个共享多项式$Q$使得$P_i=Q\cdot P_i^{\prime }$，并计算$\mathsf{C}{\mathsf{T}}_{\mathsf{out}}\leftarrow {\mathbf{PBS}}^{\ast }(\mathsf{c}{\mathsf{t}}_{\mathsf{in}},\mathsf{BSK},Q)$，然后可以用$\mathsf{C}{\mathsf{T}}_{\mathsf{out}}$去乘$P_i^{\prime }$来得到运算不同函数的结果。

这种方法的一个缺点在于输出的密文的噪声与$P_i^{\prime }$有关。

$\mathbf{PBS}$的缺陷：

1. 总的来说，要刷新某个密文，要使得它的最高位为0，除非函数$f$具有自反性质（所谓的自反性质指$f(m)=-f(m+q/2)$，要避免自反性就要求$m<q/2$，即最高位为0）。
2. 对于超过6位精度的密文来说，就无法高效地进行刷新操作了。每次能刷新的精度与$N$有关，要想要增加精度就要扩大$N$，而扩大$N$会非常影响效率。
3. $\mathbf{PBS}$过程对于多线程并不友好，因为它使用了一个累加器一遍遍地加。
4. 对于两个$\mathsf{LWE}$密文没有一个非常原生的方法来做乘法，有两种手段来最乘法：（1）使用$\mathbf{PBS}$来运算$f:x\mapsto \frac{x^2}{4}$，可以调用两次这样的$\mathbf{PBS}$来运算$x\cdot y=\frac{(x+y{)}^2}{4}-\frac{(x-y{)}^2}{4}$；（2）调用一次$\mathbf{PBS}$来将$\mathsf{GLWE}$密文变为$\mathsf{GGSW}$密文，然后执行一次$\mathsf{GGSW}\odot \mathsf{GLWE}\to \mathsf{GLWE}$外积运算来得到乘积的密文。因为两种方法都要使用$\mathbf{PBS}$，因此都受到条件1，2的限制。
5. 因为1和2的限制存在，没有一个比较好的方法，将一个密文消息同态地分片。
6. $\mathbf{PBS}$每次只可以运行一个函数$f$，采用¹中的方法，可以一次执行多个函数，但输出的噪声会与函数有关。
7. TFHE可以有效地执行同态布尔电路，然而，这种方法需要在每个二进制电路中都进行一次$\mathbf{PBS}$，那么运算就会很慢。而且TFHE没有提供支持比1比特大的整数的算数电路运算。
8. TFHE电路的同态刷新需要$\ell$次$\mathbf{PBS}$，以及很多次$\mathsf{KeySwitch}$，就会非常的慢。

贡献

这篇文章解决了上述的TFHE的限制。

首先，他们扩展了TFHE的$\mathbf{PBS}$，现在可以不引入额外噪声的情况下一次执行多个函数了。这种方法适用于明文非常小的情况。这种方法解决了限制6和8。

其次，他们分析了BFV类型的LWE乘法+重现性化的噪声增长，找到了适合TFHE的参数来运算BFV类型的乘法+重线性化，而不是通过$\mathbf{PBS}$来做乘法。这就解决了限制4。

基于这种乘法，他们定义了一种新的$\mathbf{PBS}$方案，这种$\mathbf{PBS}$不需要消息的最高位为0，解决了限制1，并且这种新的$\mathbf{PBS}$方案可以由多个子$\mathbf{PBS}$并行运算得到，支持多线程操作，解决了限制3。不同于CHIMERA以及PEGASUS这样的方案，这篇文章在TFHE中加入了BFV类型的乘法，因此就可以全程保留在TFHE的状态下，而不需要去转换。

由新的$\mathbf{PBS}$方案可以构造一个同态的$\mathsf{decompose}$（分块）方案，解决了限制5，而且也解除了每个布尔门都需要$\mathbf{PBS}$的限制7。

由上述的$\mathbf{PBS}$方法和$\mathsf{homomorphic}\mathsf{decompose}$方法，可以运算超过6比特的数。解决了限制2。

背景知识

这里主要介绍几个文章中的符号，首先${\mathfrak{R}}_q={\mathbb{Z}}_q[X]/(X^N+1)$多项式环大家都比较熟悉了。

$\mathsf{GLWE}$

然后这篇文章将$\mathsf{LWE},\mathsf{RLWE}$融合成了一个$\mathsf{GLWE}$表示，具体来说为：
$$\mathsf{CT}=(A_1,\cdots ,A_k,B=\sum _{i=1}^k{A}_i\cdot S_i+\lfloor M\cdot \Delta {\rceil }_q+E)={\mathsf{GLWE}}_{\mathbf{S}}(M\cdot \Delta )\in {\mathfrak{R}}_q^{k+1}$$
其中$\mathbf{S}=(S_1,\cdots ,S_k)\in {\mathfrak{R}}_q^k$要么是一个{0,1}，要么是{-1,0,1}中均匀分布的密钥。
对于$\mathsf{GLWE}$密文来说，当$N=1$的时候这就是一个$\mathsf{LWE}$密文，当$N>1,k=1$的时候这就是一个$\mathsf{RLWE}$密文。

$\mathsf{GLev}$

其实$\mathsf{GLev}$密文就是对$\mathsf{GLWE}$密文的分解，形式如同：
$$\overline{\mathsf{CT}}=({\mathsf{CT}}_1,\cdots ,{\mathsf{CT}}_{\ell })={\mathsf{GLev}}_{\mathbf{S}}^{\mathfrak{B},\ell }\in {\mathfrak{R}}_q^{\ell \times (k+1)}$$
其中${\mathsf{CT}}_i=\mathsf{GLWE}(M\cdot \frac{q}{{\mathfrak{B}}^i})$，是对于$M$的基为$\mathfrak{B}$的分解。

再定义一个分解算法。对于一个基$\mathfrak{B}\in {\mathbb{N}}^{\ast }$，$x\in {\mathbb{Z}}_q$：
$${\mathsf{dec}}^{(\mathfrak{B},\ell )}(x)=(x_1,\cdots ,x_{\ell })\in {\mathbb{Z}}_q^{\ell }$$

满足
$$⟨{\mathsf{dec}}^{(\mathfrak{B},\ell )}(x),(\frac{q}{{\mathfrak{B}}^1},\cdots ,\frac{q}{{\mathfrak{B}}^{\ell }})⟩=\lfloor x\cdot \frac{{\mathfrak{B}}^{\ell }}{q}\rceil \cdot \frac{q}{{\mathfrak{B}}^{\ell }}\in {\mathbb{Z}}_q$$
可以类似地定义一个对整数多项式的分解$X\in {\mathfrak{R}}_q$：
$${\mathsf{dec}}^{(\mathfrak{B},\ell )}(X)=(X_1,\cdots ,X_{\ell })\in {\mathfrak{R}}_q^{\ell }$$
$$⟨{\mathsf{dec}}^{(\mathfrak{B},\ell )}(X),(\frac{q}{{\mathfrak{B}}^1},\cdots ,\frac{q}{{\mathfrak{B}}^{\ell }})⟩=\lfloor X\cdot \frac{{\mathfrak{B}}^{\ell }}{q}\rceil \cdot \frac{q}{{\mathfrak{B}}^{\ell }}\in {\mathfrak{R}}_q$$

$\mathsf{GGSW}$

$\mathsf{GGSW}$其实就是多个$\mathsf{GLev}$密文结合，令$\mathbf{S}=(S_1,\cdots ,S_k)\in {\mathfrak{R}}_q^k$，则$\mathsf{GGSW}$密文为：
$$\overline{\overline{\mathsf{CT}}}=({\overline{\mathsf{CT}}}_1,\cdots ,{\overline{\mathsf{CT}}}_{k+1})={\mathsf{GGSW}}_{\mathbf{S}}^{(\mathfrak{B},\ell )}(M)\in {\mathfrak{R}}_q^{(k+1)\times \ell \times (k+1)}$$
其中${\overline{\mathsf{CT}}}_i={\mathsf{GLev}}_{\mathbf{S}}^{(\mathfrak{B},\ell )}(-S_i\cdot M)。$
当$N=1$时，这就是个$\mathsf{GSW}$密文，当$N>1,k=1$时，这是一个$\mathsf{RGSW}$密文。

$\mathsf{KeySwitching}$

KeySwitching算是全同态加密当中最重要的一个组件了，没有这个好多事情都做不了。KeySwitching会需要一个 KSK,看一下这篇文章中的三种定义：
K S K = { C T ‾ i = G L e v S ′ B , ℓ ( s i ) 1 ≤ i ≤ n } {\sf KSK}=\{\overline{\sf CT}_i={\sf GLev}_{\bf S'}^{\mathfrak{B},\ell}(s_i)_{1 \le i \le n} \} KSK={CTi​=GLevS′B,ℓ​(si​)1≤i≤n​}。$\mathbf{s}=(s_1,\cdots ,s_n)\in {\mathbb{Z}}_q^n$是输入的LWE密钥，${\mathbf{S}}^{\prime }=(S_1^{\prime },\cdots ,S_k^{\prime })\in {\mathfrak{R}}_q^k$是输出的GLWE密钥。定义一个LWE-to-GLWE转换：

• C T o u t ← P r i v a t e K S ( { c t i } i ∈ { 1 , … , p } , K S K ) \mathsf{CT}_{\mathsf{out }} \leftarrow \mathbf{PrivateKS}\left(\left\{\mathsf{ ct }_{i}\right\}_{i \in\{1, \ldots, p\}}, \mathsf{KSK}\right) CTout​←PrivateKS({cti​}i∈{1,…,p}​,KSK)，这里的KeySwitch和之前的都不太一样，在转换密钥的同时还是运算一个函数$f$，具体的输入为 { c t i = L W E s ( m 1 ) } i ∈ { 1 , . . . , p } \{{\sf ct}_i = {\sf LWE}_{\bf s}(m_1)\}_{i\in\{1,...,p\}} {cti​=LWEs​(m1​)}i∈{1,...,p}​，输出为${\mathsf{CT}}_{\mathsf{out}}={\mathsf{GLWE}}_{{\mathbf{S}}^{\prime }}(f(m_1,\cdots m_p))$。
• C T o u t ← P u b l i c K S ( { c t i } i ∈ { 1 , … , p } , K S K , f ) \mathsf{CT}_{\mathsf {out }} \leftarrow \mathbf{PublicKS}\left(\left\{\mathsf{ct}_{i}\right\}_{i \in\{1, \ldots, p\}}, \mathsf{KSK}, f\right) CTout​←PublicKS({cti​}i∈{1,…,p}​,KSK,f)，Public和Private的区别在于Public中的$f$是公开的。Private中时私有的。
• C T o u t ← P a c k i n g K S ( { c t j } j = 1 p , { i j } j = 1 p , K S K ) \mathsf{CT}_{\mathsf {out }} \leftarrow \mathbf{PackingKS}\left(\left\{\mathsf{ct}_{j}\right\}_{j=1}^{p},\left\{i_{j}\right\}_{j=1}^{p}, \mathsf{KSK}\right) CTout​←PackingKS({ctj​}j=1p​,{ij​}j=1p​,KSK)，PackingKeySwitch的区别在于它运算的$f$是给定的，为 f ( { m j } j = 1 p → ∑ j = 1 p m j ⋅ X i j ) f(\{m_j\}_{j=1}^{p}\to \sum_{j=1}^{p}m_j\cdot X^{i_j}) f({mj​}j=1p​→∑j=1p​mj​⋅Xij​)。
  这三个算法来自TFHE2017 Asiacrypt那篇，具体可以参考那个。

$\mathbf{PBS}$算法思路

$\mathbf{PBS}$分为三步：
第一步：$\mathsf{Modulus}\mathsf{Switching}$，将一个在${\mathbb{Z}}_q^{n+1}$上的$\mathsf{LWE}(m)$密文缩减到${\mathbb{Z}}_{2N}^{n+1}$上，这里可以参考FHEW的Bootstrapping过程，只支持模$2N$大小的密文。
第二步：使用$\mathsf{BlindRotation}$（其实和FHEW里面的Refresh算法差不多，可以参考一下）得到一个$\mathsf{GLWE}(f(m))\in {\mathfrak{R}}_q$密文。
第三步：通过一个$\mathsf{extract}$算法将$\mathsf{GLWE}$密文提取为$\mathsf{LWE}$密文。

对PBS感兴趣可以看一下这篇 TOTA: Fully Homomorphic Encryption with Smaller Parameters and Stronger Security

TFHE Circuit Bootstrapping

在TFHE2017的文章里面有讲如何做Circuit Bootstrapping，可以在降低噪声的同时将LWE密文转换文GGSW密文。
但是一次Circuit Bootstrapping需要使用$\ell$次的$\mathbf{PBS}$以及$(k+1)\ell$次的$\mathbf{PrivateKS}$，是通过像搭积木一样把GLWE密文搭成一个GGSW密文，感觉效率会很慢。

构造模块

$\mathsf{LWE}$乘法

首先定义一个$\mathbf{GLWEMult}$，由乘法和一次relinearize组成。

单个$\mathsf{LWE}$乘法：
有了$\mathsf{GLWE}$的乘法之后，就可以通过将$\mathsf{LWE}$先转换为$\mathsf{GLWE}$，然后调用$\mathbf{GLWEMult}$做乘法，最后通过$\mathbf{SampleExtract}$将$\mathsf{LWE}$从$\mathsf{GLWE}$中提取出来。

这里刚开始不太明白为什么要用两次KeySwitch以及一次GLWE乘法+Relin和一次Extract来做LWE之间的乘法，难道会比LWE原生的乘法要快吗？我觉得应该是为了能够计算后面的Packed LWE乘法。但这种PackedLWEMult应该也要满足$\alpha (\alpha +1)<kN$的限制。

多个$\mathsf{LWE}$乘法：
可以通过简单的修改算法2，让其可以单次计算多个$\mathsf{LWE}$密文的乘积。
令输入为 { c t i ( 1 ) } = { L W E S ( m i ( 1 ) ⋅ Δ 1 ) } ( 0 ≤ i < α ) , { c t i ( 2 ) } = { L W E S ( m i ( 2 ) ⋅ Δ 2 ) } ( 0 ≤ i < α ) \{{\sf ct}_i^{(1)}\}=\{{\sf LWE}_{\bf S}(m_i^{(1)}\cdot \varDelta_1)\}_{}(0\le i < \alpha),\{{\sf ct}_i^{(2)}\}=\{{\sf LWE}_{\bf S}(m_i^{(2)}\cdot \varDelta_2)\}_{}(0\le i < \alpha) {cti(1)​}={LWES​(mi(1)​⋅Δ1​)}​(0≤i<α),{cti(2)​}={LWES​(mi(2)​⋅Δ2​)}​(0≤i<α)。
只需要修改算法2的2，3步，将2的Index从 { 0 } \{0\} {0}改为 I 1 = { 0 , 1 , 2 , ⋯   , α − 1 } 。 \mathcal{I}_1=\{0,1,2,\cdots,\alpha-1\}。 I1​={0,1,2,⋯,α−1}。，将3的Index从 { 0 } \{0\} {0}改为 I 2 = { 0 , α , 2 α , ⋯   , ( α − 1 ) α } \mathcal{I}_2=\{0,\alpha,2\alpha,\cdots,(\alpha-1)\alpha\} I2​={0,α,2α,⋯,(α−1)α}。可以算一下这样最后GLWE密文中的第$i\cdot (\alpha +1)$项就是$m_i^{(1)}\cdot m_i^{(2)}\cdot {\Delta }_{\mathsf{out}}$。

多个$\mathsf{LWE}$乘累加：

只要简单的修改一下上面的index，改为 I 1 = { 0 , 1 , 2 , ⋯   , α − 1 } \mathcal{I}_1=\{0,1,2,\cdots,\alpha-1\} I1​={0,1,2,⋯,α−1}， I 2 = { α − 1 , α − 2 , α − 3 , ⋯   , 0 } \mathcal{I}_2=\{\alpha-1,\alpha-2,\alpha-3,\cdots,0\} I2​={α−1,α−2,α−3,⋯,0}，那么结果的$\mathsf{GLWE}$中的第$\alpha -1$项就${\sum }_{0\le i<\alpha }(m_i^{(1)}{m}_i^{(2)}\cdot {\Delta }_{\mathsf{out}})$。

文中还有一个做PackedSquare的，和PackedMult同样思路，就不写了。

一般化的$\mathbf{PBS}$

在TFHE（以及FHEW）中，他们的$\mathbf{PBS}$都是只刷出一个MSB（为了做Bootstrapping），而其实$\mathbf{PBS}$可以刷新一段消息中的任何位置，而且一次$\mathbf{PBS}$可以同时对这一段位置执行多个函数。为了形式化地表达这种能力，这篇文章引入了两个额外的参数$\varkappa$和$\vartheta$。其中$\varkappa$表示在$\mathbf{PBS}$刷新的那段消息前面的没被刷新的消息个数，$\vartheta$表示可以批量执行$2^{\vartheta }$个函数。

这张图可以理解一下一般化的$\mathbf{PBS}$以及上述两个参数，将一个密文中包含的phase展开为二进制$(\Delta M+e)$，其中$M$为原始消息，很显然，消息部分由于乘了$\Delta$，所以在高位，而噪声在低位，只要噪声没有达到蓝色部分-1的位置，即$|e|<\Delta /2$，就可以正确解密。
对于$\mathbf{PBS}$来说，他的有效空间是模$2N$的，所以图中只有绿色部分的消息可以进入$\mathbf{PBS}$，而由于刷出来的消息是$f(m+e)$，因此要使得$f(m+e)=f(m)$这个性质满足，也就是不能刷$2N$这么大的数，有噪声存在，可以看到图中每次只能刷$5$比特。而刷出来的密文后面本应该有6位的噪声（应该Output中后面六位是红的），但这里为了实现批量运算$2^{\vartheta }$个函数的功能，手动将后面$\vartheta$位设为$0$。

在介绍$\mathbf{GenPBS}$前要先说一下为什么一般化的$\mathbf{PBS}$函数会没办法一起刷最高位。对于编码为$2N$上的多项式$f:{\mathbb{Z}}_{2N}\to \mathbb{Z}$的函数来说，输入为$(0,1,...,2N-1)$，做$\mathbf{PBS}$时需要将这个函数打包为一个多项式$P=f(0)-f(N-1)X-\cdots -f(1)X^{(N-1)}\in R_q$。而我们的$R_q$是模$X^N+1$的，所以对于$f(i)$来说，我们计算$P\cdot X^i$，这个多项式的常数项为$f(i)$，但考虑到他只有模$X^N+1$，而$f$的定义域在$2N$上。所以会满足一个自反的性质：$X^N=-1$，即$f(x+N)=-f(x)$。因此$x>N$的时候，得到的是$-f(x-N)$，即有效位只有$\log N-1$。
可以看下面这张图，最后能刷的只有$m^{\prime }$，得到的结果是$(-1{)}^{\beta }\cdot m^{\prime }$。

那么来看一下本文的$\mathbf{GenPBS}$流程。

很标准的过程，modulusSwitch+BlindRotate（Accumulation）+Extract。值得注意的是这里的modulusSwitch是把最后的$2^{\vartheta }$位给空出来了，为了之前说的批量执行$2^{\vartheta }$个函数。

注意到这里的$\mathbf{PBS}$刷新出来的结果并非$f(m)$，而是$(-1{)}^{\beta }\cdot f(m^{\prime })$。

我们先假设$\vartheta =0$，其实就有效位来说，其实只有$d$比特$(m^{\prime })$。而非$d+1$比特$(m)$。他所有运算的函数都要满足$f(x+N)=-f(x)$的自反性性质。

进阶的$\mathbf{PBS}$

现在的目的是把前面的一位$\beta$所带来的自反性去掉。来看一下这篇文章是如何做的。作者管具有这种性质的$\mathbf{PBS}$叫做PBS with out Padding $\mathbf{Wop}\cdot \mathbf{PBS}$。

第一种方法：

分别使用两次$\mathbf{PBS}$刷新出$(-1{)}^{\beta }\cdot f(m^{\prime })$以及$(-1{)}^{\beta }$，再将两者相乘就可以得到$f(m^{\prime })$的结果了。$\mathbf{PBS}$可以用来得到$(-1{)}^{\beta }$，就直接令$f(x)=1(0\le x<N),-1(N\le x<2N)$。用图片表达一下就如下所示：
其实他的这样做之后的有效位还是d位，只是避免了翻转。
看一下算法怎么写的：

需要用两次$\mathbf{PBS}$分别刷出${\mathsf{ct}}_{\mathsf{f}}=\mathsf{LWE}((-1{)}^{\beta }\cdot m^{\prime }\cdot {\Delta }_{\mathsf{out}})$。以及$\mathsf{c}{\mathsf{t}}_{\mathsf{sign}}=\mathsf{LWE}((-1{)}^{\beta })$。然后要做一次$\mathsf{LWE}$的乘法。感觉来说优点在于两个$\mathbf{PBS}$可以并行计算，缺点是也是只能刷$d$比特，而且用乘法的噪声会比较大。

第二种方法

第二种方法是弄两个函数，分别对应$\beta =0$和$\beta =1$的情况，然后用过乘法来做选择，劣势在于需要用到3个$\mathbf{PBS}$，这样做的好处在于可以刷新$d+1$个比特。
具体的方案如下：

多输出的$\mathbf{PBS}$

在编码多项式的时候，原本对于$f(m^{\prime })$我们的LUT是如下的：
$$f(0),f(0)X,f(0)X^2,f(0)X^3,...,f(2^d-1)X^{N-3},f(2^d-1)X^{N-2},f(2^d-1)X^{N-1}$$
这样子做的话在查询常数项的时候会得到$f(m^{\prime }+e)=f(m^{\prime })$。因为相邻几位的LUT是相同的，所以噪声不影响查询的结果。

那如果我们令噪声的最后几位（举例为1位）固定为0。
将LUT编码为
$$f_0(0),f_1(0)X,f_0(1)X^2,f_1(1)X^3,...,f_0(2^{d-1}-1)X^{N-2},f_1(2^{d-1}-1)X^{N-1}$$
那么查询最后结果的常数项为$f_0(x)$，1项为$f_1(x)$，也就可以通过多次的extract将多输出的结果提取出来。
但这样做法会缩小函数的有效位。如图所示：

算法如下：

值得注意的是上面两个$\mathbf{Wop}\cdot \mathbf{PBS}$也可以采用$\mathbf{PBSmanyLUT}$来代替$\mathbf{GenPBS}$来运算多个函数。

应用

固定点数

在应用里提到了固定精度算法，一个精度为p的数，密文表示为${\mathsf{ct}}_i=\mathsf{LWE}(m_i\cdot \frac{q}{2^p})$。用整数$m_i\in [0,2^p)$来表示一个精度为p的小数。

那对于一个固定点数的exact算法，就是每次做完加法和乘法之后（精度变为2p），把最低位p个数拿出来减掉，就重新回到了p位。

但这样做也有限制，因为一次刷新要把整个精度位p刷出来，所以能支持的精度位比较小。

要扩大精度位这篇文章也提出了方法，就是从最低位开始，每次刷p中的一部分，然后减去这一部分，重复上述步骤，直到刷到需要的精度为止。

快速Circuit Bootstrapping

Circuit Bootstrapping是在[CGGI17]中提出的，是将一个$\mathsf{RLWE}(\mu )$刷为$\mathsf{RGSW}(\mu )$，是通过执行$\ell$次Bootstrapping得到$\ell$个$\mathsf{RLWE}(\mu \frac{q}{{\mathfrak{B}}^j}{)}_{1\le j\le \ell }$密文，然后将$\ell$个$\mathsf{RLWE}$组合成一个$\mathsf{RGSW}$。

在这篇文章里，可以用$\mathbf{PBSmanyLUT}$同时刷出$\ell$个$\mathsf{RLWE}$，那就有了$\ell$倍的加速。

同态Decomp

除此之外，使用$\mathbf{WoP}-\mathbf{POS}$还可以在密文上进行Decomp算法。这个很好理解。

总结

这篇文章主要的贡献就在于解决$\mathbf{PBS}$的自反性吧。以及提出了一些可能的应用。

---

1. New techniques for multi-value input homomorphic evaluation and applications. ↩︎ ↩︎