def test_add_inplace(context, vec1, vec2):
first_vec = ts.bfv_vector(context, vec1)
second_vec = ts.bfv_vector(context, vec2)
first_vec += second_vec
expected = [v1 + v2 for v1, v2 in zip(vec1, vec2)]
# Decryption
decrypted_result = first_vec.decrypt()
assert decrypted_result == expected, "Addition of vectors is incorrect."
assert second_vec.decrypt() == vec2, "Something went wrong in memory."
def test_sub_inplace(context):
first_vec = ts.bfv_vector(context, [1, 2, 3, 4])
second_vec = ts.bfv_vector(context, [4, 3, 2, 1])
first_vec -= second_vec
# Decryption
decrypted_result = first_vec.decrypt()
assert decrypted_result == [-3, -1, 1,
3], "Substraction of vectors is incorrect."
assert second_vec.decrypt() == [4, 3, 2,
1], "Something went wrong in memory."
def test_mul(context, vec1, vec2):
first_vec = ts.bfv_vector(context, vec1)
second_vec = ts.bfv_vector(context, vec2)
result = first_vec * second_vec
expected = [v1 * v2 for v1, v2 in zip(vec1, vec2)]
# Decryption
decrypted_result = result.decrypt()
assert decrypted_result == expected, "Multiplication of vectors is incorrect."
assert first_vec.decrypt() == vec1, "Something went wrong in memory."
assert second_vec.decrypt() == vec2, "Something went wrong in memory."
def test_dot_product_inplace(context, vec1, vec2):
context.generate_galois_keys()
first_vec = ts.bfv_vector(context, vec1)
second_vec = ts.bfv_vector(context, vec2)
first_vec.dot_(second_vec)
expected = [sum([v1 * v2 for v1, v2 in zip(vec1, vec2)])]
# Decryption
assert first_vec.decrypt(
) == expected, "Dot product of vectors is incorrect."
assert second_vec.decrypt() == vec2, "Something went wrong in memory."
def test_mul_inplace(context):
first_vec = ts.bfv_vector(context, [66, 73, 81, 90])
second_vec = ts.bfv_vector(context, [2, 3, 4, 5])
first_vec *= second_vec
# Decryption
decrypted_result = first_vec.decrypt()
assert decrypted_result == [132, 219, 324,
450], "Multiplication of vectors is incorrect."
assert second_vec.decrypt() == [2, 3, 4,
5], "Something went wrong in memory."
def test_add_inplace(context):
first_vec = ts.bfv_vector(context, [1, 2, 3, 4])
second_vec = ts.bfv_vector(context, [4, 3, 2, 1])
first_vec += second_vec
# Decryption
decrypted_result = first_vec.decrypt()
assert decrypted_result == [5, 5, 5,
5], "Addition of vectors is incorrect."
assert second_vec.decrypt() == [4, 3, 2,
1], "Something went wrong in memory."
def test_sub(vec1, vec2, duplicate):
context = bfv_context()
first_vec = ts.bfv_vector(context, vec1)
first_vec = duplicate(first_vec)
second_vec = ts.bfv_vector(context, vec2)
result = first_vec - second_vec
expected = [v1 - v2 for v1, v2 in zip(vec1, vec2)]
# Decryption
decrypted_result = result.decrypt()
assert decrypted_result == expected, "Substraction of vectors is incorrect."
assert first_vec.decrypt() == vec1, "Something went wrong in memory."
assert second_vec.decrypt() == vec2, "Something went wrong in memory."
def test_mul_inplace(vec1, vec2, duplicate):
context = bfv_context()
first_vec = ts.bfv_vector(context, vec1)
second_vec = ts.bfv_vector(context, vec2)
first_vec *= second_vec
first_vec = duplicate(first_vec)
expected = [v1 * v2 for v1, v2 in zip(vec1, vec2)]
# Decryption
decrypted_result = first_vec.decrypt()
assert decrypted_result == expected, "Multiplication of vectors is incorrect."
assert second_vec.decrypt() == vec2, "Something went wrong in memory."
def test_bfv_encryption_decryption(plain_vec, encryption_type):
context = ts.context(ts.SCHEME_TYPE.BFV, 8192, 1032193, [], encryption_type)
bfv_vec = ts.bfv_vector(context, plain_vec)
decrypted_vec = bfv_vec.decrypt()
assert decrypted_vec == plain_vec, "Decryption of vector is incorrect."
def test_sub_plain_inplace(context, vec1, vec2):
first_vec = ts.bfv_vector(context, vec1)
second_vec = vec2
first_vec -= second_vec
expected = [v1 - v2 for v1, v2 in zip(vec1, vec2)]
# Decryption
decrypted_result = first_vec.decrypt()
assert decrypted_result == expected, "Substraction of vectors is incorrect."
def test_add__plain_inplace(context):
first_vec = ts.bfv_vector(context, [1, 2, 3, 4])
second_vec = [4, 3, 2, 1]
first_vec += second_vec
# Decryption
decrypted_result = first_vec.decrypt()
assert decrypted_result == [5, 5, 5,
5], "Addition of vectors is incorrect."
def test_mul_plain_inplace(context, vec1, vec2):
first_vec = ts.bfv_vector(context, vec1)
second_vec = vec2
first_vec *= second_vec
expected = [v1 * v2 for v1, v2 in zip(vec1, vec2)]
# Decryption
decrypted_result = first_vec.decrypt()
assert decrypted_result == expected, "Multiplication of vectors is incorrect."
def test_bfvvector_lazy_load():
vec1 = [1, 2, 3, 4]
vec2 = [1, 2, 3, 4]
context = bfv_context()
first_vec = ts.bfv_vector(context, vec1)
second_vec = ts.bfv_vector(context, vec2)
buff = first_vec.serialize()
newvec = ts.lazy_bfv_vector_from(buff)
newvec.link_context(context)
result = newvec + second_vec
# Decryption
decrypted_result = result.decrypt()
assert decrypted_result == [2, 4, 6,
8], "Addition of vectors is incorrect."
assert newvec.decrypt() == [1, 2, 3, 4], "Something went wrong in memory."
def test_bfv_secretkey_decryption(plain_vec):
context = ts.context(ts.SCHEME_TYPE.BFV, 8192, 1032193)
bfv_vec = ts.bfv_vector(context, plain_vec)
secret_key = context.secret_key()
context.make_context_public()
decrypted_vec = bfv_vec.decrypt(secret_key)
assert decrypted_vec == plain_vec, "Decryption of vector is incorrect."
def test_mul_plain_inplace(context):
first_vec = ts.bfv_vector(context, [66, 73, 81, 90])
second_vec = [2, 3, 4, 5]
first_vec *= second_vec
# Decryption
decrypted_result = first_vec.decrypt()
assert decrypted_result == [132, 219, 324,
450], "Multiplication of vectors is incorrect."
def test_sum(context, vec1):
context.generate_galois_keys()
first_vec = ts.bfv_vector(context, vec1)
result = first_vec.sum()
expected = [sum(vec1)]
# Decryption
assert result.decrypt() == expected, "Sum of vector is incorrect."
assert first_vec.decrypt() == vec1, "Something went wrong in memory."
def test_sub_plain_inplace(context):
first_vec = ts.bfv_vector(context, [1, 2, 3, 4])
second_vec = [4, 3, 2, 1]
first_vec -= second_vec
# Decryption
decrypted_result = first_vec.decrypt()
assert decrypted_result == [-3, -1, 1,
3], "Substraction of vectors is incorrect."
def test_sum_inplace(context, vec1):
context.generate_galois_keys()
first_vec = ts.bfv_vector(context, vec1)
result = first_vec.sum()
expected = [sum(vec1)]
# Decryption
decrypted_result = result.decrypt()
assert decrypted_result == expected, "Sum of vector is incorrect."
def test_mul_plain_zero(context):
# from context
max_slots = 8192
pt = [0] * max_slots
ct = ts.bfv_vector(context, [1] * max_slots)
with pytest.raises(RuntimeError) as e:
# the workaround of transparent ciphertext doesn't work when all slots are used
result = ct * pt
assert str(e.value) == "result ciphertext is transparent"
def test_dot_product_plain(context, vec1, vec2):
context.generate_galois_keys()
first_vec = ts.bfv_vector(context, vec1)
second_vec = ts.plain_tensor(vec2, dtype="int")
result = first_vec.dot(second_vec)
expected = [sum([v1 * v2 for v1, v2 in zip(vec1, vec2)])]
# Decryption
assert result.decrypt() == expected, "Dot product of vectors is incorrect."
assert first_vec.decrypt() == vec1, "Something went wrong in memory."
def test_sub_plain(context, vec1, vec2):
first_vec = ts.bfv_vector(context, vec1)
second_vec = vec2
result = first_vec - second_vec
expected = [v1 - v2 for v1, v2 in zip(vec1, vec2)]
# Decryption
decrypted_result = result.decrypt()
assert decrypted_result == expected, "Substraction of vectors is incorrect."
assert first_vec.decrypt() == vec1, "Something went wrong in memory."
def test_dot_product_plain_inplace(context, vec1, vec2):
context.generate_galois_keys()
first_vec = ts.bfv_vector(context, vec1)
second_vec = ts.plain_tensor(vec2, dtype="int")
first_vec.dot_(second_vec)
expected = [sum([v1 * v2 for v1, v2 in zip(vec1, vec2)])]
# Decryption
assert first_vec.decrypt(
) == expected, "Dot product of vectors is incorrect."
def test_bfv_secretkey_decryption(plain_vec, encryption_type):
context = ts.context(ts.SCHEME_TYPE.BFV, 8192, 1032193, [], encryption_type)
bfv_vec = ts.bfv_vector(context, plain_vec)
secret_key = context.secret_key()
if encryption_type is ts.ENCRYPTION_TYPE.ASYMMETRIC:
context.make_context_public()
decrypted_vec = bfv_vec.decrypt(secret_key)
assert decrypted_vec == plain_vec, "Decryption of vector is incorrect."
def test_radd_plain(context, vec1, vec2):
first_vec = ts.bfv_vector(context, vec1)
result = vec2 + first_vec
if isinstance(vec2, list):
expected = [v1 + v2 for v1, v2 in zip(vec1, vec2)]
elif isinstance(vec2, (float, int)):
expected = [v1 + vec2 for v1 in vec1]
# Decryption
decrypted_result = result.decrypt()
assert decrypted_result == expected, "Addition of vectors is incorrect."
assert first_vec.decrypt() == vec1, "Something went wrong in memory."
def test_add_plain_inplace(context, vec1, vec2):
first_vec = ts.bfv_vector(context, vec1)
second_vec = vec2
first_vec += second_vec
if isinstance(vec2, list):
expected = [v1 + v2 for v1, v2 in zip(vec1, vec2)]
elif isinstance(vec2, (float, int)):
expected = [v1 + vec2 for v1 in vec1]
# Decryption
decrypted_result = first_vec.decrypt()
assert decrypted_result == expected, "Addition of vectors is incorrect."
def test_add_plain_inplace(vec1, vec2, duplicate):
context = bfv_context()
first_vec = ts.bfv_vector(context, vec1)
second_vec = vec2
first_vec += second_vec
first_vec = duplicate(first_vec)
expected = [v1 + v2 for v1, v2 in zip(vec1, vec2)]
# Decryption
decrypted_result = first_vec.decrypt()
assert decrypted_result == expected, "Addition of vectors is incorrect."
def test_mul_plain(context, vec1, vec2):
first_vec = ts.bfv_vector(context, vec1)
second_vec = vec2
result = first_vec * second_vec
if isinstance(vec2, list):
expected = [v1 * v2 for v1, v2 in zip(vec1, vec2)]
elif isinstance(vec2, (float, int)):
expected = [v1 * vec2 for v1 in vec1]
# Decryption
decrypted_result = result.decrypt()
assert decrypted_result == expected, "Multiplication of vectors is incorrect."
assert first_vec.decrypt() == vec1, "Something went wrong in memory."
def test_add_plain(vec1, vec2, duplicate):
context = bfv_context()
first_vec = ts.bfv_vector(context, vec1)
first_vec = duplicate(first_vec)
second_vec = vec2
result = first_vec + second_vec
result = duplicate(result)
expected = [v1 + v2 for v1, v2 in zip(vec1, vec2)]
# Decryption
decrypted_result = result.decrypt()
assert decrypted_result == expected, "Addition of vectors is incorrect."
assert first_vec.decrypt() == vec1, "Something went wrong in memory."
def test_pack_bfv_vectors(vectors_nb, vector_size):
context = ts.context(ts.SCHEME_TYPE.BFV, 8192, 1032193)
# generated galois keys in order to do rotation on ciphertext vectors
context.generate_galois_keys()
# generate vectors
vectors = [
np.random.randint(1000, size=vector_size).tolist()
for _ in range(vectors_nb)
]
enc_vectors = [ts.bfv_vector(context, v) for v in vectors]
packed_vec = ts.pack_vectors(enc_vectors)
result = packed_vec.decrypt()
expected = reduce(lambda x, y: x + y, vectors, [])
assert almost_equal(result, expected,
1), "packing BFV vectors is incorrect."
def test_seal_context_bindings():
context = ts.context(ts.SCHEME_TYPE.BFV, 8192, 1032193)
bfv_vec = ts.bfv_vector(context, [1, 2, 3, 4])
assert context.public_key().data is not None
assert (
context.public_key().data.data().poly_modulus_degree() == context.
seal_context().data.key_context_data().parms().poly_modulus_degree())
assert context.secret_key().data is not None
assert context.secret_key().data.data().coeff_count() == 5 * 8192
decryptor = context.decryptor().data
noise_budget = decryptor.invariant_noise_budget(bfv_vec.ciphertext()[0])
bfv_vec *= bfv_vec
new_noise_budget = decryptor.invariant_noise_budget(
bfv_vec.ciphertext()[0])
assert noise_budget > new_noise_budget
