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])
