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_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_addition_gates():
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setR","arg":16}],["incmodR4"]]}',
diagram="""
0: ───Quirk(incmodR4,r=16)───
│
1: ───#2─────────────────────
│
2: ───#3─────────────────────
│
3: ───#4─────────────────────
""",
maps={0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 15: 0},
)
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setR","arg":5}],["incmodR4"]]}',
maps={0: 1, 1: 2, 2: 3, 3: 4, 4: 0, 5: 5, 15: 15},
)
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setR","arg":5}],["decmodR4"]]}',
maps={0: 4, 1: 0, 2: 1, 3: 2, 4: 3, 5: 5, 15: 15},
)
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setR","arg":5},{"id":"setA","arg":3}],["+AmodR4"]]}',
maps={0: 3, 1: 4, 2: 0, 3: 1, 4: 2, 5: 5, 15: 15},
)
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setR","arg":5},{"id":"setA","arg":3}],["-AmodR4"]]}',
maps={0: 2, 1: 3, 2: 4, 3: 0, 4: 1, 5: 5, 15: 15},
)
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_reversed_input_cell():
assert_url_to_circuit_returns(
'{"cols":[["revinputA4",1,1,1,"+=A4"]]}',
maps={
0x_0_0: 0x_0_0,
0x_2_3: 0x_2_7,
0x_1_3: 0x_1_B
},
)
assert_url_to_circuit_returns(
'{"cols":[["revinputA3",1,1,"revinputB3",1,1,"+=AB3"]]}',
maps={
0o_0_0_0: 0o_0_0_0,
0o_2_6_1: 0o_2_6_7,
0o_1_1_0: 0o_1_1_0,
0o_4_4_0: 0o_4_4_1
},
)
# Overlaps with effect.
with pytest.raises(ValueError, match='Duplicate qids'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":[["+=A3","revinputA3"]]}'
)
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_deinterleave():
assert_url_to_circuit_returns(
'{"cols":[["split5"]]}',
maps={
0b_00000: 0b_00000,
0b_00001: 0b_00100,
0b_00010: 0b_00001,
0b_00100: 0b_01000,
0b_01000: 0b_00010,
0b_10000: 0b_10000,
0b_01010: 0b_00011,
0b_11111: 0b_11111,
},
)
assert_url_to_circuit_returns(
'{"cols":[["split6"]]}',
maps={
0b_000000: 0b_000000,
0b_000001: 0b_000001,
0b_000010: 0b_001000,
0b_000100: 0b_000010,
0b_001000: 0b_010000,
0b_010000: 0b_000100,
0b_100000: 0b_100000,
0b_010101: 0b_000111,
0b_111111: 0b_111111,
},
)
def test_displays():
assert_url_to_circuit_returns(
'{"cols":[["Amps2"],[1,"Amps3"],["Chance"],'
'["Chance2"],["Density"],["Density3"],'
'["Sample4"],["Bloch"],["Sample2"]'
']}',
cirq.Circuit(),
)
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_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_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_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_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_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_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_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_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_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_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_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.quirk_url_to_circuit(
'http://algassert.com/quirk#circuit={"cols":[],"init":0}')
with pytest.raises(ValueError, match="Unrecognized init state"):
_ = cirq.quirk_url_to_circuit(
'http://algassert.com/quirk#circuit={"cols":[],"init":[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_arithmetic_unlisted_misc_gates():
assert_url_to_circuit_returns('{"cols":[["^=A3",1,1,"inputA2"]]}',
maps={
0b_000_00: 0b_000_00,
0b_000_01: 0b_001_01,
0b_000_10: 0b_010_10,
0b_111_11: 0b_100_11,
})
assert_url_to_circuit_returns('{"cols":[["^=A2",1,"inputA3"]]}',
maps={
0b_00_000: 0b_00_000,
0b_00_001: 0b_01_001,
0b_00_010: 0b_10_010,
0b_00_100: 0b_00_100,
0b_11_111: 0b_00_111,
})
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":5}],["^=A4"]]}',
maps={
0b_0000: 0b_0101,
0b_1111: 0b_1010,
})
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":11}],["+cntA4"]]}',
maps={
0b_0000: 0b_0011,
0b_0001: 0b_0100,
0b_1111: 0b_0010,
})
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":5}],["+cntA4"]]}',
maps={
0b_0000: 0b_0010,
0b_0001: 0b_0011,
0b_1111: 0b_0001,
})
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":7}],["-cntA4"]]}',
maps={
0b_0000: 0b_1101,
0b_0001: 0b_1110,
0b_1111: 0b_1100,
})
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":5}],["Flip<A4"]]}',
maps={
0b_1111: 0b_1111,
0b_0110: 0b_0110,
0b_0101: 0b_0101,
0b_0100: 0b_0000,
0b_0011: 0b_0001,
0b_0010: 0b_0010,
0b_0001: 0b_0011,
0b_0000: 0b_0100,
})
assert_url_to_circuit_returns(
'{"cols":[[{"id":"setA","arg":6}],["Flip<A4"]]}',
maps={
0b_1111: 0b_1111,
0b_0110: 0b_0110,
0b_0101: 0b_0000,
0b_0100: 0b_0001,
0b_0011: 0b_0010,
0b_0010: 0b_0011,
0b_0001: 0b_0100,
0b_0000: 0b_0101,
})
def test_arithmetic_comparison_gates():
with pytest.raises(ValueError, match='Missing input'):
_ = quirk_url_to_circuit('https://algassert.com/quirk#circuit={"cols":'
'[["^A<B"]]}')
assert_url_to_circuit_returns('{"cols":[["^A<B","inputA2",1,"inputB2"]]}',
diagram="""
0: ───Quirk(^A<B)───
│
1: ───A0────────────
│
2: ───A1────────────
│
3: ───B0────────────
│
4: ───B1────────────
""",
maps={
0b_0_00_10: 0b_1_00_10,
0b_1_00_10: 0b_0_00_10,
0b_0_11_10: 0b_0_11_10,
0b_0_10_10: 0b_0_10_10,
0b_0_01_10: 0b_1_01_10,
})
assert_url_to_circuit_returns('{"cols":[["^A>B","inputA2",1,"inputB2"]]}',
maps={
0b_0_11_10: 0b_1_11_10,
0b_0_10_10: 0b_0_10_10,
0b_0_01_10: 0b_0_01_10,
})
assert_url_to_circuit_returns('{"cols":[["^A>=B","inputA2",1,"inputB2"]]}',
maps={
0b_0_11_10: 0b_1_11_10,
0b_0_10_10: 0b_1_10_10,
0b_0_01_10: 0b_0_01_10,
})
assert_url_to_circuit_returns('{"cols":[["^A<=B","inputA2",1,"inputB2"]]}',
maps={
0b_0_11_10: 0b_0_11_10,
0b_0_10_10: 0b_1_10_10,
0b_0_01_10: 0b_1_01_10,
})
assert_url_to_circuit_returns('{"cols":[["^A=B","inputA2",1,"inputB2"]]}',
maps={
0b_0_11_10: 0b_0_11_10,
0b_0_10_10: 0b_1_10_10,
0b_0_01_10: 0b_0_01_10,
})
assert_url_to_circuit_returns('{"cols":[["^A!=B","inputA2",1,"inputB2"]]}',
maps={
0b_0_11_10: 0b_1_11_10,
0b_0_10_10: 0b_0_10_10,
0b_0_01_10: 0b_1_01_10,
})
