def main(): if mpc.args: n = int(mpc.args[0]) else: n = 5 print('Setting input to default =', n) s = [(-1)**i * (i + (n//2))**2 for i in range(n)] mpc.start() global secnum secnum = mpc.SecInt() print('Using secure integers:', secnum) x = list(map(secnum, s)) print('Array:', mpc.run(mpc.output(x))) print('Sorted array:', mpc.run(mpc.output(bsort(x)))) secnum = mpc.SecFxp() print('Using secure fixed-point numbers:', secnum) x = list(map(secnum, s)) print('Input array:', mpc.run(mpc.output(x))) print('Sorted array:', mpc.run(mpc.output(bsort(x)))) mpc.shutdown()
def main(): if not mpc.args: m = 8 print('Setting input to default =', m) else: m = int(mpc.args[0]) mpc.start() secfld = mpc.SecFld(l=max(len(mpc.parties), (m - 1)).bit_length() + 1) print('Using secure fields:', secfld) for n in range(2, m + 1): print(n, mpc.run(mpc.output(random_derangement(n, secfld)))) secint = mpc.SecInt() print('Using secure integers:', secint) for n in range(2, m + 1): print(n, mpc.run(mpc.output(random_derangement(n, secint)))) secfxp = mpc.SecFxp() print('Using secure fixed-point numbers:', secfxp) for n in range(2, m + 1): print(n, mpc.run(mpc.output(random_derangement(n, secfxp)))) mpc.shutdown()
def test_secint(self): secint = mpc.SecInt() y = [1, 3, -2, 3, 1, -2, -2, 4] * 5 random.shuffle(y) x = list(map(secint, y)) self.assertEqual(mpc.run(mpc.output(mean(x))), round(statistics.mean(y))) self.assertEqual(mpc.run(mpc.output(variance(x))), round(statistics.variance(y))) self.assertEqual(mpc.run(mpc.output(variance(x, mean(x)))), round(statistics.variance(y))) self.assertEqual(mpc.run(mpc.output(stdev(x))), round(statistics.stdev(y))) self.assertEqual(mpc.run(mpc.output(pvariance(x))), round(statistics.pvariance(y))) self.assertEqual(mpc.run(mpc.output(pstdev(x))), round(statistics.pstdev(y))) self.assertEqual(mpc.run(mpc.output(mode(x))), round(statistics.mode(y))) self.assertEqual(mpc.run(mpc.output(median(x))), round(statistics.median(y))) self.assertEqual(mpc.run(mpc.output(median_low(x))), round(statistics.median_low(y))) self.assertEqual(mpc.run(mpc.output(median_high(x))), round(statistics.median_high(y)))
def test_qsecfld(self): secfld = mpc.SecFld(7**3) a = secfld(1) b = secfld(0) self.assertEqual(mpc.run(mpc.output(+a)), 1) self.assertNotEqual(id(a), id(+a)) # NB: +a creates a copy self.assertEqual(mpc.run(mpc.output(a + b)), 1) self.assertEqual(mpc.run(mpc.output(a * b)), 0)
def test_async(self): mpc.options.no_async = False a = mpc.SecInt()(7) b = a * a mpc.run(mpc.barrier()) self.assertEqual(mpc.run(mpc.output(b)), 49) self.assertEqual(mpc.run(mpc.output(mpc.scalar_mul(a, [-a, a]))), [-49, 49]) mpc.options.no_async = True
def test_secfxp(self): secfxp = mpc.SecFxp() a = getrandbits(secfxp, 10) self.assertTrue(a.integral) a = mpc.run(mpc.output(a)) self.assertGreaterEqual(int(a), 0) self.assertLessEqual(int(a), 2**10 - 1) x = mpc.run(mpc.output(random_unit_vector(secfxp, 6))) self.assertEqual(int(sum(x)), 1) x = mpc.run(mpc.output(random_permutation(secfxp, range(1, 9)))) self.assertSetEqual(set(range(1, 9)), set(map(int, x))) x = mpc.run(mpc.output(random_derangement(secfxp, [0.0, 1.0]))) self.assertListEqual([1, 0], list(map(int, x))) a = mpc.run(mpc.output(choice(secfxp, [0.8, 0.9, 1.0, 1.1, 1.2]))) self.assertAlmostEqual(float(a), 1.0, 0) a = mpc.run(mpc.output(choice(secfxp, [0.08, 0.09, 0.1, 0.11, 0.12]))) self.assertAlmostEqual(float(a), 0.1, 1) a = mpc.run(mpc.output(random(secfxp))) self.assertGreaterEqual(float(a), 0) self.assertLessEqual(float(a), 1) a = mpc.run(mpc.output(uniform(secfxp, 13.13, 13.17))) self.assertGreaterEqual(float(a), 13.13) self.assertLessEqual(float(a), 13.17) a = mpc.run(mpc.output(uniform(secfxp, -13.13, -13.17))) self.assertGreaterEqual(float(a), -13.17) self.assertLessEqual(float(a), -13.13)
def test_Cl(self): Cl23 = fg.ClassGroup(Delta=-23) secgrp = mpc.SecGrp(Cl23) secint = secgrp.sectype g = Cl23.generator self.assertFalse(mpc.run(mpc.output(secgrp(g) != g))) self.assertEqual(mpc.run(secgrp.repeat_public(g, -secint(2))), g) self.assertEqual(mpc.run(mpc.output(g**secint(-2))), g) self.assertEqual(mpc.run(mpc.output(g * secgrp(g))), Cl23((2, -1, 3))) Cl227 = fg.ClassGroup(Delta=-227) # Example 9.6.2 from Buchman&Vollmer secgrp = mpc.SecGrp(Cl227) g = Cl227((3, 1, 19)) self.assertEqual(mpc.run(mpc.output(secgrp(g) ^ 5)), g ^ 5) Cl1123 = fg.ClassGroup( Delta=-1123) # Example 9.7.5 from Buchman&Vollmer secgrp = mpc.SecGrp(Cl1123) self.assertEqual(Cl1123((1, 1, 281)), Cl1123.identity) g = Cl1123((7, 5, 41)) self.assertEqual(mpc.run(mpc.output(secgrp(g) ^ 5)), g ^ 5) self.assertEqual(mpc.run(mpc.output(secgrp(g)**3)), g ^ 3) group = fg.ClassGroup(l=28) secgrp = mpc.SecGrp(group) g = group.generator a = secgrp(g) ^ 6 self.assertEqual(mpc.run(mpc.output(a)), g ^ 6) self.assertEqual(mpc.run(mpc.output(a * (a ^ -1))), group.identity) m, z = group.encode(5) self.assertEqual( mpc.run(mpc.output(secgrp.decode(secgrp(m), secgrp(z)))), 5) self.assertRaises(ValueError, secgrp, [0])
def test_secfxp(self): secfxp = mpc.SecFxp() s = seclist([5, -3, 2, 5, 5], secfxp) self.assertFalse(mpc.run(mpc.output(s < s))) t = s[:] t[-1] += 1 self.assertTrue(mpc.run(mpc.output(s < t))) s = [[1, 0], [0, 1], [0, 0], [1, 1]] ss = mpc.sorted([[secfxp(a) for a in _] for _ in s], key=seclist) self.assertEqual([mpc.run(mpc.output(_)) for _ in ss], sorted(s))
def test_secfld(self): secfld = mpc.SecFld() self.assertEqual(secfld.field.modulus, 2) secfld = mpc.SecFld(l=16) a = secfld(1) b = secfld(0) self.assertEqual(mpc.run(mpc.output(a + b)), 1) self.assertEqual(mpc.run(mpc.output(a * b)), 0) secfld = mpc.SecFld(101) a = secfld(1) b = secfld(-1) self.assertEqual(mpc.run(mpc.output(a + b)), 0) self.assertEqual(mpc.run(mpc.output(a * b)), 100) self.assertEqual(mpc.run(mpc.output(a == b)), 0) self.assertEqual(mpc.run(mpc.output(a == -b)), 1) self.assertEqual(mpc.run(mpc.output(a**2 == b**2)), 1) self.assertEqual(mpc.run(mpc.output(a != b)), 1) with self.assertRaises(TypeError): a < b with self.assertRaises(TypeError): a <= b with self.assertRaises(TypeError): a > b with self.assertRaises(TypeError): a >= b
def test_convert(self): secint = mpc.SecInt() secint8 = mpc.SecInt(8) secint16 = mpc.SecInt(16) secfld257 = mpc.SecFld(257) secfld263 = mpc.SecFld(263) secfxp = mpc.SecFxp() secfxp16 = mpc.SecFxp(16) x = [secint8(-100), secint8(100)] y = mpc.convert(x, secint) self.assertEqual(mpc.run(mpc.output(y)), [-100, 100]) y = mpc.convert(y, secint8) self.assertEqual(mpc.run(mpc.output(y)), [-100, 100]) x = [secint16(i) for i in range(10)] y = mpc.convert(x, secfld257) self.assertEqual(mpc.run(mpc.output(y)), list(range(10))) x = [secfld257(i) for i in range(10)] y = mpc.convert(x, secfld263) self.assertEqual(mpc.run(mpc.output(y)), list(range(10))) x = [secint(-100), secint(100)] y = mpc.convert(x, secfxp) self.assertEqual(mpc.run(mpc.output(y)), [-100, 100]) y = mpc.convert(y, secint) self.assertEqual(mpc.run(mpc.output(y)), [-100, 100]) x = [secfxp16(-100.25), secfxp16(100.875)] y = mpc.convert(x, secfxp) self.assertEqual(mpc.run(mpc.output(y)), [-100.25, 100.875]) y = mpc.convert(y, secfxp16) self.assertEqual(mpc.run(mpc.output(y)), [-100.25, 100.875])
def test_secfld(self): secfld = mpc.SecFld(101) s = seclist([], secfld) self.assertEqual(s, []) s = seclist(sectype=secfld) self.assertEqual(s, []) s.append(False) s.append(secfld(100)) s[1:2] = (1, ) s += [2, 3] s.reverse() s = [5, 4] + s s.reverse() s = s + [6, 7] del s[0] s.remove(4) s[5] = 9 del s[2:4] self.assertEqual(mpc.run(mpc.output(list(s))), [1, 2, 6, 9]) secfld2 = mpc.SecFld() self.assertRaises(TypeError, seclist, [secfld(1)], secfld2) self.assertRaises(ValueError, seclist, []) self.assertRaises(TypeError, operator.add, seclist([secfld(1)]), seclist([secfld2(1)]))
async def main(): await mpc.start() print(f"One 64-byte block of ChaCha20 with input 0, key 0, nonce 0\n") print("initializing ...".ljust(32), end='', flush=True) t1 = time.perf_counter() constant[0] = secint.field(1634760805) constant[1] = secint.field(857760878) constant[2] = secint.field(2036477234) constant[3] = secint.field(1797285236) key = [mpc.input(secint(0))[0] for _ in range(8)] nonce = [mpc.input(secint(0))[0] for _ in range(2)] inp = [mpc.input(secint(0))[0] for _ in range(16)] t2 = time.perf_counter() print(f"{(t2 - t1):.5} seconds") print("encrypting ...".ljust(32), end='', flush=True) t1 = time.perf_counter() code(key, nonce, inp) res = await (mpc.output(inp)) t2 = time.perf_counter() print(f"{(t2 - t1):.5} seconds") print("\nchecking ...".ljust(32), end='', flush=True) assert res == vec, f"{res} != {vec}" print("ok!") await mpc.shutdown()
def test_QR_SG(self): for group in fg.QuadraticResidues(l=768), fg.SchnorrGroup(l=768): secgrp = mpc.SecGrp(group) g = group.generator g2 = mpc.run(mpc.output(secgrp(g) * g)) self.assertEqual(int(g), int(group.identity * g)) self.assertFalse( mpc.run(mpc.output(secgrp(g) / g != group.identity))) self.assertTrue(mpc.run(mpc.output(g * secgrp(g) == g2))) secfld = mpc.SecFld(modulus=secgrp.group.order) self.assertEqual(mpc.run(mpc.output(secgrp.repeat(g, -secfld(2)))), 1 / g2) self.assertEqual(mpc.run(mpc.output(secgrp.repeat(secgrp(g), 2))), g2) m, z = group.encode(15) self.assertEqual( mpc.run(mpc.output(secgrp.decode(secgrp(m), secgrp(z)))), 15) h = secgrp.if_else(secgrp.sectype(0), g, secgrp(g2)) self.assertEqual(mpc.run(mpc.output(h)), g2) a = secgrp(g) self.assertRaises(TypeError, operator.truediv, 2, a) self.assertRaises(TypeError, operator.add, a, a) self.assertRaises(TypeError, operator.add, g, a) self.assertRaises(TypeError, operator.neg, a) self.assertRaises(TypeError, operator.sub, a, a) self.assertRaises(TypeError, operator.sub, g, a)
def test_empty_input(self): secint = mpc.SecInt() self.assertEqual(mpc.run(mpc.gather([])), []) self.assertEqual(mpc.run(mpc.output([])), []) self.assertEqual(mpc._reshare([]), []) self.assertEqual(mpc.convert([], None), []) self.assertEqual(mpc.sum([]), 0) self.assertEqual(mpc.sum([], start=1), 1) self.assertEqual(mpc.run(mpc.output(mpc.sum([], start=secint(1)))), 1) self.assertEqual(mpc.prod([]), 1) self.assertEqual(mpc.all([]), 1) self.assertEqual(mpc.any([]), 0) self.assertEqual(mpc.in_prod([], []), 0) self.assertEqual(mpc.vector_add([], []), []) self.assertEqual(mpc.vector_sub([], []), []) self.assertEqual(mpc.scalar_mul(secint(0), []), []) self.assertEqual(mpc.schur_prod([], []), []) self.assertEqual(mpc.from_bits([]), 0)
def test_accumulate(self): secint = mpc.SecInt() r = range(1, 9) x = [secint(i) for i in r] for acc in itertools.accumulate, mpyc.mpctools.accumulate: self.assertEqual(mpc.run(mpc.output(list(acc(x)))), list(itertools.accumulate(r))) self.assertEqual(mpc.run(mpc.output(list(acc(x, mpc.mul)))), list(itertools.accumulate(r, operator.mul))) self.assertEqual(mpc.run(mpc.output(list(acc(x, mpc.min)))), list(itertools.accumulate(r, min))) self.assertEqual(mpc.run(mpc.output(list(acc(x, mpc.max)))), list(itertools.accumulate(r, max))) a = secint(10) self.assertEqual( mpc.run( mpc.output( list(acc(itertools.repeat(a, 5), mpc.mul, secint(1))))), [1, 10, 10**2, 10**3, 10**4, 10**5])
def test_pickle(self): xsecfld = mpc.SecFld(256) psecfld = mpc.SecFld(257) secint = mpc.SecInt() secfxp = mpc.SecFxp() # NB: mpc.transfer() calls pickle.dumps() and pickle.loads() self.assertEqual( mpc.run(mpc.output(mpc.run(mpc.transfer(xsecfld(12), senders=0)))), 12) self.assertEqual( mpc.run(mpc.output(mpc.run(mpc.transfer(psecfld(12), senders=0)))), 12) self.assertEqual( mpc.run(mpc.output(mpc.run(mpc.transfer(secint(12), senders=0)))), 12) self.assertEqual( mpc.run(mpc.output(mpc.run(mpc.transfer(secfxp(12.5), senders=0)))), 12.5) self.assertEqual(mpc.run(mpc.transfer(xsecfld.field(12), senders=0)), 12) self.assertEqual(mpc.run(mpc.transfer(psecfld.field(12), senders=0)), 12) self.assertEqual(mpc.run(mpc.transfer(secint.field(12), senders=0)), 12) self.assertEqual(mpc.run(mpc.transfer(secfxp.field(13), senders=0)), 13) self.assertEqual(mpc.run(mpc.transfer(xsecfld.field.modulus, 0)), xsecfld.field.modulus) x = [(xsecfld(12), psecfld(12), secint(12), secfxp(12.5)), [ xsecfld.field(12), psecfld.field(12), secint.field(12), secfxp.field(13) ], xsecfld.field.modulus] y = mpc.run(mpc.transfer(x, senders=0)) self.assertTrue( all(mpc.run(mpc.output(a == b)) for a, b in zip(y[0], x[0]))) self.assertEqual(y[1], x[1]) self.assertEqual(y[2], x[2])
def test_secfld(self): secfld = mpc.SecFld(101) s = seclist([], secfld) self.assertEqual(s, []) s = seclist(sectype=secfld) self.assertEqual(s, []) s.append(False) s.append(secfld(100)) s[1:2] = (1, ) s += [2, 3] s.reverse() s = [5, 4] + s s.reverse() s = s + [6, 7] del s[0] self.assertEqual(mpc.run(mpc.output(list(s))), [1, 2, 3, 4, 5, 6, 7])
def test_reduce(self): secint = mpc.SecInt() r = range(1, 9) x = [secint(i) for i in r] y = [[secint(i)] * 2 for i in r] z = [[[secint(i)] * 2] * 2 for i in r] for red in functools.reduce, mpyc.mpctools.reduce: self.assertEqual(mpc.run(mpc.output(red(mpc.add, x))), 36) self.assertEqual(mpc.run(mpc.output(red(mpc.mul, x))), 40320) self.assertEqual(mpc.run(mpc.output(red(mpc.max, x))), 8) self.assertEqual(mpc.run(mpc.output(red(mpc.min, x, secint(0)))), 0) self.assertEqual(mpc.run(mpc.output(red(mpc.max, x, secint(10)))), 10) self.assertEqual(mpc.run(mpc.output(red(mpc.vector_add, y))), [36] * 2) self.assertEqual(mpc.run(mpc.output(red(mpc.schur_prod, y))), [40320] * 2) self.assertEqual(mpc.run(mpc.output(red(mpc.matrix_add, z)[0])), [36] * 2) self.assertEqual(mpc.run(mpc.output(red(mpc.matrix_prod, z)[1])), [5160960] * 2)
def test_Sn(self): group = fg.SymmetricGroup(5) a = group([3, 4, 2, 1, 0]) b = a @ a secgrp = mpc.SecGrp(group) c = secgrp(a) d = a @ c self.assertEqual(mpc.run(mpc.output(d)), b) e = ~c f = e @ b self.assertEqual(mpc.run(mpc.output(f)), a) self.assertTrue(mpc.run(mpc.output(f == c))) group = fg.SymmetricGroup(11) secgrp = mpc.SecGrp(group) a = group([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0]) secfld = mpc.SecFld(11) # ord(a) = 11 a7 = secgrp.repeat(a, secfld(7)) self.assertEqual(mpc.run(mpc.output(a7)), a ^ 7) a7 = secgrp.repeat_public(a, secfld(7)) self.assertEqual(mpc.run(a7), a ^ 7) a6 = a ^ 6 a12 = a6 @ a6 self.assertEqual(mpc.run(mpc.output(secgrp(a6).inverse())), a ^ 5) self.assertEqual( mpc.run(mpc.output((secgrp(a) ^ 6) @ secgrp.identity)), a6) self.assertEqual(mpc.run(mpc.output(secgrp.repeat(a6, secfld(2)))), a12) self.assertEqual( mpc.run(mpc.output(secgrp.repeat(secgrp(a), secfld(6)))), a6) p = secgrp(a) self.assertRaises(TypeError, operator.add, p, p) self.assertRaises(TypeError, operator.mul, p, p) self.assertRaises(TypeError, operator.mul, 1, p) group.is_multiplicative = True self.assertTrue(mpc.run(mpc.output(a * p == a ^ 2))) group.is_multiplicative = False self.assertRaises(ValueError, secgrp, [0, 1, 2, 3])
def calculate_se(label): # square error #print("label:", label) new_list = label.values.tolist() #print("new list:", new_list) if len(new_list) > 0: mean_value = mean(new_list) #mean = label.mean() se = secnum(0) #for y in label: #se += (y - mean) * (y - mean) for ele in new_list: tmp = mpc.sub(ele, mean_value) tmp = mpc.mul(tmp, tmp) se = mpc.add(se, tmp) return mpc.run(mpc.output(se)) # should return cipher, deal it lator; else: return 0
def main(): data = pd.read_csv(DATA_PATH) mpc.run(mpc.start()) n = len(mpc.parties) s = [secint(x) for x in range(1, 11)] samples = [] for j in range(20): #s = [secint(x) for x in range(1, n + 1)] print("Iteration: %d, Sample %d" % (n, j)) start = time.time() mpc.run(mpc.output(many_secure_mul(s, 100))) end = time.time() samples.append(end - start) mpc.run(mpc.shutdown()) avg = np.average(samples) data.loc[data.shape[0]] = [n, avg] data.to_csv(DATA_PATH, index=False) return 0
Run with m parties to compute: - m = sum_{i=0}^{m-1} 1 = sum(1 for i in range(m)) - m**2 = sum_{i=0}^{m-1} 2i+1 = sum(2*i+1 for i in range(m)) - 2**m = prod_{i=0}^{m-1} 2 = prod(2 for i in range(m)) - m! = prod_{i=0}^{m-1} i+1 = prod(i+1 for i in range(m)) Bit lengths of secure integers ensure each result fits for any m >= 1. """ from mpyc.runtime import mpc m = len(mpc.parties) l = m.bit_length() mpc.run(mpc.start()) print('m =', mpc.run(mpc.output(mpc.sum(mpc.input(mpc.SecInt(l + 1)(1)))))) print( 'm**2 =', mpc.run( mpc.output(mpc.sum(mpc.input(mpc.SecInt(2 * l + 1)(2 * mpc.pid + 1)))))) print('2**m =', mpc.run(mpc.output(mpc.prod(mpc.input(mpc.SecInt(m + 2)(2)))))) print( 'm! =', mpc.run( mpc.output( mpc.prod(mpc.input( mpc.SecInt(int(m * (l - 1.4) + 3))(mpc.pid + 1)))))) mpc.run(mpc.shutdown())
# computes a database join function (sums by category) # this code is written as a script, so we call mpc.run() on each individual mpc operation instead of # calling it once on the whole operation as in mult3, innerprod # # this code was contributed by Berry Schoenmakers via private correspondence # from mpyc.runtime import mpc from mpyc.seclists import seclist secint = mpc.SecInt() N = 25 # number of samples C = 4 # number of categories # deterministic input data # (no mpc.input to assign different inputs to different parties) categories = [(secint(i), secint(i % C)) for i in range(N)] values = [(secint(i), secint(i)) for i in range(N)] mpc.run(mpc.start()) s = seclist([0] * C, secint) for i, c in categories: for j, v in values: s[c] += mpc.if_else(i == j, v, 0) print(mpc.run(mpc.output(list(s)))) mpc.run(mpc.shutdown())
def test_misc(self): secint = mpc.SecInt() secfxp = mpc.SecFxp() secfld = mpc.SecFld() for secnum in (secint, secfxp, secfld): self.assertEqual(type(mpc.run(mpc.output(secnum(0), raw=True))), secnum.field) self.assertEqual(mpc.run(mpc.output(mpc._reshare([secnum(0)]))), [0]) self.assertEqual( mpc.run(mpc.output(mpc.all(secnum(1) for _ in range(5)))), True) self.assertEqual( mpc.run(mpc.output(mpc.all([secnum(1), secnum(1), secnum(0)]))), False) self.assertEqual( mpc.run(mpc.output(mpc.any(secnum(0) for _ in range(5)))), False) self.assertEqual( mpc.run(mpc.output(mpc.any([secnum(0), secnum(1), secnum(1)]))), True) self.assertEqual( mpc.run(mpc.output(mpc.sum([secnum(1)], start=1))), 2) self.assertEqual( mpc.run(mpc.output(mpc.prod([secnum(1)], start=1))), 1) self.assertEqual( mpc.run(mpc.output(mpc.sum([secnum(1)], start=secnum(1)))), 2) self.assertEqual( mpc.run(mpc.output(mpc.find([secnum(1)], 0, e=-1))), -1) self.assertEqual(mpc.run(mpc.output(mpc.find([secnum(1)], 1))), 0) self.assertEqual( mpc.run(mpc.output(mpc.find([secnum(1)], 1, f=lambda i: i))), 0) self.assertEqual( mpc.run(mpc.output(mpc.min(secint(i) for i in range(-1, 2, 1)))), -1) self.assertEqual( mpc.run( mpc.output(mpc.argmin(secint(i) for i in range(-1, 2, 1))[0])), 0) self.assertEqual( mpc.run(mpc.output(mpc.max(secfxp(i) for i in range(-1, 2, 1)))), 1) self.assertEqual( mpc.run( mpc.output(mpc.argmax(secfxp(i) for i in range(-1, 2, 1))[0])), 2) self.assertEqual( mpc.run(mpc.output(list(mpc.min_max(map(secfxp, range(5)))))), [0, 4]) x = (secint(i) for i in range(-3, 3)) s = [0, -1, 1, -2, 2, -3] self.assertEqual( mpc.run(mpc.output(mpc.sorted(x, key=lambda a: a * (2 * a + 1)))), s) x = (secfxp(i) for i in range(5)) self.assertEqual(mpc.run(mpc.output(mpc.sorted(x, reverse=True))), [4, 3, 2, 1, 0]) self.assertEqual(mpc.run(mpc.output(mpc.sum(map(secint, range(5))))), 10) self.assertEqual( mpc.run(mpc.output(mpc.sum([secfxp(2.75)], start=3.125))), 5.875) self.assertEqual( int(mpc.run(mpc.output(mpc.prod(map(secfxp, range(1, 5)))))), 24) self.assertEqual( int(mpc.run(mpc.output(mpc.prod([secfxp(1.414214)] * 4)))), 4) self.assertEqual(mpc.find([], 0), 0) self.assertEqual(mpc.find([], 0, e=None), (1, 0)) self.assertEqual( mpc.run(mpc.output(list(mpc.find([secfld(1)], 1, e=None)))), [0, 0]) self.assertEqual( mpc.run(mpc.output(mpc.find([secfld(2)], 2, bits=False))), 0) x = [secint(i) for i in range(5)] f = lambda i: [i**2, 3**i] self.assertEqual(mpc.run(mpc.output(mpc.find(x, 2, bits=False, f=f))), [4, 9]) cs_f = lambda b, i: [b * (2 * i + 1) + i**2, (b * 2 + 1) * 3**i] self.assertEqual( mpc.run(mpc.output(mpc.find(x, 2, bits=False, cs_f=cs_f))), [4, 9])
def test_if_else(self): secfld = mpc.SecFld() a = secfld(0) b = secfld(1) c = secfld(1) self.assertEqual(mpc.run(mpc.output(mpc.if_else(c, a, b))), 0) self.assertEqual(mpc.run(mpc.output(mpc.if_else(1 - c, a, b))), 1) self.assertEqual(mpc.run(mpc.output(mpc.if_else(c, [a, b], [b, a]))), [0, 1]) self.assertEqual( mpc.run(mpc.output(mpc.if_else(1 - c, [a, b], [b, a]))), [1, 0]) secint = mpc.SecInt() a = secint(-1) b = secint(1) c = secint(1) self.assertEqual(mpc.run(mpc.output(mpc.if_else(c, a, b))), -1) self.assertEqual(mpc.run(mpc.output(mpc.if_else(1 - c, a, b))), 1) self.assertEqual(mpc.run(mpc.output(mpc.if_else(c, [a, b], [b, a]))), [-1, 1]) self.assertEqual( mpc.run(mpc.output(mpc.if_else(1 - c, [a, b], [b, a]))), [1, -1]) secfxp = mpc.SecFxp() a = secfxp(-1.0) b = secfxp(1.0) c = secfxp(1) self.assertEqual(mpc.run(mpc.output(mpc.if_else(c, a, b))), -1.0) self.assertEqual(mpc.run(mpc.output(mpc.if_else(1 - c, a, b))), 1.0) self.assertEqual(mpc.run(mpc.output(mpc.if_else(c, 0.0, 1.0))), 0.0) self.assertEqual(mpc.run(mpc.output(mpc.if_else(1 - c, 0.0, 1.0))), 1.0)
def test_secflt(self): secflt = mpc.SecFlt() a = secflt(1.25) b = secflt(2.5) self.assertEqual(mpc.run(mpc.output(mpc.input(a, 0))), 1.25) self.assertEqual(mpc.run(mpc.output(a + b)), 3.75) self.assertEqual(mpc.run(mpc.output(-a + -b)), -3.75) self.assertEqual(mpc.run(mpc.output(a * 2**10 + 2**10 * b)), 3.75 * 2**10) self.assertEqual(mpc.run(mpc.output(-b + b)), 0) self.assertEqual(mpc.run(mpc.output(abs(1.25 - +b))), 1.25) self.assertEqual(mpc.run(mpc.output(a * b)), 1.25 * 2.5) self.assertAlmostEqual(mpc.run(mpc.output(a / b)), 0.5, delta=2**-21) self.assertTrue(mpc.run(mpc.output(a < b))) self.assertTrue(mpc.run(mpc.output(a <= b))) self.assertFalse(mpc.run(mpc.output(a == b))) self.assertFalse(mpc.run(mpc.output(a >= b))) self.assertFalse(mpc.run(mpc.output(a > b))) self.assertTrue(mpc.run(mpc.output(a != b))) self.assertFalse(mpc.run(mpc.eq_public(a, b))) self.assertTrue(mpc.run(mpc.eq_public(a, a))) phi = secflt((math.sqrt(5) + 1) / 2) self.assertAlmostEqual(mpc.run(mpc.output(phi**2 - phi - 1)), 0, delta=2**-21) @mpc.coroutine async def nop(a) -> secflt: return a self.assertEqual(mpc.run(mpc.output(nop(a))), 1.25)
def test_secfxp(self): secfxp = mpc.SecFxp() self.assertEqual( mpc.run(mpc.output(mpc.input(secfxp(7.75), senders=0))), 7.75) c = mpc.to_bits(secfxp(0), 0) # mpc.output() only works for nonempty lists self.assertEqual(c, []) c = mpc.run(mpc.output(mpc.to_bits(secfxp(0)))) self.assertEqual(c, [0.0] * 32) c = mpc.run(mpc.output(mpc.to_bits(secfxp(1)))) self.assertEqual(c, [0.0] * 16 + [1.0] + [0.0] * 15) c = mpc.run(mpc.output(mpc.to_bits(secfxp(0.5)))) self.assertEqual(c, [0.0] * 15 + [1.0] + [0.0] * 16) c = mpc.run(mpc.output(mpc.to_bits(secfxp(8113)))) self.assertEqual(c, [0.0] * 16 + [1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0]) c = mpc.run(mpc.output(mpc.to_bits(secfxp(2**15 - 1)))) self.assertEqual(c, [0] * 16 + [1] * 15 + [0]) c = mpc.run(mpc.output(mpc.to_bits(secfxp(-1)))) self.assertEqual(c, [0] * 16 + [1] * 16) c = mpc.run(mpc.output(mpc.to_bits(secfxp(-2**15)))) self.assertEqual(c, [0] * 31 + [1]) for f in [8, 16, 32, 64]: secfxp = mpc.SecFxp(2 * f) c = mpc.run(mpc.output(secfxp(1) + secfxp(1))) self.assertEqual(c, 2) c = mpc.run(mpc.output(secfxp(2**-f) + secfxp(1))) if f != 64: # NB: 1 + 2**-64 == 1 in Python self.assertEqual(c, 1 + 2**-f) self.assertEqual(mpc.run(mpc.output(secfxp(0.5) * secfxp(2.0))), 1) self.assertEqual(mpc.run(mpc.output(secfxp(2.0) * secfxp(0.5))), 1) c = mpc.run( mpc.output( secfxp(2**(f // 2 - 1) - 0.5) * secfxp(-2**(f // 2) + 0.5))) self.assertEqual(c, -2**(f - 1) + 1.5 * 2**(f // 2 - 1) - 0.25) s = [10.75, -3.375, 0.125, -0.125] self.assertEqual(mpc.run(mpc.output(list(map(secfxp, s)))), s) s = [10.5, -3.25, 0.125, -0.125] a, b, c, d = list(map(secfxp, s)) t = [v * v for v in s] self.assertEqual(mpc.run(mpc.output([a * a, b * b, c * c, d * d])), t) x = [a, b, c, d] self.assertEqual(mpc.run(mpc.output(mpc.schur_prod(x, x))), t) self.assertEqual(mpc.run(mpc.output(mpc.schur_prod(x, x[:]))), t) t = sum(t) self.assertEqual(mpc.run(mpc.output(mpc.in_prod(x, x))), t) self.assertEqual(mpc.run(mpc.output(mpc.in_prod(x, x[:]))), t) self.assertEqual( mpc.run(mpc.output(mpc.matrix_prod([x], [x], True)[0])), [t]) u = mpc.unit_vector(secfxp(3), 4) self.assertEqual( mpc.run(mpc.output(mpc.matrix_prod([x], [u], True)[0])), [s[3]]) self.assertEqual( mpc.run(mpc.output(mpc.matrix_prod([u], [x], True)[0])), [s[3]]) self.assertEqual( mpc.run(mpc.output(mpc.gauss([[a]], b, [a], [b])[0])), [0]) t = [_ for a, b, c, d in [s] for _ in [a + b, a * b, a - b]] self.assertEqual(mpc.run(mpc.output([a + b, a * b, a - b])), t) t = [ _ for a, b, c, d in [s] for _ in [(a + b)**2, (a + b)**2 + 3 * c] ] self.assertEqual( mpc.run(mpc.output([(a + b)**2, (a + b)**2 + 3 * c])), t) t = [_ for a, b, c, d in [s] for _ in [a < b, b < c, c < d]] self.assertEqual(mpc.run(mpc.output([a < b, b < c, c < d])), t) t = s[0] < s[1] and s[1] < s[2] self.assertEqual(mpc.run(mpc.output((a < b) & (b < c))), t) t = s[0] < s[1] or s[1] < s[2] self.assertEqual(mpc.run(mpc.output((a < b) | (b < c))), t) t = (int(s[0] < s[1]) ^ int(s[1] < s[2])) self.assertEqual(mpc.run(mpc.output((a < b) ^ (b < c))), t) t = (int(not s[0] < s[1]) ^ int(s[1] < s[2])) self.assertEqual(mpc.run(mpc.output(~(a < b) ^ b < c)), t) t = [s[0] > 1, 10 * s[1] < 5, 10 * s[0] == 5] self.assertEqual( mpc.run(mpc.output([a > 1, 10 * b < 5, 10 * a == 5])), t) s[3] = -0.120 d = secfxp(s[3]) t = s[3] / 0.25 self.assertAlmostEqual(mpc.run(mpc.output(d / 0.25)), t, delta=2**(1 - f)) t = round(s[3] / s[2] + s[0]) self.assertEqual(round(mpc.run(mpc.output(d / c + a))), t) t = ((s[0] + s[1])**2 + 3 * s[2]) / s[2] self.assertAlmostEqual(mpc.run(mpc.output( ((a + b)**2 + 3 * c) / c)), t, delta=2**(8 - f)) t = 1 / s[3] self.assertAlmostEqual(mpc.run(mpc.output(1 / d)), t, delta=2**(6 - f)) t = s[2] / s[3] self.assertAlmostEqual(mpc.run(mpc.output(c / d)), t, delta=2**(3 - f)) t = -s[3] / s[2] self.assertAlmostEqual(mpc.run(mpc.output(-d / c)), t, delta=2**(3 - f)) self.assertEqual(mpc.run(mpc.output(mpc.sgn(+a))), s[0] > 0) self.assertEqual(mpc.run(mpc.output(mpc.sgn(-a))), -(s[0] > 0)) self.assertEqual(mpc.run(mpc.output(mpc.sgn(secfxp(0)))), 0) self.assertEqual(mpc.run(mpc.output(abs(secfxp(-1.5)))), 1.5) self.assertEqual(mpc.run(mpc.output(mpc.min(a, b, c, d))), min(s)) self.assertEqual(mpc.run(mpc.output(mpc.min(a, 0))), min(s[0], 0)) self.assertEqual(mpc.run(mpc.output(mpc.min(0, b))), min(0, s[1])) self.assertEqual(mpc.run(mpc.output(mpc.max(a, b, c, d))), max(s)) self.assertEqual(mpc.run(mpc.output(mpc.max(a, 0))), max(s[0], 0)) self.assertEqual(mpc.run(mpc.output(mpc.max(0, b))), max(0, s[1])) self.assertEqual( mpc.run(mpc.output(list(mpc.min_max(a, b, c, d)))), [min(s), max(s)]) self.assertEqual(mpc.run(mpc.output(mpc.argmin([a, b, c, d])[0])), 1) self.assertEqual( mpc.run(mpc.output(mpc.argmin([a, b], key=operator.neg)[1])), max(s)) self.assertEqual(mpc.run(mpc.output(mpc.argmax([a, b, c, d])[0])), 0) self.assertEqual( mpc.run(mpc.output(mpc.argmax([a, b], key=operator.neg)[1])), min(s)) self.assertEqual(mpc.run(mpc.output(secfxp(5) % 2)), 1) self.assertEqual(mpc.run(mpc.output(secfxp(1) % 2**(1 - f))), 0) self.assertEqual(mpc.run(mpc.output(secfxp(2**-f) % 2**(1 - f))), 2**-f) self.assertEqual( mpc.run(mpc.output(secfxp(2 * 2**-f) % 2**(1 - f))), 0) self.assertEqual(mpc.run(mpc.output(secfxp(1) // 2**(1 - f))), 2**(f - 1)) self.assertEqual(mpc.run(mpc.output(secfxp(27.0) % 7.0)), 6.0) self.assertEqual(mpc.run(mpc.output(secfxp(-27.0) // 7.0)), -4.0) self.assertEqual( mpc.run(mpc.output(list(divmod(secfxp(27.0), 6.0)))), [4.0, 3.0]) self.assertEqual(mpc.run(mpc.output(secfxp(21.5) % 7.5)), 6.5) self.assertEqual(mpc.run(mpc.output(secfxp(-21.5) // 7.5)), -3.0) self.assertEqual( mpc.run(mpc.output(list(divmod(secfxp(21.5), 0.5)))), [43.0, 0.0])
def test_secint(self): secint = mpc.SecInt() a = secint(12) b = secint(13) self.assertEqual(mpc.run(mpc.output(mpc.input(a, 0))), 12) self.assertEqual(mpc.run(mpc.output(mpc.input([a, b], 0))), [12, 13]) self.assertEqual(mpc.run(mpc.output(-a)), -12) self.assertEqual(mpc.run(mpc.output(+a)), 12) self.assertNotEqual(id(a), id(+a)) # NB: +a creates a copy self.assertEqual(mpc.run(mpc.output(a * b + b)), 12 * 13 + 13) self.assertEqual(mpc.run(mpc.output((a * b) / b)), 12) self.assertEqual(mpc.run(mpc.output((a * b) / 12)), 13) self.assertEqual(mpc.run(mpc.output(a**11 * a**-6 * a**-5)), 1) self.assertEqual(mpc.run(mpc.output(a**(secint.field.modulus - 1))), 1) c = mpc.to_bits( mpc.SecInt(0)(0)) # mpc.output() only works for nonempty lists self.assertEqual(c, []) c = mpc.run(mpc.output(mpc.to_bits(mpc.SecInt(1)(0)))) self.assertEqual(c, [0]) c = mpc.run(mpc.output(mpc.to_bits(mpc.SecInt(1)(1)))) self.assertEqual(c, [1]) c = mpc.to_bits(secint(0), 0) # mpc.output() only works for nonempty lists self.assertEqual(c, []) c = mpc.run(mpc.output(mpc.to_bits(secint(0)))) self.assertEqual(c, [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]) c = mpc.run(mpc.output(mpc.to_bits(secint(1)))) self.assertEqual(c, [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]) c = mpc.run(mpc.output(mpc.to_bits(secint(8113)))) self.assertEqual(c, [ 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]) c = mpc.run(mpc.output(mpc.to_bits(secint(2**31 - 1)))) self.assertEqual(c, [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 ]) c = mpc.run(mpc.output(mpc.to_bits(secint(2**31 - 1), 16))) self.assertEqual(c, [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]) c = mpc.run(mpc.output(mpc.to_bits(secint(-1), 8))) self.assertEqual(c, [1, 1, 1, 1, 1, 1, 1, 1]) c = mpc.run(mpc.output(mpc.to_bits(secint(-2**31)))) self.assertEqual(c, [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ]) c = mpc.run(mpc.output(mpc.to_bits(secint(-2**31), 16))) self.assertEqual(c, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) c = mpc.run(mpc.output(mpc.from_bits(mpc.to_bits(secint(8113))))) self.assertEqual(c, 8113) c = mpc.run(mpc.output(mpc.from_bits(mpc.to_bits(secint(2**31 - 1))))) self.assertEqual(c, 2**31 - 1) # TODO: from_bits for negative numbers # c = mpc.run(mpc.output(mpc.from_bits(mpc.to_bits(secint(-2**31))))) # self.assertEqual(c, -2**31) self.assertFalse(mpc.run(mpc.eq_public(secint(4), secint(2)))) self.assertTrue(mpc.run(mpc.eq_public(secint(42), secint(42)))) self.assertEqual(mpc.run(mpc.output(abs(secint(1)))), 1) self.assertEqual(mpc.run(mpc.output(secint(-2**31) % 2)), 0) self.assertEqual(mpc.run(mpc.output(secint(-2**31 + 1) % 2)), 1) self.assertEqual(mpc.run(mpc.output(secint(-1) % 2)), 1) self.assertEqual(mpc.run(mpc.output(secint(0) % 2)), 0) self.assertEqual(mpc.run(mpc.output(secint(1) % 2)), 1) self.assertEqual(mpc.run(mpc.output(secint(2**31 - 1) % 2)), 1) self.assertEqual(mpc.run(mpc.output(secint(5) % 2)), 1) self.assertEqual(mpc.run(mpc.output(secint(-5) % 2)), 1) self.assertEqual(mpc.run(mpc.output(secint(50) % 2)), 0) self.assertEqual(mpc.run(mpc.output(secint(50) % 4)), 2) self.assertEqual(mpc.run(mpc.output(secint(50) % 32)), 18) self.assertEqual(mpc.run(mpc.output(secint(-50) % 2)), 0) self.assertEqual(mpc.run(mpc.output(secint(-50) % 32)), 14) self.assertEqual(mpc.run(mpc.output(secint(5) // 2)), 2) self.assertEqual(mpc.run(mpc.output(secint(50) // 2)), 25) self.assertEqual(mpc.run(mpc.output(secint(50) // 4)), 12) self.assertEqual(mpc.run(mpc.output(secint(11) << 3)), 88) self.assertEqual(mpc.run(mpc.output(secint(-11) << 3)), -88) self.assertEqual(mpc.run(mpc.output(secint(70) >> 2)), 17) self.assertEqual(mpc.run(mpc.output(secint(-70) >> 2)), -18) self.assertEqual(mpc.run(mpc.output(secint(50) % 17)), 16) self.assertEqual(mpc.run(mpc.output(secint(177) % 17)), 7) self.assertEqual(mpc.run(mpc.output(secint(-50) % 17)), 1) self.assertEqual(mpc.run(mpc.output(secint(-177) % 17)), 10) self.assertEqual(mpc.run(mpc.output(secint(3)**0)), 1) self.assertEqual(mpc.run(mpc.output(secint(3)**18)), 3**18) self.assertIn(mpc.run(mpc.output(mpc.random_bit(secint))), [0, 1]) self.assertIn(mpc.run(mpc.output(mpc.random_bit(secint, signed=True))), [-1, 1])
def test_bsecfld(self): secfld = mpc.SecFld(char=2, min_order=2**8) a = secfld(57) b = secfld(67) self.assertEqual(int(mpc.run(mpc.output(mpc.input(a, 0)))), 57) self.assertEqual(int(mpc.run(mpc.output(+a - -a))), 0) self.assertEqual(int(mpc.run(mpc.output(a * b))), 137) self.assertEqual(int(mpc.run(mpc.output(a * b / a))), 67) self.assertEqual(int(mpc.run(mpc.output(a**254 * a))), 1) self.assertEqual(int(mpc.run(mpc.output(a & b))), 1) self.assertEqual(int(mpc.run(mpc.output(a | b))), 123) self.assertEqual(int(mpc.run(mpc.output(a ^ b))), 122) self.assertEqual(int(mpc.run(mpc.output(~a))), 198) c = mpc.run(mpc.output(mpc.to_bits(secfld(0)))) self.assertEqual(c, [0, 0, 0, 0, 0, 0, 0, 0]) c = mpc.run(mpc.output(mpc.to_bits(secfld(1)))) self.assertEqual(c, [1, 0, 0, 0, 0, 0, 0, 0]) c = mpc.run(mpc.output(mpc.to_bits(secfld(255)))) self.assertEqual(c, [1, 1, 1, 1, 1, 1, 1, 1]) c = mpc.run(mpc.output(mpc.to_bits(secfld(255), 1))) self.assertEqual(c, [1]) c = mpc.run(mpc.output(mpc.to_bits(secfld(255), 4))) self.assertEqual(c, [1, 1, 1, 1]) self.assertEqual(mpc.run(mpc.output(mpc.matrix_sub([[a]], [[a]])[0])), [0]) self.assertEqual( mpc.run(mpc.output(mpc.matrix_prod([c], [[a] * 4], True)[0])), [0]) self.assertEqual( mpc.run(mpc.output(mpc.matrix_prod([[a] * 4], [c], True)[0])), [0])
def test_io(self): x = ({4, 3}, [1 - 1j, 2.5], 0, range(7)) self.assertEqual(mpc.run(mpc.transfer(x))[0], x) self.assertEqual(mpc.run(mpc.transfer(x, senders=0)), x) self.assertEqual(mpc.run(mpc.transfer(x, senders=[0]))[0], x) self.assertEqual( mpc.run(mpc.transfer(x, senders=iter(range(1))))[0], x) self.assertEqual(mpc.run(mpc.transfer(x, receivers=0))[0], x) self.assertEqual(mpc.run(mpc.transfer(x, receivers=[0]))[0], x) self.assertEqual( mpc.run(mpc.transfer(x, receivers=iter(range(1))))[0], x) self.assertEqual(mpc.run(mpc.transfer(x, senders=0, receivers=0)), x) self.assertEqual( mpc.run(mpc.transfer(x, senders=[0], receivers=[0]))[0], x) self.assertEqual( mpc.run(mpc.transfer(x, sender_receivers=[(0, 0)]))[0], x) self.assertEqual( mpc.run(mpc.transfer(x, sender_receivers={0: {0}}))[0], x) a = mpc.SecInt()(7) self.assertEqual(mpc.run(mpc.output(mpc.input(a)))[0], 7) self.assertEqual(mpc.run(mpc.output(mpc.input(a)[0])), 7) self.assertEqual(mpc.run(mpc.output(mpc.input(a, senders=0))), 7) self.assertEqual(mpc.run(mpc.output(mpc.input(a, senders=[0])))[0], 7) self.assertEqual( mpc.run(mpc.output(mpc.input(a, senders=iter(range(1)))))[0], 7) self.assertEqual(mpc.run(mpc.output(mpc.input(a, senders=[0])))[0], 7) self.assertEqual(mpc.run(mpc.output(mpc.input(a, senders=[0])[0])), 7) self.assertEqual(mpc.run(mpc.output(mpc.input(a), receivers=0))[0], 7) self.assertEqual(mpc.run(mpc.output(mpc.input(a)[0], receivers=0)), 7) self.assertEqual( mpc.run(mpc.output(mpc.input(a), receivers=[0]))[0], 7) self.assertEqual( mpc.run(mpc.output(mpc.input(a), receivers=iter(range(1))))[0], 7) self.assertEqual(mpc.run(mpc.output(mpc.input(a)[0], receivers=[0])), 7) self.assertEqual( mpc.run(mpc.output(mpc.input(a, senders=0), receivers=0)), 7) self.assertEqual( mpc.run(mpc.output(mpc.input(a, senders=[0]), receivers=[0]))[0], 7) self.assertEqual( mpc.run(mpc.output(mpc.input(a, senders=[0])[0], receivers=[0])), 7) x = [a, a] self.assertEqual(mpc.run(mpc.output(mpc.input(x)[0])), [7, 7]) self.assertEqual(mpc.run(mpc.output(mpc.input(x, senders=0))), [7, 7]) self.assertEqual(mpc.run(mpc.output(mpc.input(x, senders=[0])[0])), [7, 7]) self.assertEqual(mpc.run(mpc.output(mpc.input(x)[0], receivers=0)), [7, 7]) self.assertEqual(mpc.run(mpc.output(mpc.input(x)[0], receivers=[0])), [7, 7]) self.assertEqual( mpc.run(mpc.output(mpc.input(x, senders=0), receivers=0)), [7, 7]) self.assertEqual( mpc.run(mpc.output(mpc.input(x, senders=[0])[0], receivers=[0])), [7, 7])