Incorrect calculation results with SealCkksContext involving scalar subtraction and negation

[zooiik]

I encountered an incorrect result when using SealCkksContext, however, OpenFheCkksContext can produce a correct result.

Here is the minimal reproducible snippet:

import pyhelayers

def run_bug_reproduction():
    requirement = pyhelayers.HeConfigRequirement(
        num_slots=8192,
        multiplication_depth=6,
        fractional_part_precision=30,
        integer_part_precision=10,
        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 = -73
    
    # Expected calculation steps:
    # var_0002 = 5 - (-73) = 78
    # var_0003 = 12 + 78 = 90
    # var_0004 = -7 - 90 = -97
    # var_0005 = -14 - (-97) = 83
    # res = 83 + (-97) = -14
    expected_result = -14
    print(f"Expected Plaintext Result: {expected_result}")


    ct_x = encoder.encode_encrypt([val_x])
 
    var_0002 = pyhelayers.CTile(ct_x) 
    var_0002.add_scalar(-5)         
    var_0002.multiply_scalar(-1)    

    var_0003 = pyhelayers.CTile(var_0002) 
    var_0003.add_scalar(12)

    var_0004 = pyhelayers.CTile(var_0003) 
    var_0004.add_scalar(7)
    var_0004.multiply_scalar(-1)

    var_0005 = pyhelayers.CTile(var_0004) 
    var_0005.add_scalar(14)
    var_0005.multiply_scalar(-1)

    result_ct = pyhelayers.CTile(var_0005)
    result_ct.add(var_0004)

    res_vec = encoder.decrypt_decode_double(result_ct)
    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: -14
HElayers Result: 0

However, the result from OpenFheCkksContext is correct:

Expected Plaintext Result: -14
HElayers Result: -14

[aehud]

Thanks. We'll check both issues and update soon.

[aehud]

This is indeed a bug and we'll fix it in the next release.

It's related to how we handle transparent ciphertexts, a situation that occurs sometimes where the computation creates a ciphertext where the value it encrypts is known. This occurs in your example, the result is transparent, which helayers accidentally erases and replaces with 0. You can see it's transparent, for example, by noting that the computation results in -14 for any input ct_x you feed it. In an ordinary computation the result does depend on the inputs, and this shouldn't occur. But anyway the next release will fix it.

[zooiik]

Got it! Thanks for your detailed responses to my two issues!