META-BTS Bootstrapping Precision Beyond the Limit

META-BTS: Bootstrapping Precision Beyond the Limit

Abstract

Bootstrapping 是HE中必不可少的步骤，它通过恢复密文模数来实现可以无限次同态操作的FHE。然而Bootstrapping是HE中最消耗时间和内存的操作。且随着Bootstrapping精度的增加，大量的计算资源也被需要。特别地，先前所设计的所有Bootstrapping操作，其精度都受限于Rescaling的精度。

本文提出了一种新的Bootstrapping算法用于CKKS，该算法需要重复使用先前已知的Bootstrapping算法，所以称其为"Meta-BTS"。通过重复两次原始Bootstrapping，可以获得一个新的精度翻倍的Bootstrapping。当密文尺寸足够大，该算法可以被归纳为$k-fold$ Bootstrapping操作，其中$k>1$。

Keywords： FHE, CKKS, Approximate Bootstrapping, High Precision, Small parameters.

1 Introduction

HE指的是一类允许在加密数据上进行计算的加密方案。CKKS由于其天然以实数和复数向量作为明文空间，因此它成为目前最显著的HE方案。

为了支持复杂的应用程序，HE应该有更快的同态操作以及能够评估巨大深度的电路。然而由于同态操作的前进，密文模数会降低，直到模数足够小而不能维持进一步的操作。为了解决这个问题，提出了重加密密文的操作，即Bootstrapping，它可以刷新密文从而让模数得到恢复，以支持更多的同态操作。

在CKKS中对密文进行Bootstrapping操作实际上是同态地评估一个必不可少的模约减函数。CKKS本身仅支持同态加法和同态乘法，但是可以通过这些操作近似组合得到模约减函数的近似评估，但是很明显这会消耗大量的模量和计算资源，这也是制约CKKS的瓶颈。

此外，在HE的实际使用中，有许多情况都需要高精度的Bootstrapping。因为密文在每次同态操作和Bootstrapping操作中都会损失一定的精度。

为了解决该问题，本文提出了一个新颖的Bootstrapping算法，称为"Meta-BTS"。

1.1 Over of Our Algorithm

CKKS Bootstrapping可以理解为解密电路的同态评估以重加密密文。在每次的Bootstrapping操作中，都会给密文添加Bootstrapping误差，原因是模约减函数是通过评估近似多项式实现的。这里简单给出 "Meta-BTS"算法的主要idea。

(1)使用Bootstraped Ciphertext减去Original Ciphertext来提取Bootstrapping error。

(2)对Bootstrapping error 进行一次Bootstrap，得到Bootstraped error。

(3)使用Bootstraped Ciphertext 减去Bootstraped error。

通过重复该步骤，可以在一定程度上从Bootstraped Ciphertext中移除Bootstrapping error，从而获得更高精度的自举密文。

Techniques

如图1所示，本文描述了如何使用n-bit精度的Bootstrapping算法$BT{S}^{(1)}$实现新的2n-bit精度的bootstrapping算法$BT{S}^{(2)}$。

图1 High-level Overview of the Meta-BTS algorithm

在定义bootstrapping和它的精度之前，我们首先定义一下CKSK的密文为:$ct(m,q)\in R_q^2$表示模q下对m加密得到的密文。

现在我们定义bootstrapping的精度。通过对密文$ct(2^{r}m,q)$应用bootstrapping操作，我们可以获得一个新的密文$c{t}_{BTS}(2^{r}m+2^{-n}e,Q_{rem})$，$Q_{rem}$是bootstrapping后密文模数，$||e|{|}_{\infty }\le 1$。此时，我们定义这个Bootstrapping的精度为"r+n"。

2-fold Bootstrapping 是Meta-BTS中最简单的情况，包含两次Bootstrapping操作:Bootstrapping the Ciphertext 和Bootstrapping the error。

Bootstrapping of a Ciphertext

给定一个密文$c{t}_I=ct(2^n\cdot m,2^n\cdot q)$，其中$||m|{|}_{\infty }\le 1$，然后通过$2^n$重缩放该密文，然后得到新的密文$c{t}_1=ct(m,q)$​。

然后对密文$c{t}_1$执行n-bit 精度的$BT{S}^{(1)}$，获得新的密文$c{t}_2=ct(m+2^{-n}\cdot e_1,Q_{rem})$，其中$||e_1|{|}_{\infty }\le 1$。然后给$c{t}_2$乘以$2^n$，获得新的密文$c{t}_3=ct(2^n\cdot m+e_1,Q_{rem})$。

然后计算Bootstrapping error，$c{t}_{error}=[c{t}_3{]}_q-[c{t}_I{]}_q=ct(e_1,q)$。现在我们获得了密文的自举误差 $e_1$。

Bootstrapping error

现在，对密文$c{t}_{error}$执行n-bit精度的$BT{S}^{(1)}$，获得新的密文$c{t}_4=ct(e_1+2^{-n}\cdot e_2,Q_{rem})$，其中$||e_2|{|}_{\infty }\le 1$。

最后，我们计算$c{t}_o=c{t}_3-c{t}_4=ct(2^n\cdot m-2^{-n}\cdot e_2,Q_{rem})$，其中$||e_2|{|}_{\infty }\le 1$。因此我们使用n-bit 精度的$BT{S}^{(1)}$得到了2n-bit精度的$BT{S}^{(2)}$。

此外，可以看到"Meta-BTS"可以很容易的扩展为迭代两次以上的BTS。

1.2 Our Contributions

本文提出了"Meta-BTS"算法，该算法可以通过迭代低精度的Bootstrapping算法获得更高精度的Bootstrapping算法。也就是说，给定FHE参数，该算法可能构建出一个精度超过现有参数限制的Bootstrapping算法。

给定一个n-bit精度的$BT{S}^{(1)}$，以及一个范围在$[-1,1]$中的输入，则我们只需要迭代k次就可以获得一个kn-bit精度的$BT{S}^{(k)}$。从这里可以看到，"Meta-BTS"不需要改变FHE参数就可以得到更高精度的Bootstrapping算法。

本文所提算法将自举算法视为黑盒，也就是说该算法适用于所有的CKKS自举算法，可以使用现有的自举算法来构建更高精度的自举算法。

1.3 Related Works

2 Background

2.1 Notation

2.2 The CKKS scheme

2.3 Bootstrapping of the CKKS scheme

针对CKKS的Bootstrapping的研究已经足够广泛，尽管它们在细节方面不同，但是所有的CKKS自举程序都包含四个步骤: StC, ModRaise, Cts, EvalMod。

---

Slot to Coefficient(StC). 在CKKS中，标准嵌入可以将复数向量编码为一个多项式。同态操作执行在slot-wise，而改变密文的模数大小，仅仅能应用于密文多项式的系数中。因此，为了模增加，所以需要执行同态线性变换，将slot中的值移动到系数上。

Modulus raising(ModRaise).ModRaise 增加密文模数到更大的模数以恢复密文的级别。设$ct(m,Q_l)=(b=-as+m(X)+e,a)mod{Q}_l$是一个密文，其中$m(X)=Ecd(m,\Delta )$。仅仅通过改变该密文的模数，则可以得到新的密文$ct(m^{\prime },Q_L)$，其中$Q_l<Q_L$。且有$m^{\prime }=Dcd(m(X)+Q_{l}I(X),\Delta )$，其中$I(X)\in \mathbb{Z}[X]/(X^N+1)$。

Coefficient to Slot (CtS).为了计算模约减函数，需要执行一个同态线性变换从而将系数上的值移动到solt中。然后密文中的每个solt中的值分别为$m_i+Q_l{I}_i$，其中$m_i+Q_l{I}_i$是多项式$m(X)+Q_{l}I(X)$的第$i$个系数。

Approximate Evaluation of the Modular Reduction(EvalMod).在这一步需要执行模约减函数的近似评估。模约减函数不能被加法和减法精确的表达，但是它可以通过多项式来近似。正是因为这种近似，引入了Bootstrapping误差，该误差远大于同态操作期间由Rescaling操作引入的误差。已经有各种各样的研究来减小这种近似所带来的误差。

Definition 2.1 (BTS) : Bootstrapping算法是一种允许重加密密文并使得同态操作可以持续进行的算法。Bootstrapping简称为BTS，如下所示：

• $BTS(ct(m,q),btk)\to c{t}_{BTS}=ct(m^{\prime },Q_{rem})$:给定Bootstrapping计算公钥$btk$和一个密文$ct(m,q)$，其中消息$||m|{|}_{\infty }\le 2^r$，对于某些r。然后Bootstrapping算法返回一个密文$c{t}_{BTS}(m^{\prime },Q_{rem})$，其中$Q_{rem}>q$是Bootstrapping算法之后得到的密文模数。

其中$||m|{|}_{\infty }$的上界限$2^r$被称为BTS的输入界限，当输入界限为1时，称此时的BTS是标准的。

Definition 2.2($PER{F}_{BTS}$):给定一个bootstrapping算法BTS，$PER{F}_{BTS}$是一种测量BTS性能的方法：
$$PER{F}_{BTS}=(Precision,RemainModulus,Time)$$

• $PER{F}_{BTS}.Presion\to r+n$:
• $PER{F}_{BTS}.RemainModulus\to Q_{rem}/q$:
• $PER{F}_{BTS}.Time\to t$: 返回BTS的运行时间。

由于Bootstrapping是由同态操作组成的，故在自举后的密文中添加了一个误差。通过定义2.1和2.2，自举后的密文包含一个自举后的消息$m^{\prime }=m+m+2^{-2}e$，其中$m$是输入密文中的消息，$||m|{|}_{\infty }\le 2^r$，$||e|{|}_{\infty }\le 1$。

3 The Meta-BTS Algorithm

在本节，我们提出"Meta-BTS"，一种迭代自举算法，以获得高精度的bootstrapping算法。这里我们结合不同的Bootstrapping算法来描述一个2-fold Bootstrapping算法。由于Meta-BTS将使用的Bootstrapping算法视为黑盒，故它也可以使用到未来的新的Bootstrapping算法。

3.1 Difficulties in improving the performance of bootstrapping

在CKKS的自举算法中，需要对加密数据执行模约减函数。由于CKKS仅支持同态加和同态乘操作，故需要使用多项式来近似评估模约减函数。在自举过程中，自举误差是由多项式近似的同态运算以及多次带误差的rescaling引起的。

为了获得高精度的自举，可以通过增加缩放因子$\Delta$或者增加近似多项式的幂次来减小自举误差。由于高精度的自举算法消耗大量的密文模数，所以增加自举精度会显著降低密文模数，并导致HE参数增大。

3.2 Algorithm description

本小节中提出了一个新的算法，对自举引入的误差再进行一次自举从而得到高精度的bootstrapping。此外，本文还提出了本文方法的归纳，即重复两次以上的自举算法。在使用RNS-CKKS时，每次rescaling操作$2^n$意味着我们通过要给接近$2^n$的模数rescaling密文。

3.2.1 2-fold Bootstrapping.

本文提出一个算法，使用n-bit 精度的Bootstrapping $BT{S}^{(1)}$来构建一个2n-bit精度的Bootstrapping $BT{S}^{(2)}$。

我们以$PER{F}_{BT{S}^{(1)}}=(n,Q_{rem},t)$的标准Bootstrapping算法$BT{S}^{(1)}$开始。换句话说，$BT{S}^{(1)}$将密文$ct(m,q)$转变为$ct(m+2^{-n}e,Q_{rem})$，其中$||m|{|}_{\infty }\le 1$，$||e|{|}_{\infty }\le 1$。

$BT{S}^{(2)}$如下：

(1)给定输入密文$c{t}_I=ct(2^n\cdot m,2^n\cdot q)$，其中$||m|{|}_{\infty }\le 1$。使用$2^n$来Rescale $c{t}_I$来约减消息大小，使其适用于$BT{S}^{(1)}$​。

此时Rescale后，得到新密文$c{t}_1=ct(m+e_{rs},q)$。在这里，我们假设rescale 误差$e_{rs}$小于$BT{S}^{(1)}$的误差，所以满足$||e_{rs}|{|}_{\infty }\le 2^{-n}$。

(2)然后应用$BT{S}^{(1)}$到$c{t}_1$，得到新密文$c{t}_2=ct(m+e_{rs}+2^{-n}{e}_1,Q_{rem})$，其中$||e_1|{|}_{\infty }$。

(3)提取误差，给密文$c{t}_2$乘以$2^n$，得到新密文$c{t}_3=2^n\ast c{t}_2=ct(2^{n}m+2^n{e}_{rs}+e_1,Q_{rem})$​。

(4)为了在密文$c{t}_I$和$c{t}_3$之间进行计算，我们需要对密文$c{t}_3$进行降模。获得新的密文$c{t}_4=[c{t}_3{]}_{2^{n}q}=ct(2^{n}m+2^n{e}_{rs}+e_1,2^{n}q)$。

(5)然后计算$c{t}_4-c{t}_1$，获得新密文$c{t}_5=c{t}_4-c{t}_I=ct(2^n{e}_{rs}+e_1,2^{n}q)$。这里，我们获得的密文$c{t}_5$是rescale误差和bootstrapping误差和 $2^n{e}_{rs}+e_1$的加密。由于$||2^n{e}_{rs}+e_1|{|}_{\infty }\le 1$​。

(6)然后应用$BT{S}^{(1)}$到密文$c{t}_5$，得到新密文$c{t}_6=ct(2^n{e}_{rs}+e_1+2^{-n}{e}_2,Q_{rem})$。

(7)最后，计算$c{t}_3-c{t}_6$,得到新密文$c{t}_o=ct(2^{n}m-2^{-n}{e}_2,Q_{rem})$​。

(8)得到$BT{S}^{(2)}$的输出为$c{t}_o$。

上述所有步骤如下图2所示：

图2 Meta-BTS构建流程

图3 Meta-BTS示意图

---

Theorem 3.1(2-fold Bootstrapping Algorithm). Given a standard bootstrapping algorithm $BT{S}^{(1)}$ with performance
$$PER{F}_{BT{S}^{(1)}}=(n,Q_{rem}/q,t)$$
there is a bootstrapping algorithm $BT{S}^{(2)}$ whose performance is
$$PER{F}_{BT{S}^{(2)}}=(2n,Q_{rem}/(2^{n}q),2t)$$
if
$$Q_{rem}/(2^{n}q)\ge 1$$

---

3.3.3 k-fold bootstrapping.

本文提出了一个算法，通过使用n-bit精度的$BT{S}^{(1)}$来构建一个kn-bit精度的$BT{S}^{(k)}$，其中k是正整数。

设$BT{S}^{(1)}$是一个标准bootstrapping算法，其性能为$(n,Q_{rem}/q,t)$。假设$BT{S}^{(k)}$对于正整数k满足以下条件：

(1) Input : $ct(2^{(k-1)n}\cdot m,2^{(k-1)n}\cdot q)$。

(2) Output : $ct(2^{(k-1)n}m+2^{-n}{e}_k,Q_{rem})$，其中$||m|{|}_{\infty },||e_k|{|}_{\infty }\le 1$。

(3) $PER{F}_{BT{S}^{(k)}}=(kn,Q_{rem}/(2^{(k-1)n}q),kt)$。

文中提出使用归纳法来证明，感兴趣可以尝试一下。

4 Implementation

这里的实现，使用OpenFHE库中的官方教程代码：

#include "openfhe.h"

using namespace lbcrypto;
using namespace std;

void IterativeBootstrapExample();

int main() {
    IterativeBootstrapExample();
}

double CalculateApproximationError(const vector<complex<double>>& result, const vector<complex<double>>& expectedResult) {
    /*
     * 参数: result:真实结果,expectedResult：期待结果
     * 功能：用于真实值和期待值之间的最大计算近似误差
     */
    if (result.size() != expectedResult.size()) {            // 比较二者的尺寸是否相同
        OPENFHE_THROW("Cannot compare vectors with different numbers of elements");   // 不相同的情况下抛出异常
    }

    double maxError = 0;
    // 使用for循环得到真实值和期待值之间，最大的误差值
    for (size_t i = 0; i < result.size(); i++) {       // 遍历元素
        double error = abs(result[i].real() - expectedResult[i].real());           // 真实值减去期待值的绝对值
        if (maxError < error) {
            maxError = error;
        }
    }
    return abs(log2(maxError));                      // 返回最大误差对应的log2(*)的绝对值
}

void IterativeBootstrapExample() {
    // 1. 设置rns-ckks参数，以及bootstrapping参数
    CCParams<CryptoContextCKKSRNS> parameters;        // 声明rns-ckks参数对象
    SecretKeyDist secretKeyDist = UNIFORM_TERNARY;    // 指定密钥分布形式
    parameters.SetSecretKeyDist(secretKeyDist);       // 选择密钥分布形式
    parameters.SetSecurityLevel(HEStd_NotSet);        // 选择安全级别
    parameters.SetRingDim(1<<12);                     // 设置Ringim
    ScalingTechnique rescaleTech = FLEXIBLEAUTO;      // 指定rescale技术类别
    usint dcrtBits = 59;                              // 设置模链中的模大小
    usint firstMod = 60;                              // 设置模链中第一个模的大小
    parameters.SetScalingModSize(dcrtBits);           // 选择模链大小
    parameters.SetScalingTechnique(rescaleTech);      // 选择rescale技术
    parameters.SetFirstModSize(firstMod);             // 选择模链第一个模的大小
    uint32_t numIterations = 2;                       // 设置迭代自举的次数
    vector<uint32_t> levelBudget = {3, 3};            // 设置自举过程中同态编码和解码消耗的级别预算
    vector<uint32_t> bsgsDim = {0, 0};                // ???
    uint32_t levelsAvailableAfterBootstrap = 10;      // 设置自举后期待密文拥有的深度
    usint depth = levelsAvailableAfterBootstrap       // 设置初始rns-ckks深度
    + FHECKKSRNS::GetBootstrapDepth(levelBudget, secretKeyDist)
    + (numIterations - 1);
    parameters.SetMultiplicativeDepth(depth);          // 设置深度
    // 2. 根据参数创建context
    CryptoContext<DCRTPoly> context = GenCryptoContext(parameters);    // 根据上述参数创建context
    cout << "CKKS scheme is using ring dimension " << context->GetRingDimension() << endl;
    // 3. 使能各种操作
    context->Enable(PKE);              // 使能公钥方案
    context->Enable(KEYSWITCH);        // 使能key switching
    context->Enable(LEVELEDSHE);       // 使能leveledshe
    context->Enable(ADVANCEDSHE);      // 使能advancedshe
    context->Enable(FHE);              // 使能fhe
    // 4. 初始化bootstrapping
    uint32_t numSlots = 8;      //使用稀疏打包方式
    context->EvalBootstrapSetup(levelBudget, bsgsDim, numSlots);     // 自举初始化
    // 5. 创建各种key，仅有私钥和公钥是被提取出来的，其余的各种计算公钥key均蕴含在context对象中
    auto keys = context->KeyGen();                    // 密钥对生成
    auto sk = keys.secretKey;                       // 提取解密私钥
    auto pk = keys.publicKey;                       // 提取加密公钥
    context->EvalMultKeyGen(sk);                   // 重线性化计算公钥生成
    context->EvalBootstrapKeyGen(sk, numSlots);    // 自举计算公钥生成
    // 6. 创建消息向量
    vector<double> x = {0.5, 0.2, 0.1, 0.6, 0.7, 0.8, 0.1, 0.2};    // 消息向量
    // 7. 编码为明文多项式
    Plaintext pt = context->MakeCKKSPackedPlaintext(x, 1, depth-1, nullptr, numSlots); // 编码
    pt->SetLength(numSlots);
    cout << "Input : " << pt << endl;
    // 8. 加密得到密文
    auto ct = context->Encrypt(pk, pt);  // 加密
    // 9. 对密文进行一次自举，即BTS^(1)
    auto ciphertextAfter = context->EvalBootstrap(ct);   // 对密文进行自举
    // 10. 解密自举后的密文
    Plaintext result;      // 声明一个空的明文多项式
    context->Decrypt(sk, ciphertextAfter, &result);      // 解密
    result->SetLength(numSlots);
    // 11. 调用CalculateApproximationError()函数，查看自举一次后的精度值
    uint32_t precision = floor(CalculateApproximationError(result->GetCKKSPackedValue(), pt->GetCKKSPackedValue()));    // 精度
    // 12. 打印输出
    cout << "一次迭代自举得到的密文精度为 : " << precision << endl;
    // 13.
    // precision = 17;
    cout << "Precision input to algorithm : " << precision << endl;
    // 14. 对原密文进行二次迭代自举，即Meta-BTS(BTS^(2))
    auto ciphertextTwoIterations = context->EvalBootstrap(ct, numIterations, precision);
    // 15. 解密自举后的密文
    Plaintext resultTwoIterations;
    context->Decrypt(sk, ciphertextTwoIterations, &resultTwoIterations);
    result->SetLength(numSlots);
    auto actualResult = resultTwoIterations->GetCKKSPackedValue();
    cout << "两次自举得到的密文结果为 : " << actualResult << endl;
    // 16. 调用CalculateApproximationError()函数，查看二次迭代自举后的精度值
    double precisionMultipleIterations = CalculateApproximationError(actualResult, pt->GetCKKSPackedValue());
    cout << "两次迭代自举得到的密文精度为 : " << precisionMultipleIterations << endl;
    cout << "两次迭代自举后得到的密文保留的深度为 : " << depth - ciphertextTwoIterations->GetLevel() - (ciphertextTwoIterations->GetNoiseScaleDeg() - 1) << endl;
}

5 Conclusion

本文提出了CKKS的高精度Bootstrapping算法，称为"Meta-BTS"。