def test_cleartext_dist32():
x = 4060000
y = 7390000
cx = 4063500
cy = 7396000
rsq = 64000000
answer = 1 if ((x - cx)**2 + (y - cy)**2) < rsq else 0
inputs = [0 for _ in range(32)]
x_bits = [int(b) for b in bin(x)[2:]]
if len(x_bits) < 32:
x_bits = [0 for _ in range(32 - len(x_bits))] + x_bits
y_bits = [int(b) for b in bin(y)[2:]]
if len(y_bits) < 32:
y_bits = [0 for _ in range(32 - len(y_bits))] + y_bits
cx_bits = [int(b) for b in bin(cx)[2:]]
if len(cx_bits) < 32:
cx_bits = [0 for _ in range(32 - len(cx_bits))] + cx_bits
cy_bits = [int(b) for b in bin(cy)[2:]]
if len(cy_bits) < 32:
cy_bits = [0 for _ in range(32 - len(cy_bits))] + cy_bits
rsq_bits = [int(b) for b in bin(rsq)[2:]]
if len(rsq_bits) < 32:
rsq_bits = [0 for _ in range(32 - len(rsq_bits))] + rsq_bits
inputs.extend(x_bits[::-1])
inputs.extend(y_bits[::-1])
inputs.extend(cx_bits[::-1])
inputs.extend(cy_bits[::-1])
inputs.extend(rsq_bits[::-1])
c = Circuit("bristol_circuits/dist32.txt", ['V' for _ in range(192)])
out_bit = asyncio.run(c.evaluate(inputs))
assert out_bit[0] == answer, "computed wrong value"
def run_circuit_process(t, n, c_path, index, queues, main_queue, inputs,
triples):
print(f"starting node {index}")
shamir = Shamir(t, n)
messenger = MockMessenger(t, n, index, queues)
c = Circuit(c_path)
outputs = c.evaluate(inputs,
shamir=shamir,
messenger=messenger,
triples=triples)
main_queue.put(outputs)
print(f"closing node {index}")
def test_cleartext_unnormalized_subregion_example():
answer = 300
inputs = [0 for _ in range(64)] + [1 for _ in range(1200)]
c = Circuit("bristol_circuits/unnormalized_subregion_100_10.txt",
['V' for _ in range(1264)])
out_bits = asyncio.run(c.evaluate(inputs))
out_string = ''.join([str(i) for i in list(reversed(out_bits))])
for i in range(10):
assert eval('0b' + out_string[i * 64:(i + 1) *
64]) == answer, "computed wrong value"
def test_evaluation(self):
c = Circuit(2)
f = AdditionGate("F")
g = AdditionGate("G")
h = ScalarMultGate(2, "H")
c.add_gate(h, ["INPUT1"])
c.add_gate(f, ["H","INPUT0"])
c.add_gate(g, ["F", "H"], True)
input0, input1 = 1, 100
result = c.evaluate((input0, input1))
h_res = input1 * 2
f_res = h_res + input0
g_res = h_res + f_res
self.assertEqual(result, g_res)
def compile_unitary(U):
"""
Takes a unitary and returns a circuit - i.e. a list of CNOTs and single qubit gates.
"""
# perform two level decomposition
two_level_unitaries = two_level_decomp(U)
assert(np.allclose(mat_mul(two_level_unitaries), U))
controlled_ops = []
# decompose each two-level unitary into fully controlled operations
for t in two_level_unitaries:
controlled_ops += two_level_to_fully_controlled(t)
assert(np.allclose(mat_mul(controlled_ops),U))
gates = []
# decompose each fully controlled operations into single qubit and CNOT gates
for c in controlled_ops:
gates += fully_controlled_to_single_cnot(c)
circ = Circuit(n)
circ.add_gates(gates)
prod = circ.evaluate()
assert(np.allclose(prod, U))
print('number of two-level: ' + str(len(two_level_unitaries)))
print('number of fully controlled ops: ' + str(len(controlled_ops)))
print('number of CNOT and single qubit gates: ' + str(len(gates)))
s = [g for g in gates if type(g) is SingleQubitGate]
c = [g for g in gates if type(g) is CNOTGate]
print('Single gates: ' + str(len(s)))
print('CNOT gates: ' + str(len(c)))
print('approximation error: ' + str(np.linalg.norm(prod-U)))
for g in gates:
if np.allclose(g.total_matrix(), np.eye(2**g.num_qubits)):
print('redundant gate')
return circ
def test_cleartext_lessthan32():
for x,y in [(100, 200), (200, 100), (111111, 23456), (2**30, 2**10), (2**10, 2**30), (2**32-1, 2**32-1)]:
answer = 1 if x<y else 0
x_bits = [int(c) for c in bin(x)[2:]]
if len(x_bits)<32:
x_bits = [0 for _ in range(32 - len(x_bits))]+ x_bits
y_bits = [int(c) for c in bin(y)[2:]]
if len(y_bits)<32:
y_bits = [0 for _ in range(32 - len(y_bits))]+ y_bits
x_bits = list(reversed(x_bits))
y_bits = list(reversed(y_bits))
c = Circuit("bristol_circuits/lessthan32.txt", ['V' for _ in range(64)])
out_bit = c.evaluate(x_bits+y_bits)
assert out_bit[0] == answer, "computed wrong value"
def test_cleartext_mul64mod():
for x,y in [(100, 200), (111111, 23456), (2**30, 2**10), (2**63, 2**63+1), (2**64-1, 2**64-1)]:
answer = (x*y)%(2**64)
x_bits = [int(c) for c in bin(x)[2:]]
if len(x_bits)<64:
x_bits = [0 for _ in range(64 - len(x_bits))]+ x_bits
y_bits = [int(c) for c in bin(y)[2:]]
if len(y_bits)<64:
y_bits = [0 for _ in range(64 - len(y_bits))]+ y_bits
x_bits = list(reversed(x_bits))
y_bits = list(reversed(y_bits))
c = Circuit("bristol_circuits/mul64mod.txt", ['V' for _ in range(128)])
out_bits = c.evaluate(x_bits+y_bits)
out_string = ''.join([str(i) for i in list(reversed(out_bits))])
assert eval('0b'+out_string) == answer, "computed wrong value"
def test_cleartext_sub64():
for x, y in [(1000, 2010), (2010, 1000), (2**32 - 1, 2**32 - 1),
(2**60, 2**60 + 5), (2**63, 2**63 + 1),
(2**64 - 25, 2**64 - 100), (2**64 - 1, 2**64 - 1)]:
answer = (x - y) % (2**64)
x_bits = [int(c) for c in bin(x)[2:]]
if len(x_bits) < 64:
x_bits = [0 for _ in range(64 - len(x_bits))] + x_bits
y_bits = [int(c) for c in bin(y)[2:]]
if len(y_bits) < 64:
y_bits = [0 for _ in range(64 - len(y_bits))] + y_bits
x_bits = list(reversed(x_bits))
y_bits = list(reversed(y_bits))
c = Circuit("bristol_circuits/sub64.txt", ['V' for _ in range(128)])
out_bits = asyncio.run(c.evaluate(x_bits + y_bits))
out_string = ''.join([str(i) for i in list(reversed(out_bits))])
assert eval('0b' + out_string) == answer, "computed wrong value"
def test_cleartext_addsub_example():
x = 1000
y = 2000
answer1 = (x + y) % (2**64)
answer2 = (x - y) % (2**64)
x_bits = [int(c) for c in bin(x)[2:]]
if len(x_bits) < 64:
x_bits = [0 for _ in range(64 - len(x_bits))] + x_bits
y_bits = [int(c) for c in bin(y)[2:]]
if len(y_bits) < 64:
y_bits = [0 for _ in range(64 - len(y_bits))] + y_bits
x_bits = list(reversed(x_bits))
y_bits = list(reversed(y_bits))
c = Circuit("bristol_circuits/example.txt", ['V' for _ in range(128)])
out_bits = asyncio.run(c.evaluate(x_bits + y_bits))
out_string = ''.join([str(i) for i in list(reversed(out_bits))])
assert eval('0b' + out_string[:64]) == answer2, "computed wrong value"
assert eval('0b' + out_string[64:]) == answer1, "computed wrong value"
def test_circuit_add64():
for x, y in [(1000, 2010), (100, 200), (111111, 23456),
(2**32 - 1, 2**32 - 1), (2**60, 2**60 + 5),
(2**63, 2**63 + 1), (2**64 - 25, 2**64 - 100),
(2**64 - 1, 2**64 - 1)]:
answer = (x + y) % (2**64)
x_bits = [int(c) for c in bin(x)[2:]]
if len(x_bits) < 64:
x_bits = [0 for _ in range(64 - len(x_bits))] + x_bits
y_bits = [int(c) for c in bin(y)[2:]]
if len(y_bits) < 64:
y_bits = [0 for _ in range(64 - len(y_bits))] + y_bits
x_bits = list(reversed(x_bits))
y_bits = list(reversed(y_bits))
c = Circuit("bristol_circuits/add64.txt")
out_bits = c.evaluate(x_bits + y_bits)
out_string = ''.join([str(i) for i in list(reversed(out_bits))])
assert eval('0b' + out_string) == answer, "computed wrong value"
c.add_gate("snap", n_params=1, fn=snap_zz)
# arbitrary one-qubit rotations
c.add_gate("rotation")
c.add_gate("displacement", n_params=1, fn=cav_xrot)
c.add_gate("displacement", n_params=1, fn=cav_yrot)
c.add_gate("displacement", n_params=1, fn=cav_xrot)
np.set_printoptions(precision=3)
np.set_printoptions(suppress=True)
c.assemble()
print()
print("num free params: {}".format(c.n_params))
print()
rng = np.random.default_rng()
params = rng.uniform(high=2*np.pi, size=c.n_params)
print("param vector:\n{}".format(params))
print()
u = c.evaluate(params)
print("resulting unitary:\n{}".format(u))
print()
tensor = c.get_tensor(params)
print("resulting tensor:\n{}".format(tensor))
print()
print("tensor shape:\n{}".format(tensor.shape))
def run_circuit_process(t, n, c_path, index, queues, main_queue, inputs, triples):
shamir = Shamir(t, n)
messenger = MockMessenger(t, n, index, queues)
c = Circuit(c_path, ['S' for _ in range(len(inputs))])
outputs = c.evaluate(inputs, shamir=shamir, messenger=messenger, triples=triples)
main_queue.put(outputs)
from circuit import Circuit
test_cleartext_circuit():
x = 20000
y = 200
answer = x*y
x_bits = [int(c) for c in bin(x)[2:]]
if len(x_bits)<32:
x_bits = [0 for _ in range(32 - len(x_bits))]+ x_bits
y_bits = [int(c) for c in bin(y)[2:]]
if len(y_bits)<32:
y_bits = [0 for _ in range(32 - len(y_bits))]+ y_bits
c = Circuit("circuits/mul32_circuit.txt")
out_bits = c.evaluate(x_bits+y_bits)
out_string = ''.join([str(i) for i in out_bits])
print(eval('0b'+out_string) == answer)
if __name__ == "__main__":
test_cleartext_citcuit()
print("PASS")
