Composite Prime Moduli Sampling and Scaling Factor Calculations (#910 phase 2)

src/pke/include/cryptocontext.h

@@ -66,9 +66,7 @@
 #include <algorithm>
 #include <unordered_map>
 #include <set>
-#ifdef DEBUG_KEY
-    #include <iostream>
-#endif
+#include <iostream>
 
 namespace lbcrypto {
 
@@ -1054,6 +1052,20 @@ class CryptoContextImpl : public Serializable {
         return params->GetElementParams()->GetRootOfUnity();
     }
 
+    /**
+    * GetCompositeDegree: get composite degree of the current scheme crypto context.
+    * @return integer value corresponding to composite degree
+    */
+    uint32_t GetCompositeDegreeFromCtxt() const {
+        const auto cryptoParams = std::dynamic_pointer_cast<CryptoParametersRNS>(params);
+        if (!cryptoParams) {
+            std::string errorMsg(std::string("std::dynamic_pointer_cast<CryptoParametersRNS>() failed"));
+            OPENFHE_THROW(errorMsg);
+        }
+
+        return cryptoParams->GetCompositeDegree();
+    }
+
     //------------------------------------------------------------------------------
     // KEYS GETTERS
     //------------------------------------------------------------------------------
@@ -2342,10 +2354,7 @@ class CryptoContextImpl : public Serializable {
     Ciphertext<Element> Rescale(ConstCiphertext<Element> ciphertext) const {
         ValidateCiphertext(ciphertext);
 
-        const auto cryptoParams =
-            std::dynamic_pointer_cast<CryptoParametersRNS>(ciphertext->GetCryptoContext()->GetCryptoParameters());
-
-        return GetScheme()->ModReduce(ciphertext, cryptoParams->GetCompositeDegree());
+        return GetScheme()->ModReduce(ciphertext, GetCompositeDegreeFromCtxt());
     }
 
     /**
@@ -2357,10 +2366,7 @@ class CryptoContextImpl : public Serializable {
     void RescaleInPlace(Ciphertext<Element>& ciphertext) const {
         ValidateCiphertext(ciphertext);
 
-        const auto cryptoParams =
-            std::dynamic_pointer_cast<CryptoParametersRNS>(ciphertext->GetCryptoContext()->GetCryptoParameters());
-
-        GetScheme()->ModReduceInPlace(ciphertext, cryptoParams->GetCompositeDegree());
+        GetScheme()->ModReduceInPlace(ciphertext, GetCompositeDegreeFromCtxt());
     }
 
     /**
@@ -2371,13 +2377,7 @@ class CryptoContextImpl : public Serializable {
     Ciphertext<Element> ModReduce(ConstCiphertext<Element> ciphertext) const {
         ValidateCiphertext(ciphertext);
 
-        if (isCKKS(m_schemeId)) {
-            const auto cryptoParams =
-                std::dynamic_pointer_cast<CryptoParametersRNS>(ciphertext->GetCryptoContext()->GetCryptoParameters());
-            return GetScheme()->ModReduce(ciphertext, cryptoParams->GetCompositeDegree());
-        }
-
-        return GetScheme()->ModReduce(ciphertext, BASE_NUM_LEVELS_TO_DROP);
+        return GetScheme()->ModReduce(ciphertext, GetCompositeDegreeFromCtxt());
     }
 
     /**
@@ -2387,14 +2387,7 @@ class CryptoContextImpl : public Serializable {
     void ModReduceInPlace(Ciphertext<Element>& ciphertext) const {
         ValidateCiphertext(ciphertext);
 
-        if (isCKKS(m_schemeId)) {
-            const auto cryptoParams =
-                std::dynamic_pointer_cast<CryptoParametersRNS>(ciphertext->GetCryptoContext()->GetCryptoParameters());
-            GetScheme()->ModReduceInPlace(ciphertext, cryptoParams->GetCompositeDegree());
-        }
-        else {
-            GetScheme()->ModReduceInPlace(ciphertext, BASE_NUM_LEVELS_TO_DROP);
-        }
+        GetScheme()->ModReduceInPlace(ciphertext, GetCompositeDegreeFromCtxt());
     }
 
     /**
@@ -2408,13 +2401,7 @@ class CryptoContextImpl : public Serializable {
                                     size_t levels = 1) const {
         ValidateCiphertext(ciphertext);
 
-        if (isCKKS(m_schemeId)) {
-            const auto cryptoParams =
-                std::dynamic_pointer_cast<CryptoParametersRNS>(ciphertext->GetCryptoContext()->GetCryptoParameters());
-            return GetScheme()->LevelReduce(ciphertext, evalKey, levels * cryptoParams->GetCompositeDegree());
-        }
-
-        return GetScheme()->LevelReduce(ciphertext, evalKey, levels);
+        return GetScheme()->LevelReduce(ciphertext, evalKey, levels * GetCompositeDegreeFromCtxt());
     }
 
     /**
@@ -2429,14 +2416,7 @@ class CryptoContextImpl : public Serializable {
             return;
         }
 
-        if (isCKKS(m_schemeId)) {
-            const auto cryptoParams =
-                std::dynamic_pointer_cast<CryptoParametersRNS>(ciphertext->GetCryptoContext()->GetCryptoParameters());
-            GetScheme()->LevelReduceInPlace(ciphertext, evalKey, levels * cryptoParams->GetCompositeDegree());
-        }
-        else {
-            GetScheme()->LevelReduceInPlace(ciphertext, evalKey, levels);
-        }
+        GetScheme()->LevelReduceInPlace(ciphertext, evalKey, levels * GetCompositeDegreeFromCtxt());
     }
     /**
    * Compress - Reduces the size of ciphertext modulus to minimize the

src/pke/include/scheme/ckksrns/ckksrns-advancedshe.h

@@ -47,6 +47,9 @@ class AdvancedSHECKKSRNS : public AdvancedSHERNS {
 public:
     virtual ~AdvancedSHECKKSRNS() {}
 
+    Ciphertext<DCRTPoly> EvalMultMany(const std::vector<Ciphertext<DCRTPoly>>& ciphertextVec,
+                                      const std::vector<EvalKey<DCRTPoly>>& evalKeyVec) const override;
+
     //------------------------------------------------------------------------------
     // LINEAR WEIGHTED SUM
     //------------------------------------------------------------------------------

src/pke/include/schemerns/rns-leveledshe.h

@@ -291,6 +291,15 @@ class LeveledSHERNS : public LeveledSHEBase<DCRTPoly> {
 
     Ciphertext<DCRTPoly> Compress(ConstCiphertext<DCRTPoly> ciphertext, size_t towersLeft) const override;
 
+    ////////////////////////////////////////
+    // SHE LEVELED ComposedEvalMult
+    ////////////////////////////////////////
+
+    using LeveledSHEBase<DCRTPoly>::ComposedEvalMult;
+
+    Ciphertext<DCRTPoly> ComposedEvalMult(ConstCiphertext<DCRTPoly> ciphertext1, ConstCiphertext<DCRTPoly> ciphertext2,
+                                          const EvalKey<DCRTPoly> evalKey) const override;
+
 protected:
     /////////////////////////////////////
     // RNS Core

src/pke/lib/scheme/ckksrns/ckksrns-advancedshe.cpp

@@ -46,6 +46,32 @@ CKKS implementation. See https://eprint.iacr.org/2020/1118 for details.
 
 namespace lbcrypto {
 
+Ciphertext<DCRTPoly> AdvancedSHECKKSRNS::EvalMultMany(const std::vector<Ciphertext<DCRTPoly>>& ciphertextVec,
+                                                      const std::vector<EvalKey<DCRTPoly>>& evalKeys) const {
+    if (ciphertextVec.size() < 1)
+        OPENFHE_THROW("Input ciphertext vector size should be 1 or more");
+
+    const size_t inSize = ciphertextVec.size();
+    const size_t lim    = inSize * 2 - 2;
+    std::vector<Ciphertext<DCRTPoly>> ciphertextMultVec;
+    ciphertextMultVec.resize(inSize - 1);
+    size_t ctrIndex = 0;
+
+    auto algo               = ciphertextVec[0]->GetCryptoContext()->GetScheme();
+    const auto cc           = ciphertextVec[0]->GetCryptoContext();
+    const auto cryptoParams = std::dynamic_pointer_cast<CryptoParametersRNS>(ciphertextVec[0]->GetCryptoParameters());
+    uint32_t levelsToDrop   = cryptoParams->GetCompositeDegree();
+
+    for (size_t i = 0; i < lim; i = i + 2) {
+        ciphertextMultVec[ctrIndex] = algo->EvalMultAndRelinearize(
+            i < inSize ? ciphertextVec[i] : ciphertextMultVec[i - inSize],
+            i + 1 < inSize ? ciphertextVec[i + 1] : ciphertextMultVec[i + 1 - inSize], evalKeys);
+        algo->ModReduceInPlace(ciphertextMultVec[ctrIndex++], levelsToDrop);
+    }
+
+    return ciphertextMultVec.back();
+}
+
 //------------------------------------------------------------------------------
 // LINEAR WEIGHTED SUM
 //------------------------------------------------------------------------------

src/pke/lib/scheme/ckksrns/ckksrns-parametergeneration.cpp

@@ -70,14 +70,20 @@ bool ParameterGenerationCKKSRNS::ParamsGenCKKSRNS(std::shared_ptr<CryptoParamete
 
     // Determine appropriate composite degree automatically if scaling technique set to COMPOSITESCALINGAUTO
     cryptoParamsCKKSRNS->ConfigureCompositeDegree(firstModSize);
-  
+
     uint32_t compositeDegree  = cryptoParamsCKKSRNS->GetCompositeDegree();
     uint32_t registerWordSize = cryptoParamsCKKSRNS->GetRegisterWordSize();
 
     if (scalTech == COMPOSITESCALINGAUTO || scalTech == COMPOSITESCALINGMANUAL) {
         if (compositeDegree > 2 && scalingModSize < 55) {
-            OPENFHE_THROW(
-                "COMPOSITESCALING Warning: There will probably not be enough prime moduli for composite degree > 2 and scaling factor < 55, prime moduli too small. Prime moduli size must generally be greater than 22, especially for larger multiplicative depth. Try increasing the scaling factor (scalingModSize) or feel free to try it using COMPOSITESCALINGMANUAL at your own risk.");
+            std::string errorMsg = "COMPOSITESCALING Warning:";
+            errorMsg +=
+                "There will not be enough prime moduli for composite degree > 2 and scaling factor < 55 -- prime moduli too small.";
+            errorMsg +=
+                "Prime moduli size must generally be greater than 22, especially for larger multiplicative depth.";
+            errorMsg += "Try increasing the scaling factor (scalingModSize).";
+            errorMsg += "Also, feel free to use COMPOSITESCALINGMANUAL at your own risk.";
+            OPENFHE_THROW(errorMsg);
         }
         else if (compositeDegree == 1 && registerWordSize < 64) {
             OPENFHE_THROW(
@@ -88,8 +94,9 @@ bool ParameterGenerationCKKSRNS::ParamsGenCKKSRNS(std::shared_ptr<CryptoParamete
         }
 
         if (registerWordSize < 24 && scalTech == COMPOSITESCALINGAUTO) {
-            OPENFHE_THROW(
-                "Register word size must be greater than or equal to 24 for COMPOSITESCALINGAUTO. Otherwise, try it with COMPOSITESCALINGMANUAL.");
+            std::string errorMsg = "Register word size must be greater than or equal to 24 for COMPOSITESCALINGAUTO.";
+            errorMsg += "Otherwise, try it with COMPOSITESCALINGMANUAL.";
+            OPENFHE_THROW(errorMsg);
         }
     }
 
@@ -166,11 +173,7 @@ bool ParameterGenerationCKKSRNS::ParamsGenCKKSRNS(std::shared_ptr<CryptoParamete
 
     uint32_t dcrtBits = scalingModSize;
 
-    if (scalTech == COMPOSITESCALINGAUTO || scalTech == COMPOSITESCALINGMANUAL) {
-        numPrimes *= compositeDegree;
-        std::cout << __FUNCTION__ << "::" << __LINE__ << " numPrimes: " << numPrimes << " qBound: " << qBound
-                  << std::endl;
-    }
+    numPrimes *= compositeDegree;
 
     uint32_t vecSize = (extraModSize == 0) ? numPrimes : numPrimes + 1;
     std::vector<NativeInteger> moduliQ(vecSize);
@@ -205,13 +208,8 @@ bool ParameterGenerationCKKSRNS::ParamsGenCKKSRNS(std::shared_ptr<CryptoParamete
 
     // Validate the ring dimension found using estimated logQ(P) against actual logQ(P)
     if (stdLevel != HEStd_NotSet) {
-        uint32_t logActualQ = 0;
-        if (ksTech == HYBRID) {
-            logActualQ = cryptoParamsCKKSRNS->GetParamsQP()->GetModulus().GetMSB();
-        }
-        else {
-            logActualQ = cryptoParamsCKKSRNS->GetElementParams()->GetModulus().GetMSB();
-        }
+        uint32_t logActualQ = (ksTech == HYBRID) ? cryptoParamsCKKSRNS->GetParamsQP()->GetModulus().GetMSB() :
+                                                   cryptoParamsCKKSRNS->GetElementParams()->GetModulus().GetMSB();
 
         uint32_t nActual = StdLatticeParm::FindRingDim(distType, stdLevel, logActualQ);
         if (n < nActual) {
@@ -234,16 +232,13 @@ void ParameterGenerationCKKSRNS::CompositePrimeModuliGen(std::vector<NativeInteg
     std::unordered_set<uint64_t> moduliQRecord;
 
     // Sample q0, the first primes in the modulus chain
-    NativeInteger q;
-    uint32_t qBitSize = static_cast<double>(dcrtBits) / compositeDegree;
-    uint32_t remBits  = dcrtBits;
+    uint32_t remBits = dcrtBits;
 
     for (uint32_t d = 1; d <= compositeDegree; ++d) {
-        double numBits = static_cast<double>(remBits) / (compositeDegree - d + 1);
-        qBitSize       = std::ceil(numBits);
-        q              = FirstPrime<NativeInteger>(qBitSize, cyclOrder);
-        q              = PreviousPrime<NativeInteger>(q, cyclOrder);
-        while (std::log2(q.ConvertToDouble()) > registerWordSize || std::log2(q.ConvertToDouble()) > numBits ||
+        uint32_t qBitSize = std::ceil(static_cast<double>(remBits) / (compositeDegree - d + 1));
+        NativeInteger q   = FirstPrime<NativeInteger>(qBitSize, cyclOrder);
+        q                 = PreviousPrime<NativeInteger>(q, cyclOrder);
+        while (std::log2(q.ConvertToDouble()) > registerWordSize || std::log2(q.ConvertToDouble()) > qBitSize ||
                moduliQRecord.find(q.ConvertToInt()) != moduliQRecord.end()) {
             q = PreviousPrime<NativeInteger>(q, cyclOrder);
         }
@@ -253,17 +248,17 @@ void ParameterGenerationCKKSRNS::CompositePrimeModuliGen(std::vector<NativeInteg
         remBits -= std::ceil(std::log2(q.ConvertToDouble()));
     }
 
-    std::vector<NativeInteger> qPrev(std::ceil(static_cast<double>(compositeDegree) / 2));
-    std::vector<NativeInteger> qNext(compositeDegree - static_cast<uint32_t>(qPrev.size()));
-
     if (numPrimes > 1) {
+        std::vector<NativeInteger> qPrev(std::ceil(static_cast<double>(compositeDegree) / 2));
+        std::vector<NativeInteger> qNext(compositeDegree - static_cast<uint32_t>(qPrev.size()));
+
         // Prep to compute initial scaling factor
         double sf = moduliQ[numPrimes - 1].ConvertToDouble();
         for (uint32_t d = 2; d <= compositeDegree; ++d) {
             sf *= moduliQ[numPrimes - d].ConvertToDouble();
         }
 
-        uint32_t cnt = 1;
+        bool flag = true;
         for (usint i = numPrimes - compositeDegree; i >= 2 * compositeDegree; i -= compositeDegree) {
             // Compute initial scaling factor
             sf = static_cast<double>(std::pow(sf, 2));
@@ -273,15 +268,13 @@ void ParameterGenerationCKKSRNS::CompositePrimeModuliGen(std::vector<NativeInteg
 
             auto sf_sqrt = std::pow(sf, 1.0 / compositeDegree);
 
-            qBitSize = std::ceil(std::log2(sf_sqrt));
-
             NativeInteger sfInt = std::llround(sf_sqrt);
             NativeInteger sfRem = sfInt.Mod(cyclOrder);
 
             double primeProduct = 1.0;
             std::unordered_set<uint64_t> qCurrentRecord;  // current prime tracker
 
-            for (uint32_t step = 0; step < static_cast<uint32_t>(qPrev.size()); ++step) {
+            for (size_t step = 0; step < qPrev.size(); ++step) {
                 qPrev[step] = sfInt - sfRem + NativeInteger(1) - NativeInteger(cyclOrder);
                 do {
                     try {
@@ -291,15 +284,14 @@ void ParameterGenerationCKKSRNS::CompositePrimeModuliGen(std::vector<NativeInteg
                         OPENFHE_THROW(
                             "COMPOSITE SCALING previous prime sampling error. Try increasing scaling factor (scalingModSize).");
                     }
-                } while (  // std::log2(qPrev[step].ConvertToDouble()) > qBitSize ||
-                    std::log2(qPrev[step].ConvertToDouble()) > registerWordSize ||
-                    moduliQRecord.find(qPrev[step].ConvertToInt()) != moduliQRecord.end() ||
-                    qCurrentRecord.find(qPrev[step].ConvertToInt()) != qCurrentRecord.end());
+                } while (std::log2(qPrev[step].ConvertToDouble()) > registerWordSize ||
+                         moduliQRecord.find(qPrev[step].ConvertToInt()) != moduliQRecord.end() ||
+                         qCurrentRecord.find(qPrev[step].ConvertToInt()) != qCurrentRecord.end());
                 qCurrentRecord.emplace(qPrev[step].ConvertToInt());
                 primeProduct *= qPrev[step].ConvertToDouble();
             }
 
-            for (uint32_t step = 0; step < static_cast<uint32_t>(qNext.size()); ++step) {
+            for (size_t step = 0; step < qNext.size(); ++step) {
                 qNext[step] = sfInt - sfRem + NativeInteger(1) + NativeInteger(cyclOrder);
                 do {
                     try {
@@ -316,7 +308,7 @@ void ParameterGenerationCKKSRNS::CompositePrimeModuliGen(std::vector<NativeInteg
                 primeProduct *= qNext[step].ConvertToDouble();
             }
 
-            if (cnt == 0) {
+            if (flag == false) {
                 NativeInteger qPrevNext = NativeInteger(qNext[qNext.size() - 1].ConvertToInt());
                 while (primeProduct > sf) {
                     do {
@@ -351,7 +343,7 @@ void ParameterGenerationCKKSRNS::CompositePrimeModuliGen(std::vector<NativeInteg
                     moduliQRecord.emplace(moduliQ[i - d].ConvertToInt());
                 }
 
-                cnt = 1;
+                flag = true;
             }
             else {
                 NativeInteger qNextPrev = NativeInteger(qPrev[qPrev.size() - 1].ConvertToInt());
@@ -366,10 +358,9 @@ void ParameterGenerationCKKSRNS::CompositePrimeModuliGen(std::vector<NativeInteg
                             OPENFHE_THROW(
                                 "COMPOSITE SCALING next prime sampling error. Try increasing scaling factor (scalingModSize).");
                         }
-                    } while (  // std::log2(qNextPrev.ConvertToDouble()) > qBitSize ||
-                        std::log2(qNextPrev.ConvertToDouble()) > registerWordSize ||
-                        moduliQRecord.find(qNextPrev.ConvertToInt()) != moduliQRecord.end() ||
-                        qCurrentRecord.find(qNextPrev.ConvertToInt()) != qCurrentRecord.end());
+                    } while (std::log2(qNextPrev.ConvertToDouble()) > registerWordSize ||
+                             moduliQRecord.find(qNextPrev.ConvertToInt()) != moduliQRecord.end() ||
+                             qCurrentRecord.find(qNextPrev.ConvertToInt()) != qCurrentRecord.end());
                     qCurrentRecord.emplace(qNextPrev.ConvertToInt());
 
                     primeProduct /= qPrev[qPrev.size() - 1].ConvertToDouble();
@@ -390,7 +381,7 @@ void ParameterGenerationCKKSRNS::CompositePrimeModuliGen(std::vector<NativeInteg
                     moduliQRecord.emplace(moduliQ[i - d].ConvertToInt());
                 }
 
-                cnt = 0;
+                flag = false;
             }
         }  // for loop
     }  // if numPrimes > 1
@@ -399,10 +390,9 @@ void ParameterGenerationCKKSRNS::CompositePrimeModuliGen(std::vector<NativeInteg
         OPENFHE_THROW("firstModSize must be > scalingModSize.");
     }
     else {
-        qBitSize = 0;
-        remBits  = static_cast<uint32_t>(firstModSize);
+        remBits = static_cast<uint32_t>(firstModSize);
         for (uint32_t d = 1; d <= compositeDegree; ++d) {
-            qBitSize = std::ceil(static_cast<double>(remBits) / (compositeDegree - d + 1));
+            uint32_t qBitSize = std::ceil(static_cast<double>(remBits) / (compositeDegree - d + 1));
             // Find next prime
             NativeInteger nextInteger = FirstPrime<NativeInteger>(qBitSize, cyclOrder);
             nextInteger               = PreviousPrime<NativeInteger>(nextInteger, cyclOrder);

src/pke/lib/schemebase/base-advancedshe.cpp

@@ -105,20 +105,11 @@ Ciphertext<Element> AdvancedSHEBase<Element>::EvalMultMany(const std::vector<Cip
 
     auto algo = ciphertextVec[0]->GetCryptoContext()->GetScheme();
 
-    const auto cc = ciphertextVec[0]->GetCryptoContext();
-
-    uint32_t levelsToDrop = BASE_NUM_LEVELS_TO_DROP;
-    if (cc->getSchemeId() == CKKSRNS_SCHEME) {
-        const auto cryptoParams =
-            std::dynamic_pointer_cast<CryptoParametersRNS>(ciphertextVec[0]->GetCryptoParameters());
-        levelsToDrop = cryptoParams->GetCompositeDegree();
-    }
-
     for (size_t i = 0; i < lim; i = i + 2) {
         ciphertextMultVec[ctrIndex] = algo->EvalMultAndRelinearize(
             i < inSize ? ciphertextVec[i] : ciphertextMultVec[i - inSize],
             i + 1 < inSize ? ciphertextVec[i + 1] : ciphertextMultVec[i + 1 - inSize], evalKeys);
-        algo->ModReduceInPlace(ciphertextMultVec[ctrIndex++], levelsToDrop);
+        algo->ModReduceInPlace(ciphertextMultVec[ctrIndex++], BASE_NUM_LEVELS_TO_DROP);
     }
 
     return ciphertextMultVec.back();