Inconsistent results between SealCkksContext and OpenFheCkksContext in a multiplication intensive program

[zooiik]

This issue shares some similarities with issue #24 , but the program provided here involves much more multiplication operations, which may introduces more noise accumulation that were not present in #24.

Therefore, I suspect that these two issues stem from different root causes? So I create two issues :)

Here is the minimal reproducible snippet:

import pyhelayers

def run_bug_reproduction():
    requirement = pyhelayers.HeConfigRequirement(
        num_slots=8192,
        multiplication_depth=7,
        fractional_part_precision=40,
        integer_part_precision=20,
        security_level=128
    )
    he_context = pyhelayers.SealCkksContext() # BUG occurs here 
    # he_context = pyhelayers.OpenFheCkksContext() # Correct alternative

    he_context.init(requirement)
    encoder = pyhelayers.Encoder(he_context)

    val_x = 25

    # Expected calculation steps:
    # x = 25
    # var_0002 = -10 * 25 = -250
    # var_0003 = -250 * -12 = 3000
    # var_0004 = 3000 * -250 = -750000
    # var_0005 = -750000 * 6 = -4500000
    # var_0006 = -4500000 - (-4500000) = 0
    # var_0007 = 0 * -4500000 = 0
    # var_0008 = 0 * 3000 = 0
    expected_result = 0
    print(f"Expected Plaintext Result: {expected_result}")

    ct_x = encoder.encode_encrypt([val_x])
 
    var_0002 = pyhelayers.CTile(ct_x)
    var_0002.multiply_scalar(-10)

    var_0003 = pyhelayers.CTile(var_0002)
    var_0003.multiply_scalar(-12)

    var_0004 = pyhelayers.CTile(var_0003)
    var_0004.multiply(var_0002)

    var_0005 = pyhelayers.CTile(var_0004)
    var_0005.multiply_scalar(6)

    var_0006 = pyhelayers.CTile(var_0005)
    var_0006.sub(var_0005)

    var_0007 = pyhelayers.CTile(var_0006)
    var_0007.multiply(var_0005)

    var_0008 = pyhelayers.CTile(var_0007)
    var_0008.multiply(var_0003)

    res_vec = encoder.decrypt_decode_int(var_0008)
    fhe_result = int(round(res_vec.flat[0]))

    print(f"HElayers Result: {fhe_result}")


if __name__ == "__main__":
    run_bug_reproduction()

If I use the SealCkksContext backend, then the program output is

Expected Plaintext Result: 0
HElayers Result: -4

However, the result from OpenFheCkksContext is correct:

Expected Plaintext Result: 0
HElayers Result: 0

[aehud]

Here it's a combination of the phenomenon from issue #24 and another thing that is not a bug.
You multiply var_0007 and var_0008, which are supposed to be 0, by a very large constant, -3000*4500000. CKKS is an approximate scheme, so 0 is not really 0 but a very small value such as 1e-10. Multiplied by a large factor it may end up in values larger than 1.

Note that var_0006 is transparently 0 (it's 0 regardless of the initial input). So the result may be exactly 0 or some noisy 0 depending on how we handle transparent ciphertexts internally. We'll make it consistent in the next release.