def test_non_physical_operations():
with pytest.raises(NotImplementedError, match="unphysical operation"):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":[["__error__"]]}')
with pytest.raises(NotImplementedError, match="unphysical operation"):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":[["__unstable__UniversalNot"]]}'
)
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_extra_cell_makers():
assert cirq.quirk_url_to_circuit(
'http://algassert.com/quirk#circuit={"cols":[["iswap"]]}',
extra_cell_makers=[
cirq.interop.quirk.cells.CellMaker(
identifier='iswap',
size=2,
maker=lambda args: cirq.ISWAP(*args.qubits))
]) == cirq.Circuit(cirq.ISWAP(*cirq.LineQubit.range(2)))
assert cirq.quirk_url_to_circuit(
'http://algassert.com/quirk#circuit={"cols":[["iswap"]]}',
extra_cell_makers={'iswap': cirq.ISWAP}) == cirq.Circuit(
cirq.ISWAP(*cirq.LineQubit.range(2)))
def test_parse_simple_cases():
a, b = cirq.LineQubit.range(2)
assert quirk_url_to_circuit('http://algassert.com/quirk') == cirq.Circuit()
assert quirk_url_to_circuit('https://algassert.com/quirk') == cirq.Circuit()
assert quirk_url_to_circuit(
'https://algassert.com/quirk#') == cirq.Circuit()
assert quirk_url_to_circuit(
'http://algassert.com/quirk#circuit={"cols":[]}') == cirq.Circuit()
assert quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={'
'%22cols%22:[[%22H%22],[%22%E2%80%A2%22,%22X%22]]'
'}') == cirq.Circuit(cirq.H(a),
cirq.X(b).controlled_by(a))
def test_custom_gate_parse_failures():
with pytest.raises(ValueError, match='must be a list'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":[],'
'"gates":5}')
with pytest.raises(ValueError, match='gate json must be a dict'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":[],'
'"gates":[5]}')
with pytest.raises(ValueError, match='Circuit JSON must be a dict'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":[],'
'"gates":[{"id":"~a","circuit":5}]}')
with pytest.raises(ValueError, match='matrix json must be a string'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":[],'
'"gates":[{"id":"~a","matrix":5}]}')
with pytest.raises(ValueError, match='Not surrounded by {{}}'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":[],'
'"gates":[{"id":"~a","matrix":"abc"}]}')
with pytest.raises(ValueError, match='must have an id'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":[],'
'"gates":['
'{"matrix":"{{1,0},{0,1}}"}'
']}')
with pytest.raises(ValueError, match='both a matrix and a circuit'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":[],'
'"gates":['
'{"id":"~a","circuit":{"cols":[]},"matrix":"{{1,0},{0,1}}"}'
']}')
with pytest.raises(ValueError, match='matrix or a circuit'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":[],'
'"gates":['
'{"id":"~a"}'
']}')
with pytest.raises(ValueError, match='duplicate identifier'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":[],'
'"gates":['
'{"id":"~a","matrix":"{{1,0},{0,1}}"},'
'{"id":"~a","matrix":"{{1,0},{0,1}}"}]}')
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_completes_weight_zero_billion_laughs():
circuit = cirq.quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={'
'"cols":[["~z"]],'
'"gates":['
'{"id":"~a","circuit":{"cols":['
'["•"],["inputA2"],["setA"],["⊗","xpar"]]}},'
'{"id":"~b","circuit":{"cols":[["~a"],["~a"],["~a"],["~a"]]}},'
'{"id":"~c","circuit":{"cols":[["~b"],["~b"],["~b"],["~b"]]}},'
'{"id":"~d","circuit":{"cols":[["~c"],["~c"],["~c"],["~c"]]}},'
'{"id":"~e","circuit":{"cols":[["~d"],["~d"],["~d"],["~d"]]}},'
'{"id":"~f","circuit":{"cols":[["~e"],["~e"],["~e"],["~e"]]}},'
'{"id":"~g","circuit":{"cols":[["~f"],["~f"],["~f"],["~f"]]}},'
'{"id":"~h","circuit":{"cols":[["~g"],["~g"],["~g"],["~g"]]}},'
'{"id":"~i","circuit":{"cols":[["~h"],["~h"],["~h"],["~h"]]}},'
'{"id":"~j","circuit":{"cols":[["~i"],["~i"],["~i"],["~i"]]}},'
'{"id":"~k","circuit":{"cols":[["~j"],["~j"],["~j"],["~j"]]}},'
'{"id":"~l","circuit":{"cols":[["~k"],["~k"],["~k"],["~k"]]}},'
'{"id":"~m","circuit":{"cols":[["~l"],["~l"],["~l"],["~l"]]}},'
'{"id":"~n","circuit":{"cols":[["~m"],["~m"],["~m"],["~m"]]}},'
'{"id":"~o","circuit":{"cols":[["~n"],["~n"],["~n"],["~n"]]}},'
'{"id":"~p","circuit":{"cols":[["~o"],["~o"],["~o"],["~o"]]}},'
'{"id":"~q","circuit":{"cols":[["~p"],["~p"],["~p"],["~p"]]}},'
'{"id":"~r","circuit":{"cols":[["~q"],["~q"],["~q"],["~q"]]}},'
'{"id":"~s","circuit":{"cols":[["~r"],["~r"],["~r"],["~r"]]}},'
'{"id":"~t","circuit":{"cols":[["~s"],["~s"],["~s"],["~s"]]}},'
'{"id":"~u","circuit":{"cols":[["~t"],["~t"],["~t"],["~t"]]}},'
'{"id":"~v","circuit":{"cols":[["~u"],["~u"],["~u"],["~u"]]}},'
'{"id":"~w","circuit":{"cols":[["~v"],["~v"],["~v"],["~v"]]}},'
'{"id":"~x","circuit":{"cols":[["~w"],["~w"],["~w"],["~w"]]}},'
'{"id":"~y","circuit":{"cols":[["~x"],["~x"],["~x"],["~x"]]}},'
'{"id":"~z","circuit":{"cols":[["~y"],["~y"],["~y"],["~y"]]}}'
']}',
max_operation_count=0)
assert circuit == cirq.Circuit()
def test_with_registers():
circuit = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":'
'['
'[{"id":"setA","arg":3}],'
'["+=AB3",1,1,"inputB2"]'
']}')
op = cast(cirq.ArithmeticOperation, circuit[0].operations[0])
with pytest.raises(ValueError, match='number of registers'):
_ = op.with_registers()
with pytest.raises(ValueError, match='first register.*mutable target'):
_ = op.with_registers(1, 2, 3)
op2 = op.with_registers([], 5, 5)
np.testing.assert_allclose(cirq.unitary(cirq.Circuit(op2)),
np.array([[1]]),
atol=1e-8)
op2 = op.with_registers([*cirq.LineQubit.range(3)], 5, 5)
np.testing.assert_allclose(cirq.final_state_vector(cirq.Circuit(op2),
initial_state=0),
cirq.one_hot(index=25 % 8,
shape=8,
dtype=np.complex64),
atol=1e-8)
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_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,
})
def assert_url_to_circuit_returns(
json_text: str,
circuit: 'cirq.Circuit' = None,
*,
unitary: Optional[np.ndarray] = None,
diagram: Optional[str] = None,
output_amplitudes_from_quirk: Optional[List[Dict[str, float]]] = None,
maps: Optional[Dict[int, int]] = None):
"""
Args:
json_text: The part of the quirk URL after "#circuit=".
circuit: The optional expected circuit. If specified and not
equal to the parsed circuit, an assertion fails.
unitary: The optional expected unitary of the circuit. If specified
and the parsed circuit has a different unitary, an assertion fails.
diagram: The optional expected circuit diagram. If specified and the
parsed circuit has a different diagram, an assertion fails.
output_amplitudes_from_quirk: Optional data copied from Quirk's "export
simulation data" function, for comparison to Cirq's simulator
results. If specified and the output from the simulation differs
from this data (after accounting for differences in endian-ness),
an assertion fails.
maps: Optional dictionary of test computational basis input states and
the output computational basis state that they should be mapped to.
If any state is mapped to the wrong thing, an assertion fails. Note
that the states are specified using Quirk's little endian
convention, meaning that the last bit of a binary literal will refer
to the last qubit's value instead of vice versa.
"""
parsed = quirk_url_to_circuit(
f'https://algassert.com/quirk#circuit={json_text}')
if diagram is not None:
cirq.testing.assert_has_diagram(parsed, diagram)
if circuit is not None:
cirq.testing.assert_same_circuits(parsed, circuit)
if unitary is not None:
np.testing.assert_allclose(cirq.unitary(parsed), unitary, atol=1e-8)
if output_amplitudes_from_quirk is not None:
expected = np.array([
float(e['r']) + 1j * float(e['i'])
for e in output_amplitudes_from_quirk
])
np.testing.assert_allclose(
cirq.final_state_vector(
parsed,
# Match Quirk's endian-ness for comparison purposes.
qubit_order=sorted(parsed.all_qubits(), reverse=True),
),
expected,
atol=1e-8)
if maps:
cirq.testing.assert_equivalent_computational_basis_map(maps, parsed)
def test_parse_failures(url, msg):
parsed_url = urllib.parse.urlparse(url)
data = json.loads(parsed_url.fragment[len('circuit='):])
with pytest.raises(ValueError, match=msg):
_ = quirk_url_to_circuit(url)
with pytest.raises(ValueError, match=msg):
_ = quirk_json_to_circuit(data)
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_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_parse_with_qubits():
a = cirq.GridQubit(0, 0)
b = cirq.GridQubit(0, 1)
c = cirq.GridQubit(0, 2)
assert quirk_url_to_circuit(
'http://algassert.com/quirk#circuit={"cols":[["H"],["•","X"]]}',
qubits=cirq.GridQubit.rect(4, 4)) == cirq.Circuit(
cirq.H(a),
cirq.X(b).controlled_by(a))
assert quirk_url_to_circuit(
'http://algassert.com/quirk#circuit={"cols":[["H"],["•",1,"X"]]}',
qubits=cirq.GridQubit.rect(4, 4)) == cirq.Circuit(
cirq.H(a),
cirq.X(c).controlled_by(a))
with pytest.raises(IndexError, match="qubits specified"):
_ = quirk_url_to_circuit(
'http://algassert.com/quirk#circuit={"cols":[["H"],["•","X"]]}',
qubits=[cirq.GridQubit(0, 0)])
def test_survives_a_billion_laughs():
# If this test is timing out, it means you made a change that accidentally
# iterated over the circuit contents before they were counted and checked
# against the maximum. It is not possible to test for the billion laughs
# attack by doing a small case, because iterating-then-counting instead of
# counting-then-iterating misleadingly succeeds on small cases.
with pytest.raises(ValueError, match=f'{4**26} operations'):
cirq.quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={'
'"cols":[["~z"]],'
'"gates":['
'{"id":"~a","circuit":{"cols":[["H"],["H"],["H"],["H"]]}},'
'{"id":"~b","circuit":{"cols":[["~a"],["~a"],["~a"],["~a"]]}},'
'{"id":"~c","circuit":{"cols":[["~b"],["~b"],["~b"],["~b"]]}},'
'{"id":"~d","circuit":{"cols":[["~c"],["~c"],["~c"],["~c"]]}},'
'{"id":"~e","circuit":{"cols":[["~d"],["~d"],["~d"],["~d"]]}},'
'{"id":"~f","circuit":{"cols":[["~e"],["~e"],["~e"],["~e"]]}},'
'{"id":"~g","circuit":{"cols":[["~f"],["~f"],["~f"],["~f"]]}},'
'{"id":"~h","circuit":{"cols":[["~g"],["~g"],["~g"],["~g"]]}},'
'{"id":"~i","circuit":{"cols":[["~h"],["~h"],["~h"],["~h"]]}},'
'{"id":"~j","circuit":{"cols":[["~i"],["~i"],["~i"],["~i"]]}},'
'{"id":"~k","circuit":{"cols":[["~j"],["~j"],["~j"],["~j"]]}},'
'{"id":"~l","circuit":{"cols":[["~k"],["~k"],["~k"],["~k"]]}},'
'{"id":"~m","circuit":{"cols":[["~l"],["~l"],["~l"],["~l"]]}},'
'{"id":"~n","circuit":{"cols":[["~m"],["~m"],["~m"],["~m"]]}},'
'{"id":"~o","circuit":{"cols":[["~n"],["~n"],["~n"],["~n"]]}},'
'{"id":"~p","circuit":{"cols":[["~o"],["~o"],["~o"],["~o"]]}},'
'{"id":"~q","circuit":{"cols":[["~p"],["~p"],["~p"],["~p"]]}},'
'{"id":"~r","circuit":{"cols":[["~q"],["~q"],["~q"],["~q"]]}},'
'{"id":"~s","circuit":{"cols":[["~r"],["~r"],["~r"],["~r"]]}},'
'{"id":"~t","circuit":{"cols":[["~s"],["~s"],["~s"],["~s"]]}},'
'{"id":"~u","circuit":{"cols":[["~t"],["~t"],["~t"],["~t"]]}},'
'{"id":"~v","circuit":{"cols":[["~u"],["~u"],["~u"],["~u"]]}},'
'{"id":"~w","circuit":{"cols":[["~v"],["~v"],["~v"],["~v"]]}},'
'{"id":"~x","circuit":{"cols":[["~w"],["~w"],["~w"],["~w"]]}},'
'{"id":"~y","circuit":{"cols":[["~x"],["~x"],["~x"],["~x"]]}},'
'{"id":"~z","circuit":{"cols":[["~y"],["~y"],["~y"],["~y"]]}}'
']}',
max_operation_count=10**6,
)
def test_repr():
circuit = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":'
'['
'[{"id":"setA","arg":3}],'
'["+=AB3",1,1,"inputB2"]'
']}')
op = circuit[0].operations[0]
cirq.testing.assert_equivalent_repr(op)
cirq.testing.assert_equivalent_repr(
cirq.interop.quirk.cells.arithmetic_cells.ArithmeticCell(
'+=A2', cirq.LineQubit.range(2), [cirq.LineQubit.range(2, 5)]))
def test_not_implemented_gates():
# This test mostly exists to ensure the gates are tested if added.
for k in ["X^⌈t⌉", "X^⌈t-¼⌉", "Counting4", "Uncounting4", ">>t3", "<<t3"]:
with pytest.raises(NotImplementedError, match="discrete parameter"):
_ = quirk_url_to_circuit('https://algassert.com/quirk#circuit={'
'"cols":[["' + k + '"]]}')
for k in ["add3", "sub3", "c+=ab4", "c-=ab4"]:
with pytest.raises(NotImplementedError, match="deprecated"):
_ = quirk_url_to_circuit('https://algassert.com/quirk#circuit={'
'"cols":[["' + k + '"]]}')
for k in ["X", "Y", "Z"]:
with pytest.raises(NotImplementedError, match="feedback"):
_ = quirk_url_to_circuit('https://algassert.com/quirk#circuit={"'
'cols":[["' + k +
'DetectControlReset"]]}')
for k in ["|0⟩⟨0|", "|1⟩⟨1|", "|+⟩⟨+|", "|-⟩⟨-|", "|X⟩⟨X|", "|/⟩⟨/|", "0"]:
with pytest.raises(NotImplementedError, match="postselection"):
_ = quirk_url_to_circuit('https://algassert.com/quirk#circuit={'
'"cols":[["' + k + '"]]}')
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_missing_input_cell():
with pytest.raises(ValueError, match='Missing input'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":[["+=A2"]]}')
def test_parse_url_failures(url, error_cls, msg):
with pytest.raises(error_cls, match=msg):
_ = quirk_url_to_circuit(url)
def test_input_rotation_cells():
with pytest.raises(ValueError, match='classical constant'):
_ = quirk_url_to_circuit(
'https://algassert.com/quirk#circuit={"cols":' '[["Z^(A/2^n)",{"id":"setA","arg":3}]]}'
)
with pytest.raises(ValueError, match="Missing input 'a'"):
_ = quirk_url_to_circuit('https://algassert.com/quirk#circuit={"cols":' '[["X^(A/2^n)"]]}')
assert_url_to_circuit_returns(
'{"cols":[["Z^(A/2^n)","inputA2"]]}',
diagram="""
0: ───Z^(A/2^2)───
│
1: ───A0──────────
│
2: ───A1──────────
""",
unitary=np.diag([1, 1, 1, 1, 1j ** 0, 1j ** 0.5, 1j ** 1, 1j ** 1.5]),
)
assert_url_to_circuit_returns(
'{"cols":[["Z^(-A/2^n)","inputA1"]]}', unitary=np.diag([1, 1, 1, -1j])
)
assert_url_to_circuit_returns(
'{"cols":[["H"],["X^(A/2^n)","inputA2"],["H"]]}',
unitary=np.diag([1, 1, 1, 1, 1j ** 0, 1j ** 0.5, 1j ** 1, 1j ** 1.5]),
)
assert_url_to_circuit_returns(
'{"cols":[["H"],["X^(-A/2^n)","inputA2"],["H"]]}',
unitary=np.diag([1, 1, 1, 1, 1j ** 0, 1j ** -0.5, 1j ** -1, 1j ** -1.5]),
)
assert_url_to_circuit_returns(
'{"cols":[["X^-½"],["Y^(A/2^n)","inputA2"],["X^½"]]}',
unitary=np.diag([1, 1, 1, 1, 1j ** 0, 1j ** 0.5, 1j ** 1, 1j ** 1.5]),
)
assert_url_to_circuit_returns(
'{"cols":[["X^-½"],["Y^(-A/2^n)","inputA2"],["X^½"]]}',
unitary=np.diag([1, 1, 1, 1, 1j ** 0, 1j ** -0.5, 1j ** -1, 1j ** -1.5]),
)
assert_url_to_circuit_returns(
'{"cols":[["•","Z^(A/2^n)","inputA2"]]}',
diagram="""
0: ───@───────────
│
1: ───Z^(A/2^2)───
│
2: ───A0──────────
│
3: ───A1──────────
""",
unitary=np.diag([1 + 0j] * 13 + [1j ** 0.5, 1j, 1j ** 1.5]),
)
assert_url_to_circuit_returns(
'{"cols":[["X^(-A/2^n)","inputA2"]]}',
diagram="""
0: ───X^(-A/2^2)───
│
1: ───A0───────────
│
2: ───A1───────────
""",
)
assert_url_to_circuit_returns(
'{"cols":[["•","X^(-A/2^n)","inputA2"]]}',
diagram="""
0: ───@────────────
│
1: ───X^(-A/2^2)───
│
2: ───A0───────────
│
3: ───A1───────────
""",
)
assert_url_to_circuit_returns(
'{"cols":[["Z^(A/2^n)","inputA1","inputB1"],[1,1,"Z"],[1,1,"Z"]]}',
unitary=np.diag([1, 1, 1, 1, 1, 1, 1j, 1j]),
)
def test_input_rotation_cells_repr():
circuit = quirk_url_to_circuit(
'http://algassert.com/quirk#circuit=' '{"cols":[["•","X^(-A/2^n)","inputA2"]]}'
)
op = circuit[0].operations[0]
cirq.testing.assert_equivalent_repr(op)
