CKKS: single-iteration UNIFORM_TERNARY standard bootstrap produces wrong values (FLEXIBLEAUTO, scaleModSize 50, multDepth ≥ 25) #1364

// uniform_bootstrap_1iter.cpp
#include "openfhe.h"
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace lbcrypto;

// Decrypt while bypassing CKKSPackedEncoding::Decode's precision guard (EXEC_EVALUATION
// instead of EXEC_DECRYPT), so the wrong values can be printed. The public cc->Decrypt
// path is also exercised: on the buggy version it throws before we get here.
static std::vector<std::complex<double>> DecodeNoGuard(CryptoContext<DCRTPoly>& cc,
                                                       const PrivateKey<DCRTPoly>& sk,
                                                       ConstCiphertext<DCRTPoly> shell, uint32_t slots) {
    Plaintext p = PlaintextFactory::MakePlaintext(CKKS_PACKED_ENCODING, shell->GetElements()[0].GetParams(),
                                                  cc->GetEncodingParams(), SCHEME::INVALID_SCHEME, COMPLEX);
    cc->GetScheme()->Decrypt(shell, sk, &p->GetElement<Poly>());
    auto ckks = std::dynamic_pointer_cast<CKKSPackedEncoding>(p);
    ckks->SetNoiseScaleDeg(shell->GetNoiseScaleDeg());
    ckks->SetLevel(shell->GetLevel());
    ckks->SetScalingFactor(shell->GetScalingFactor());
    ckks->SetSlots(slots);
    auto params = std::dynamic_pointer_cast<CryptoParametersRNS>(cc->GetCryptoParameters());
    ckks->Decode(shell->GetNoiseScaleDeg(), shell->GetScalingFactor(), params->GetScalingTechnique(),
                 EXEC_EVALUATION);
    return ckks->GetCKKSPackedValue();
}

static bool run(const char* label, SecretKeyDist skd, uint32_t numIterations, uint32_t precision) {
    const uint32_t multDepth = 25, scaleModSize = 50, batchSize = 8, ringDim = 1 << 12;

    CCParams<CryptoContextCKKSRNS> parameters;
    parameters.SetSecretKeyDist(skd);
    parameters.SetScalingTechnique(FLEXIBLEAUTO);
    parameters.SetMultiplicativeDepth(multDepth);
    parameters.SetScalingModSize(scaleModSize);
    parameters.SetBatchSize(batchSize);
    parameters.SetSecurityLevel(HEStd_NotSet);
    parameters.SetRingDim(ringDim);

    CryptoContext<DCRTPoly> cc = GenCryptoContext(parameters);
    cc->Enable(PKE);
    cc->Enable(KEYSWITCH);
    cc->Enable(LEVELEDSHE);
    cc->Enable(ADVANCEDSHE);
    cc->Enable(FHE);

    auto keys = cc->KeyGen();
    cc->EvalMultKeyGen(keys.secretKey);
    cc->EvalBootstrapSetup({ 3, 3 }, { 0, 0 }, batchSize, /*correctionFactor=*/0);
    cc->EvalBootstrapKeyGen(keys.secretKey, batchSize);

    const std::vector<double> x = { 0.25, 0.5, 0.75, 1.0, 2.0, 3.0, 4.0, 5.0 };
    auto ptxt = cc->MakeCKKSPackedPlaintext(x, 1, multDepth - 1, nullptr, batchSize);
    auto ctxt = cc->Encrypt(keys.publicKey, ptxt);

    auto c = cc->EvalBootstrap(ctxt, numIterations, precision);

    // The public decrypt path (with the precision guard).
    bool publicDecryptOk = true;
    try {
        Plaintext r;
        cc->Decrypt(keys.secretKey, c, &r);
    } catch (const std::exception& e) {
        publicDecryptOk = false;
        std::cout << "[" << label << "] public Decrypt THREW: " << e.what() << "\n";
    }

    // Guard-free decode to measure the actual error.
    double maxErr = 0.0;
    std::vector<double> got;
    try {
        auto v = DecodeNoGuard(cc, keys.secretKey, c, batchSize);
        for (uint32_t i = 0; i < batchSize; ++i) {
            got.push_back(v[i].real());
            maxErr = std::max(maxErr, std::abs(v[i].real() - x[i]));
        }
    } catch (const std::exception& e) {
        std::cout << "[" << label << "] guard-free decode THREW: " << e.what() << "\n";
        return false;
    }

    const bool pass = publicDecryptOk && maxErr < 1e-2;
    std::cout << "[" << label << "] maxErr=" << std::scientific << std::setprecision(3) << maxErr
              << "  first values:";
    for (int i = 0; i < 4; ++i)
        std::cout << " " << std::fixed << std::setprecision(4) << got[i];
    std::cout << "  => " << (pass ? "PASS" : "FAIL") << std::endl;
    return pass;
}

int main() {
    std::cout << "MRE: standard CKKS bootstrap, FLEXIBLEAUTO, ring 2^12, slots 8, "
                 "scaleModSize 50, multDepth 25, levelBudget {3,3}, auto correction factor\n";
    bool ok = true;
    ok &= run("UNIFORM FLEX 1it", UNIFORM_TERNARY, /*numIterations=*/1, /*precision=*/0);
    ok &= run("UNIFORM FLEX 2it", UNIFORM_TERNARY, /*numIterations=*/2, /*precision=*/10);
    ok &= run("SPARSE  FLEX 1it", SPARSE_TERNARY, /*numIterations=*/1, /*precision=*/0);
    return ok ? 0 : 1;
}