def test_lwe_noiseless_trivial_broadcast(thread, src_len): params = NuFHEParameters() lwe_size = params.in_out_params.size res_shape = (10, 20) src_shape = res_shape[len(res_shape)-src_len:] res_a = numpy.empty(res_shape + (lwe_size,), Torus32) res_b = numpy.empty(res_shape, Torus32) res_cv = numpy.empty(res_shape, ErrorFloat) mus = get_test_array(src_shape, Torus32) shape_info = LweSampleArrayShapeInfo(res_a, res_b, res_cv) test = LweNoiselessTrivial(shape_info, src_shape).compile(thread) ref = LweNoiselessTrivialReference(shape_info, src_shape) res_a_dev = thread.empty_like(res_a) res_b_dev = thread.empty_like(res_b) res_cv_dev = thread.empty_like(res_cv) mus_dev = thread.to_device(mus) test(res_a_dev, res_b_dev, res_cv_dev, mus_dev) ref(res_a, res_b, res_cv, mus) assert (res_a_dev.get() == res_a).all() assert (res_b_dev.get() == res_b).all() assert errors_allclose(res_cv_dev.get(), res_cv)
def test_shift_torus_polynomial(thread, option): polynomial_degree = 16 shape = (20, 30) powers_shape = (20, 10) if option == 'powers_view' else (20, ) powers_idx = 5 # not used unless `option == 'powers_view'` source = get_test_array(shape + (polynomial_degree, ), Torus32) powers = get_test_array(powers_shape, Int32, (0, 2 * polynomial_degree)) result = numpy.empty_like(source) source_dev = thread.to_device(source) powers_dev = thread.to_device(powers) result_dev = thread.empty_like(result) options = {option: True} comp = ShiftTorusPolynomial(polynomial_degree, shape, powers_shape, **options).compile(thread) ref = ShiftTorusPolynomialReference(polynomial_degree, shape, powers_shape, **options) comp(result_dev, source_dev, powers_dev, powers_idx) result_test = result_dev.get() ref(result, source, powers, powers_idx) assert errors_allclose(result_test, result)
def test_lwe_noiseless_trivial_constant(thread): params = NuFHEParameters() lwe_size = params.in_out_params.size shape = (10, 20) res_a = numpy.empty(shape + (lwe_size,), Torus32) res_b = numpy.empty(shape, Torus32) res_cv = numpy.empty(shape, ErrorFloat) mu = Torus32(-5) shape_info = LweSampleArrayShapeInfo(res_a, res_b, res_cv) test = LweNoiselessTrivialConstant(shape_info).compile(thread) ref = LweNoiselessTrivialConstantReference(shape_info) res_a_dev = thread.empty_like(res_a) res_b_dev = thread.empty_like(res_b) res_cv_dev = thread.empty_like(res_cv) test(res_a_dev, res_b_dev, res_cv_dev, mu) ref(res_a, res_b, res_cv, mu) assert (res_a_dev.get() == res_a).all() assert (res_b_dev.get() == res_b).all() assert errors_allclose(res_cv_dev.get(), res_cv)
def test_tlwe_encrypt_zero(thread): nufhe_params = NuFHEParameters() perf_params = PerformanceParameters(nufhe_params) params = nufhe_params.tgsw_params.tlwe_params mask_size = params.mask_size polynomial_degree = params.polynomial_degree noise = params.min_noise shape = (3, 4, 5) result_a = numpy.empty(shape + (mask_size + 1, polynomial_degree), Torus32) result_cv = numpy.empty(shape, ErrorFloat) noises1 = get_test_array(shape + (mask_size, polynomial_degree), Torus32) noises2 = get_test_array(shape + (polynomial_degree, ), Torus32) key = get_test_array((mask_size, polynomial_degree), Int32, (0, 2)) test = TLweEncryptZero(params, shape, noise, perf_params).compile(thread) ref = TLweEncryptZeroReference(params, shape, noise, perf_params) result_a_dev = thread.empty_like(result_a) result_cv_dev = thread.empty_like(result_cv) noises1_dev = thread.to_device(noises1) noises2_dev = thread.to_device(noises2) key_dev = thread.to_device(key) test(result_a_dev, result_cv_dev, key_dev, noises1_dev, noises2_dev) ref(result_a, result_cv, key, noises1, noises2) result_a_test = result_a_dev.get() result_cv_test = result_cv_dev.get() assert (result_a_test == result_a).all() assert errors_allclose(result_cv_test, result_cv)
def test_tlwe_noiseless_trivial(thread): shape = (2, 5) params = NuFHEParameters().tgsw_params.tlwe_params mask_size = params.mask_size polynomial_degree = params.polynomial_degree mu = get_test_array(shape + (polynomial_degree, ), Torus32) a = numpy.empty(shape + (mask_size + 1, polynomial_degree), Torus32) cv = numpy.empty(shape, ErrorFloat) a_dev = thread.empty_like(a) cv_dev = thread.empty_like(cv) mu_dev = thread.to_device(mu) test = TLweNoiselessTrivial(params, shape).compile(thread) ref = TLweNoiselessTrivialReference(params, shape) test(a_dev, cv_dev, mu_dev) a_test = a_dev.get() cv_test = cv_dev.get() ref(a, cv, mu) assert (a_test == a).all() assert errors_allclose(cv_test, cv)
def test_lwe_keyswitch(thread): batch_shape = (4, 5) params = NuFHEParameters() input_size = params.tgsw_params.tlwe_params.extracted_lweparams.size output_size = params.in_out_params.size decomp_length = params.ks_decomp_length log2_base = params.ks_log2_base base = 2**log2_base result_a = numpy.empty(batch_shape + (output_size, ), Torus32) result_b = numpy.empty(batch_shape, Torus32) result_cv = numpy.empty(batch_shape, ErrorFloat) ks_a = get_test_array((input_size, decomp_length, base, output_size), Torus32, (-1000, 1000)) ks_b = get_test_array((input_size, decomp_length, base), Torus32, (-1000, 1000)) ks_cv = get_test_array((input_size, decomp_length, base), ErrorFloat, (-1, 1)) # The base=0 slice of the keyswitch key is a "padding" - it's filled with zeroes. # The keyswitch function may rely on that. ks_a[:, :, 0, :] = 0 ks_b[:, :, 0] = 0 ks_cv[:, :, 0] = 0 source_a = get_test_array(batch_shape + (input_size, ), Torus32) source_b = get_test_array(batch_shape, Torus32, (-1000, 1000)) result_a_dev = thread.empty_like(result_a) result_b_dev = thread.empty_like(result_b) result_cv_dev = thread.empty_like(result_cv) ks_a_dev = thread.to_device(ks_a) ks_b_dev = thread.to_device(ks_b) ks_cv_dev = thread.to_device(ks_cv) source_a_dev = thread.to_device(source_a) source_b_dev = thread.to_device(source_b) shape_info = LweSampleArrayShapeInfo(result_a_dev, result_b_dev, result_cv_dev) test = LweKeyswitch(shape_info, input_size, output_size, decomp_length, log2_base).compile(thread) ref = LweKeyswitchReference(shape_info, input_size, output_size, decomp_length, log2_base) test(result_a_dev, result_b_dev, result_cv_dev, ks_a_dev, ks_b_dev, ks_cv_dev, source_a_dev, source_b_dev) result_a_test = result_a_dev.get() result_b_test = result_b_dev.get() result_cv_test = result_cv_dev.get() ref(result_a, result_b, result_cv, ks_a, ks_b, ks_cv, source_a, source_b) assert (result_a == result_a_test).all() assert (result_b == result_b_test).all() assert errors_allclose(result_cv, result_cv_test)
def test_make_lwe_keyswitch_key(thread): params = NuFHEParameters() input_size = params.tgsw_params.tlwe_params.extracted_lweparams.size output_size = params.in_out_params.size decomp_length = params.ks_decomp_length log2_base = params.ks_log2_base base = 2**log2_base noise = params.in_out_params.min_noise ks_a = numpy.empty((input_size, decomp_length, base, output_size), dtype=Torus32) ks_b = numpy.empty((input_size, decomp_length, base), dtype=Torus32) ks_cv = numpy.empty((input_size, decomp_length, base), dtype=ErrorFloat) in_key = get_test_array(input_size, Int32, (0, 2)) out_key = get_test_array(output_size, Int32, (0, 2)) noises_a = get_test_array( (input_size, decomp_length, base - 1, output_size), Torus32) noises_b = double_to_t32( get_test_array((input_size, decomp_length, base - 1), ErrorFloat, (-noise, noise))) test = MakeLweKeyswitchKey(input_size, output_size, decomp_length, log2_base, noise).compile(thread) ref = MakeLweKeyswitchKeyReference(input_size, output_size, decomp_length, log2_base, noise) ks_a_dev = thread.empty_like(ks_a) ks_b_dev = thread.empty_like(ks_b) ks_cv_dev = thread.empty_like(ks_cv) in_key_dev = thread.to_device(in_key) out_key_dev = thread.to_device(out_key) noises_a_dev = thread.to_device(noises_a) noises_b_dev = thread.to_device(noises_b) test(ks_a_dev, ks_b_dev, ks_cv_dev, in_key_dev, out_key_dev, noises_a_dev, noises_b_dev) ref(ks_a, ks_b, ks_cv, in_key, out_key, noises_a, noises_b) ks_a_test = ks_a_dev.get() ks_b_test = ks_b_dev.get() ks_cv_test = ks_cv_dev.get() assert (ks_a_test == ks_a).all() assert (ks_b_test == ks_b).all() assert errors_allclose(ks_cv_test, ks_cv)
def test_lwe_linear_broadcast(thread): params = NuFHEParameters() lwe_size = params.in_out_params.size res_shape = (10, 20) src_shape = res_shape[1:] res_a = get_test_array(res_shape + (lwe_size, ), Torus32) res_b = get_test_array(res_shape, Torus32) res_cv = get_test_array(res_shape, ErrorFloat, (-1, 1)) src_a = get_test_array(src_shape + (lwe_size, ), Torus32) src_b = get_test_array(src_shape, Torus32) src_cv = get_test_array(src_shape, ErrorFloat, (-1, 1)) coeff = 1 add_result = True res_shape_info = LweSampleArrayShapeInfo(res_a, res_b, res_cv) src_shape_info = LweSampleArrayShapeInfo(src_a, src_b, src_cv) test = LweLinear(res_shape_info, src_shape_info, add_result=add_result).compile(thread) ref = LweLinearReference(res_shape_info, src_shape_info, add_result=add_result) res_a_dev = thread.to_device(res_a) res_b_dev = thread.to_device(res_b) res_cv_dev = thread.to_device(res_cv) src_a_dev = thread.to_device(src_a) src_b_dev = thread.to_device(src_b) src_cv_dev = thread.to_device(src_cv) thread.synchronize() test(res_a_dev, res_b_dev, res_cv_dev, src_a_dev, src_b_dev, src_cv_dev, coeff) ref(res_a, res_b, res_cv, src_a, src_b, src_cv, coeff) assert (res_a_dev.get() == res_a).all() assert (res_b_dev.get() == res_b).all() assert errors_allclose(res_cv_dev.get(), res_cv)
def test_t32_to_phase(thread): mspace_size = 2048 shape = (10, 20, 30) phase = get_test_array(shape, Torus32) result = numpy.empty(shape, Int32) phase_dev = thread.to_device(phase) result_dev = thread.empty_like(result) comp = Torus32ToPhase(shape, mspace_size).compile(thread) ref = Torus32ToPhaseReference(shape, mspace_size) comp(result_dev, phase_dev) result_test = result_dev.get() ref(result, phase) assert errors_allclose(result_test, result)
def test_lwe_encrypt(thread): params = NuFHEParameters() lwe_size = params.in_out_params.size noise = params.in_out_params.min_noise shape = (16, 20) result_a = numpy.empty(shape + (lwe_size,), Torus32) result_b = numpy.empty(shape, Torus32) result_cv = numpy.empty(shape, ErrorFloat) key = get_test_array(lwe_size, Int32, (0, 2)) messages = get_test_array(shape, Torus32) noises_a = get_test_array(shape + (lwe_size,), Torus32) noises_b = get_test_array(shape, Torus32) test = LweEncrypt(shape, lwe_size, noise).compile(thread) ref = LweEncryptReference(shape, lwe_size, noise) result_a_dev = thread.empty_like(result_a) result_b_dev = thread.empty_like(result_b) result_cv_dev = thread.empty_like(result_cv) key_dev = thread.to_device(key) messages_dev = thread.to_device(messages) noises_a_dev = thread.to_device(noises_a) noises_b_dev = thread.to_device(noises_b) test( result_a_dev, result_b_dev, result_cv_dev, messages_dev, key_dev, noises_a_dev, noises_b_dev) ref(result_a, result_b, result_cv, messages, key, noises_a, noises_b) result_a_test = result_a_dev.get() result_b_test = result_b_dev.get() result_cv_test = result_cv_dev.get() assert (result_a_test == result_a).all() assert (result_b_test == result_b).all() assert errors_allclose(result_cv_test, result_cv)