def test_arithmetic_modular_multiply_accumulate_gates():
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setR","arg":5},{"id":"setA","arg":3},'
'{"id":"setB","arg":4}],["+ABmodR4"]]}',
maps={
0: 2,
1: 3,
2: 4,
3: 0,
4: 1,
5: 5,
15: 15,
})
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setR","arg":27},{"id":"setA","arg":3},'
'{"id":"setB","arg":5}],["-ABmodR6"]]}',
maps={
0: 27 - 15,
1: 27 - 14,
15: 0,
16: 1,
26: 26 - 15,
27: 27,
63: 63,
})
def test_dynamic_single_qubit_rotations():
a, b, c = cirq.LineQubit.range(3)
t = sympy.Symbol('t')
# Dynamic single qubit rotations.
assert_url_to_circuit_returns(
'{"cols":[["X^t","Y^t","Z^t"],["X^-t","Y^-t","Z^-t"]]}',
cirq.Circuit(
cirq.X(a)**t,
cirq.Y(b)**t,
cirq.Z(c)**t,
cirq.X(a)**-t,
cirq.Y(b)**-t,
cirq.Z(c)**-t,
))
assert_url_to_circuit_returns(
'{"cols":[["e^iXt","e^iYt","e^iZt"],["e^-iXt","e^-iYt","e^-iZt"]]}',
cirq.Circuit(
cirq.Rx(2 * sympy.pi * t).on(a),
cirq.Ry(2 * sympy.pi * t).on(b),
cirq.Rz(2 * sympy.pi * t).on(c),
cirq.Rx(2 * sympy.pi * -t).on(a),
cirq.Ry(2 * sympy.pi * -t).on(b),
cirq.Rz(2 * sympy.pi * -t).on(c),
))
def test_controlled_swap():
a, b, c, d = cirq.LineQubit.range(4)
assert_url_to_circuit_returns(
'{"cols":[["Swap","•","Swap"]]}',
cirq.Circuit(cirq.SWAP(a, c).controlled_by(b)))
assert_url_to_circuit_returns(
'{"cols":[["Swap","•","Swap","•"]]}',
cirq.Circuit(cirq.SWAP(a, c).controlled_by(b, d)))
def test_assert_url_to_circuit_returns_circuit():
assert_url_to_circuit_returns('{"cols":[["X"]]}',
circuit=cirq.Circuit(
cirq.X(cirq.LineQubit(0))))
with pytest.raises(AssertionError, match='circuit differs'):
assert_url_to_circuit_returns('{"cols":[["X"]]}',
circuit=cirq.Circuit(
cirq.Y(cirq.LineQubit(0))))
def test_left_rotate():
assert_url_to_circuit_returns('{"cols":[["<<4"]]}',
maps={
0b_0000: 0b_0000,
0b_0001: 0b_1000,
0b_0010: 0b_0001,
0b_0100: 0b_0010,
0b_1000: 0b_0100,
0b_1111: 0b_1111,
0b_1010: 0b_0101,
})
def test_arithmetic_multiply_gates():
assert_url_to_circuit_returns('{"cols":[[{"id":"setA","arg":3}],["*A4"]]}',
maps={
0: 0,
1: 3,
3: 9,
9: 11,
11: 1,
})
assert_url_to_circuit_returns('{"cols":[[{"id":"setA","arg":3}],["/A4"]]}',
maps={
0: 0,
1: 11,
3: 1,
9: 3,
11: 9,
})
# Irreversible multipliers have no effect.
assert_url_to_circuit_returns('{"cols":[[{"id":"setA","arg":4}],["*A4"]]}',
maps={
0: 0,
1: 1,
3: 3,
})
assert_url_to_circuit_returns('{"cols":[[{"id":"setA","arg":4}],["/A4"]]}',
maps={
0: 0,
1: 1,
3: 3,
})
def test_arithmetic_multiply_accumulate_gates():
assert_url_to_circuit_returns('{"cols":[["+=AA4",1,1,1,"inputA2"]]}',
maps={
0b_0000_00: 0b_0000_00,
0b_0100_10: 0b_1000_10,
0b_1000_11: 0b_0001_11,
})
assert_url_to_circuit_returns('{"cols":[["-=AA4",1,1,1,"inputA2"]]}',
maps={
0b_0000_00: 0b_0000_00,
0b_0100_10: 0b_0000_10,
0b_1000_11: 0b_1111_11,
})
assert_url_to_circuit_returns(
'{"cols":[["+=AB3",1,1,"inputA2",1,"inputB2"]]}',
maps={
0b_000_00_00: 0b_000_00_00,
0b_000_11_10: 0b_110_11_10,
0b_100_11_11: 0b_101_11_11,
})
assert_url_to_circuit_returns(
'{"cols":[["-=AB3",1,1,"inputA2",1,"inputB2"]]}',
maps={
0b_000_00_00: 0b_000_00_00,
0b_000_11_10: 0b_010_11_10,
0b_100_11_11: 0b_011_11_11,
})
def test_arithmetic_addition_gates():
assert_url_to_circuit_returns('{"cols":[["inc3"]]}',
diagram="""
0: ───Quirk(inc3)───
│
1: ───#2────────────
│
2: ───#3────────────
""",
maps={
0: 1,
3: 4,
7: 0,
})
assert_url_to_circuit_returns('{"cols":[["dec3"]]}',
maps={
0: 7,
3: 2,
7: 6,
})
assert_url_to_circuit_returns('{"cols":[["+=A2",1,"inputA2"]]}',
maps={
0b_00_00: 0b_00_00,
0b_01_10: 0b_11_10,
0b_10_11: 0b_01_11,
})
assert_url_to_circuit_returns('{"cols":[["-=A2",1,"inputA2"]]}',
maps={
0b_00_00: 0b_00_00,
0b_01_10: 0b_11_10,
0b_10_11: 0b_11_11,
})
def test_assert_url_to_circuit_misc():
a, b = cirq.LineQubit.range(2)
assert_url_to_circuit_returns('{"cols":[["X","X"],["X"]]}',
cirq.Circuit(
cirq.X(a),
cirq.X(b),
cirq.X(a),
),
output_amplitudes_from_quirk=[{
"r": 0,
"i": 0
}, {
"r": 0,
"i": 0
}, {
"r": 1,
"i": 0
}, {
"r": 0,
"i": 0
}])
assert_url_to_circuit_returns(
'{"cols":[["X","X"],["X"]]}',
cirq.Circuit(
cirq.X(a),
cirq.X(b),
cirq.X(a),
))
with pytest.raises(AssertionError, match='Not equal to tolerance'):
assert_url_to_circuit_returns('{"cols":[["X","X"],["X"]]}',
cirq.Circuit(
cirq.X(a),
cirq.X(b),
cirq.X(a),
),
output_amplitudes_from_quirk=[{
"r": 0,
"i": 0
}, {
"r": 0,
"i": -1
}, {
"r": 0,
"i": 0
}, {
"r": 0,
"i": 0
}])
with pytest.raises(AssertionError, match='differs from expected circuit'):
assert_url_to_circuit_returns(
'{"cols":[["X","X"],["X"]]}',
cirq.Circuit(
cirq.X(a),
cirq.Y(b),
cirq.X(a),
))
def test_swap():
a, b, c = cirq.LineQubit.range(3)
assert_url_to_circuit_returns('{"cols":[["Swap","Swap"]]}',
cirq.Circuit(cirq.SWAP(a, b)))
assert_url_to_circuit_returns('{"cols":[["Swap","X","Swap"]]}',
cirq.Circuit(cirq.SWAP(a, c), cirq.X(b)))
with pytest.raises(ValueError, match='number of swap gates'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":[['
'"Swap"]]}')
with pytest.raises(ValueError, match='number of swap gates'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":[['
'"Swap","Swap","Swap"]]}')
def test_assert_url_to_circuit_returns_maps():
assert_url_to_circuit_returns('{"cols":[["X"]]}', maps={0: 1})
assert_url_to_circuit_returns('{"cols":[["X"]]}', maps={0: 1, 1: 0})
with pytest.raises(AssertionError, match='was mapped to 0b1'):
assert_url_to_circuit_returns('{"cols":[["X"]]}', maps={0: 0})
with pytest.raises(AssertionError, match='was mapped to None'):
assert_url_to_circuit_returns('{"cols":[["H"]]}', maps={0: 0})
def test_parity_controls():
a, b, c, d, e = cirq.LineQubit.range(5)
assert_url_to_circuit_returns(
'{"cols":[["Y","xpar","ypar","zpar","Z"]]}',
cirq.Circuit(
cirq.Y(b)**0.5,
cirq.X(c)**-0.5,
cirq.CNOT(c, b),
cirq.CNOT(d, b),
cirq.Y(a).controlled_by(b),
cirq.Z(e).controlled_by(b),
cirq.CNOT(d, b),
cirq.CNOT(c, b),
cirq.X(c)**0.5,
cirq.Y(b)**-0.5,
))
def test_input_cell():
assert_url_to_circuit_returns('{"cols":[["inputA4",1,1,1,"+=A4"]]}',
maps={
0x_0_0: 0x_0_0,
0x_2_3: 0x_2_5,
})
assert_url_to_circuit_returns(
'{"cols":[["inputA3",1,1,"inputB3",1,1,"+=AB3"]]}',
maps={
0o_0_0_0: 0o_0_0_0,
0o_2_3_1: 0o_2_3_7,
0o_1_1_0: 0o_1_1_1,
0o_4_4_0: 0o_4_4_0,
})
# Overlaps with effect.
with pytest.raises(ValueError, match='Overlapping registers'):
_ = quirk_url_to_circuit('https://algassert.com/quirk#circuit={"cols":['
'["+=A3","inputA3"]]}')
def test_reverse():
assert_url_to_circuit_returns('{"cols":[["rev4"]]}',
maps={
0b_0000: 0b_0000,
0b_0001: 0b_1000,
0b_0010: 0b_0100,
0b_0100: 0b_0010,
0b_1000: 0b_0001,
0b_1111: 0b_1111,
0b_1010: 0b_0101,
})
assert_url_to_circuit_returns('{"cols":[["rev3"]]}',
maps={
0b_000: 0b_000,
0b_001: 0b_100,
0b_010: 0b_010,
0b_100: 0b_001,
0b_111: 0b_111,
0b_101: 0b_101,
})
def test_assert_url_to_circuit_returns_output_amplitudes_from_quirk():
assert_url_to_circuit_returns('{"cols":[["X","Z"]]}',
output_amplitudes_from_quirk=[
{
"r": 0,
"i": 0
},
{
"r": 1,
"i": 0
},
{
"r": 0,
"i": 0
},
{
"r": 0,
"i": 0
},
])
with pytest.raises(AssertionError, match='Not equal to tolerance'):
assert_url_to_circuit_returns('{"cols":[["X","Z"]]}',
output_amplitudes_from_quirk=[
{
"r": 0,
"i": 0
},
{
"r": 0,
"i": 0
},
{
"r": 0,
"i": 1
},
{
"r": 0,
"i": 0
},
])
def test_modular_arithmetic_modulus_size():
with pytest.raises(ValueError, match='too small for modulus'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":['
'[{"id":"setR","arg":17}],["incmodR4"]]}')
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setR","arg":16}],["incmodR4"]]}')
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setR","arg":15}],["incmodR4"]]}')
with pytest.raises(ValueError, match='too small for modulus'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":['
'["incmodR2",1,"inputR3"]]}')
assert_url_to_circuit_returns('{"cols":[["incmodR3",1,1,"inputR3"]]}')
assert_url_to_circuit_returns('{"cols":[["incmodR4",1,1,1,"inputR3"]]}')
assert_url_to_circuit_returns('{"cols":[["incmodR2",1,"inputR2"]]}')
def test_measurement_gates():
a, b, c = cirq.LineQubit.range(3)
assert_url_to_circuit_returns(
'{"cols":[["Measure","Measure"],["Measure","Measure"]]}',
cirq.Circuit(
cirq.measure(a, key='row=0,col=0'),
cirq.measure(b, key='row=1,col=0'),
cirq.measure(a, key='row=0,col=1'),
cirq.measure(b, key='row=1,col=1'),
))
assert_url_to_circuit_returns(
'{"cols":[["XDetector","YDetector","ZDetector"]]}',
cirq.Circuit(
cirq.X(b)**-0.5,
cirq.Y(a)**0.5,
cirq.Moment([
cirq.measure(a, key='row=0,col=0'),
cirq.measure(b, key='row=1,col=0'),
cirq.measure(c, key='row=2,col=0'),
]),
cirq.Y(a)**-0.5,
cirq.X(b)**0.5,
))
def test_interleave():
assert_url_to_circuit_returns('{"cols":[["weave5"]]}',
maps={
0b_00000: 0b_00000,
0b_00001: 0b_00010,
0b_00010: 0b_01000,
0b_00100: 0b_00001,
0b_01000: 0b_00100,
0b_10000: 0b_10000,
0b_00011: 0b_01010,
0b_11111: 0b_11111,
})
assert_url_to_circuit_returns('{"cols":[["weave6"]]}',
maps={
0b_000000: 0b_000000,
0b_000001: 0b_000001,
0b_000010: 0b_000100,
0b_000100: 0b_010000,
0b_001000: 0b_000010,
0b_010000: 0b_001000,
0b_100000: 0b_100000,
0b_000111: 0b_010101,
0b_111111: 0b_111111,
})
def test_right_rotate():
assert_url_to_circuit_returns('{"cols":[["X",">>4",1,1,1,"X"]]}',
diagram="""
0: ───X───────────────────
1: ───right_rotate[0>3]───
│
2: ───right_rotate[1>0]───
│
3: ───right_rotate[2>1]───
│
4: ───right_rotate[3>2]───
5: ───X───────────────────
""",
maps={
0b_000000: 0b_100001,
0b_000010: 0b_100101,
0b_000100: 0b_101001,
0b_001000: 0b_110001,
0b_010000: 0b_100011,
0b_011110: 0b_111111,
0b_010100: 0b_101011,
})
def test_arithmetic_modular_multiply_gates():
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":3},{"id":"setR","arg":7}],["*AmodR4"]]}',
maps={
0: 0,
1: 3,
3: 2,
2: 6,
6: 4,
4: 5,
5: 1,
7: 7,
15: 15,
})
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":3},{"id":"setR","arg":7}],["/AmodR4"]]}',
maps={
0: 0,
1: 5,
2: 3,
3: 1,
4: 6,
5: 4,
6: 2,
7: 7,
15: 15,
})
# Irreversible multipliers have no effect.
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":5},{"id":"setR","arg":15}],["*AmodR4"]]}',
maps={
0: 0,
1: 1,
3: 3,
15: 15,
})
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":5},{"id":"setR","arg":15}],["/AmodR4"]]}',
maps={
0: 0,
1: 1,
3: 3,
15: 15,
})
def test_arithmetic_modular_exponentiation_gates():
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":5},{"id":"setB","arg":3},'
'{"id":"setR","arg":7}],["*BToAmodR4"]]}',
maps={
0: 0,
1: 5,
2: 3,
15: 15,
})
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":6},{"id":"setB","arg":3},'
'{"id":"setR","arg":7}],["*BToAmodR4"]]}',
maps={
0: 0,
1: 1,
2: 2,
15: 15,
})
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":5},{"id":"setB","arg":3},'
'{"id":"setR","arg":7}],["/BToAmodR4"]]}',
maps={
0: 0,
1: 3,
2: 6,
15: 15,
})
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":6},{"id":"setB","arg":3},'
'{"id":"setR","arg":7}],["/BToAmodR4"]]}',
maps={
0: 0,
1: 1,
2: 2,
15: 15,
})
def test_custom_matrix_gate():
a, b = cirq.LineQubit.range(2)
# Without name.
assert_url_to_circuit_returns(
'{"cols":[["~cv0d"]],'
'"gates":[{"id":"~cv0d","matrix":"{{0,1},{1,0}}"}]}',
cirq.Circuit(cirq.MatrixGate(np.array([
[0, 1],
[1, 0],
])).on(a), ))
# With name.
assert_url_to_circuit_returns(
'{"cols":[["~cv0d"]],'
'"gates":[{"id":"~cv0d","name":"test","matrix":"{{0,i},{1,0}}"}]}',
cirq.Circuit(cirq.MatrixGate(np.array([
[0, 1j],
[1, 0],
])).on(a), ))
# Multi-qubit. Reversed qubit order to account for endian-ness difference.
assert_url_to_circuit_returns(
'{"cols":[["X"],["~2hj0"]],'
'"gates":[{"id":"~2hj0",'
'"matrix":"{{-1,0,0,0},{0,i,0,0},{0,0,1,0},{0,0,0,-i}}"}]}',
cirq.Circuit(
cirq.X(a),
cirq.MatrixGate(np.diag([-1, 1j, 1, -1j])).on(b, a),
),
output_amplitudes_from_quirk=[{
"r": 0,
"i": 0
}, {
"r": 0,
"i": 1
}, {
"r": 0,
"i": 0
}, {
"r": 0,
"i": 0
}])
def test_init():
b, c, d, e, f = cirq.LineQubit.range(1, 6)
assert_url_to_circuit_returns(
'{"cols":[],"init":[0,1,"+","-","i","-i"]}',
cirq.Circuit(cirq.X(b),
cirq.Ry(np.pi / 2).on(c),
cirq.Ry(-np.pi / 2).on(d),
cirq.Rx(-np.pi / 2).on(e),
cirq.Rx(np.pi / 2).on(f)))
assert_url_to_circuit_returns('{"cols":[],"init":["+"]}',
output_amplitudes_from_quirk=[{
"r": 0.7071067690849304,
"i": 0
}, {
"r": 0.7071067690849304,
"i": 0
}])
assert_url_to_circuit_returns('{"cols":[],"init":["i"]}',
output_amplitudes_from_quirk=[{
"r": 0.7071067690849304,
"i": 0
}, {
"r":
0,
"i":
0.7071067690849304
}])
with pytest.raises(ValueError, match="init must be a list"):
_ = cirq.contrib.quirk.quirk_url_to_circuit(
'http://algassert.com/quirk#circuit={"cols":[],"init":0}')
with pytest.raises(ValueError, match="Unrecognized init state"):
_ = cirq.contrib.quirk.quirk_url_to_circuit(
'http://algassert.com/quirk#circuit={"cols":[],"init":[2]}')
def test_controls():
a, b = cirq.LineQubit.range(2)
assert_url_to_circuit_returns('{"cols":[["•","X"]]}',
cirq.Circuit(cirq.X(b).controlled_by(a), ))
assert_url_to_circuit_returns(
'{"cols":[["◦","X"]]}',
cirq.Circuit(
cirq.X(a),
cirq.X(b).controlled_by(a),
cirq.X(a),
))
assert_url_to_circuit_returns('{"cols":[["⊕","X"]]}',
cirq.Circuit(
cirq.Y(a)**0.5,
cirq.X(b).controlled_by(a),
cirq.Y(a)**-0.5,
),
output_amplitudes_from_quirk=[
{
"r": 0.5,
"i": 0
},
{
"r": -0.5,
"i": 0
},
{
"r": 0.5,
"i": 0
},
{
"r": 0.5,
"i": 0
},
])
assert_url_to_circuit_returns('{"cols":[["⊖","X"]]}',
cirq.Circuit(
cirq.Y(a)**-0.5,
cirq.X(b).controlled_by(a),
cirq.Y(a)**+0.5,
),
output_amplitudes_from_quirk=[
{
"r": 0.5,
"i": 0
},
{
"r": 0.5,
"i": 0
},
{
"r": 0.5,
"i": 0
},
{
"r": -0.5,
"i": 0
},
])
assert_url_to_circuit_returns('{"cols":[["⊗","X"]]}',
cirq.Circuit(
cirq.X(a)**-0.5,
cirq.X(b).controlled_by(a),
cirq.X(a)**+0.5,
),
output_amplitudes_from_quirk=[
{
"r": 0.5,
"i": 0
},
{
"r": 0,
"i": -0.5
},
{
"r": 0.5,
"i": 0
},
{
"r": 0,
"i": 0.5
},
])
assert_url_to_circuit_returns('{"cols":[["(/)","X"]]}',
cirq.Circuit(
cirq.X(a)**+0.5,
cirq.X(b).controlled_by(a),
cirq.X(a)**-0.5,
),
output_amplitudes_from_quirk=[
{
"r": 0.5,
"i": 0
},
{
"r": 0,
"i": 0.5
},
{
"r": 0.5,
"i": 0
},
{
"r": 0,
"i": -0.5
},
])
qs = cirq.LineQubit.range(8)
assert_url_to_circuit_returns(
'{"cols":[["X","•","◦","⊕","⊖","⊗","(/)","Z"]]}',
cirq.Circuit(
cirq.X(qs[2]),
cirq.Y(qs[3])**0.5,
cirq.Y(qs[4])**-0.5,
cirq.X(qs[5])**-0.5,
cirq.X(qs[6])**0.5,
cirq.X(qs[0]).controlled_by(*qs[1:7]),
cirq.Z(qs[7]).controlled_by(*qs[1:7]),
cirq.X(qs[6])**-0.5,
cirq.X(qs[5])**0.5,
cirq.Y(qs[4])**0.5,
cirq.Y(qs[3])**-0.5,
cirq.X(qs[2]),
))
def test_set_default_input_cell():
# Later column.
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":11}],["+=A4"]]}',
maps={
0: 11,
4: 15,
5: 0,
})
# Same column.
assert_url_to_circuit_returns('{"cols":[["+=A4",{"id":"setA","arg":11}]]}',
maps={
0: 11,
4: 15,
5: 0,
})
# Overwrite.
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":0}],["+=A4",{"id":"setA","arg":11}]]}',
maps={
0: 11,
4: 15,
5: 0,
})
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":11}],["+=A4",{"id":"setA","arg":0}]]}',
maps={
0: 0,
4: 4,
5: 5,
})
# Different values over time.
assert_url_to_circuit_returns(
'{"cols":['
'[{"id":"setA","arg":1}],'
'["+=A4"],'
'[{"id":"setA","arg":4}],'
'["+=A4"]]}',
maps={
0: 5,
})
# Broadcast.
assert_url_to_circuit_returns(
'{"cols":['
'[{"id":"setA","arg":1}],'
'["+=A2",1,"+=A2"],'
'["+=A2",1,"+=A2"]]}',
maps={
0b_00_00: 0b_10_10,
0b_10_01: 0b_00_11,
})
# Too late.
with pytest.raises(ValueError, match='Missing input'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":['
'["+=A2"],'
'[{"id":"setA","arg":1}]]}')
def test_assert_url_to_circuit_returns_unitary():
assert_url_to_circuit_returns('{"cols":[["X"]]}',
unitary=cirq.unitary(cirq.X))
with pytest.raises(AssertionError, match='Not equal to tolerance'):
assert_url_to_circuit_returns('{"cols":[["X"]]}', unitary=np.eye(2))
def test_assert_url_to_circuit_returns_diagram():
assert_url_to_circuit_returns('{"cols":[["X"]]}', diagram='0: ───X───')
with pytest.raises(AssertionError, match='text diagram differs'):
assert_url_to_circuit_returns('{"cols":[["X"]]}',
diagram='not even close')
def test_custom_circuit_gate():
a, b, c, d, e = cirq.LineQubit.range(5)
# Without name.
assert_url_to_circuit_returns(
'{"cols":[["~d3pq"],["Y"]],'
'"gates":[{"id":"~d3pq","circuit":{"cols":[["H"],["•","X"]]}}]}',
cirq.Circuit(
cirq.H(a),
cirq.X(b).controlled_by(a),
cirq.Y(a),
))
# With name.
assert_url_to_circuit_returns(
'{"cols":[["~d3pq"],["Y"]],'
'"gates":[{"id":"~d3pq","name":"test",'
'"circuit":{"cols":[["H"],["•","X"]]}}]}',
cirq.Circuit(
cirq.H(a),
cirq.X(b).controlled_by(a),
cirq.Y(a),
))
# With internal input.
assert_url_to_circuit_returns(
'{"cols":[["~a5ls"]],"gates":[{"id":"~a5ls",'
'"circuit":{"cols":[["inputA1","+=A1"]]}}]}',
cirq.Circuit(
cirq.contrib.quirk.QuirkArithmeticOperation('+=A1',
target=[b],
inputs=[[a]])))
# With external input.
assert_url_to_circuit_returns(
'{"cols":[["inputA1","~r79k"]],"gates":[{"id":"~r79k",'
'"circuit":{"cols":[["+=A1"]]}}]}',
cirq.Circuit(
cirq.contrib.quirk.QuirkArithmeticOperation('+=A1',
target=[b],
inputs=[[a]])))
# With external control.
assert_url_to_circuit_returns(
'{"cols":[["•",1,"~r79k"]],"gates":[{"id":"~r79k",'
'"circuit":{"cols":[["X"],["Y","Z"]]}}]}',
cirq.Circuit(
cirq.X(c).controlled_by(a),
cirq.Y(c).controlled_by(a),
cirq.Z(d).controlled_by(a)))
# With external and internal control.
assert_url_to_circuit_returns(
'{"cols":[["•",1,"~r79k"]],"gates":[{"id":"~r79k",'
'"circuit":{"cols":[["X"],["⊕","Z"]]}}]}',
cirq.Circuit(
cirq.X(c).controlled_by(a),
cirq.Y(c)**0.5,
cirq.Z(d).controlled_by(a, c),
cirq.Y(c)**-0.5))
# Broadcast input.
assert_url_to_circuit_returns(
'{"cols":[["~q1fh",1,1,"inputA2"]],"gates":[{"id":"~q1fh",'
'"circuit":{"cols":[["+=A2"],[1,"+=A2"],[1,"+=A2"]]}}]}',
cirq.Circuit(
cirq.contrib.quirk.QuirkArithmeticOperation('+=A2',
target=[a, b],
inputs=[[d, e]]),
cirq.contrib.quirk.QuirkArithmeticOperation('+=A2',
target=[b, c],
inputs=[[d, e]]),
cirq.contrib.quirk.QuirkArithmeticOperation('+=A2',
target=[b, c],
inputs=[[d, e]]),
))
# Nested custom gate.
assert_url_to_circuit_returns(
'{"cols":[["~gtnd"]],"gates":[{"id":"~ct36",'
'"circuit":{"cols":[["X"],["X"]]}},{"id":"~gtnd",'
'"circuit":{"cols":[["~ct36"],["~ct36"]]}}]}',
cirq.Circuit(cirq.X(a)) * 4)
# Nested custom gate wrong order.
with pytest.raises(ValueError, match='Unrecognized column entry'):
_ = quirk_json_to_circuit({
"cols": [["~gtnd"]],
"gates": [
{
"id": "~gtnd",
"circuit": {
"cols": [["~ct36"], ["~ct36"]]
}
},
{
"id": "~ct36",
"circuit": {
"cols": [["X"], ["X"]]
}
},
]
})
def test_displays():
assert_url_to_circuit_returns(
'{"cols":[["Amps2"],[1,"Amps3"],["Chance"],'
'["Chance2"],["Density"],["Density3"],'
'["Sample4"],["Bloch"],["Sample2"]'
']}', cirq.Circuit())
def test_scalar_operations():
assert_url_to_circuit_returns('{"cols":[["…"]]}', cirq.Circuit())
assert_url_to_circuit_returns('{"cols":[["NeGate"]]}',
cirq.Circuit(cirq.GlobalPhaseOperation(-1)))
assert_url_to_circuit_returns('{"cols":[["i"]]}',
cirq.Circuit(cirq.GlobalPhaseOperation(1j)))
assert_url_to_circuit_returns('{"cols":[["-i"]]}',
cirq.Circuit(cirq.GlobalPhaseOperation(-1j)))
assert_url_to_circuit_returns(
'{"cols":[["√i"]]}', cirq.Circuit(cirq.GlobalPhaseOperation(1j**0.5)))
assert_url_to_circuit_returns(
'{"cols":[["√-i"]]}', cirq.Circuit(cirq.GlobalPhaseOperation(1j**-0.5)))
