def test_compile_circuit_multiple_routing_attempts():
"""Tests that we make multiple attempts at r
outing and keep the best one."""
qubits = cirq.LineQubit.range(3)
initial_mapping = dict(zip(qubits, qubits))
badly_routed = cirq.Circuit([
cirq.X.on_each(qubits),
cirq.Y.on_each(qubits),
])
well_routed = cirq.Circuit([
cirq.X.on_each(qubits),
])
router_mock = MagicMock(side_effect=[
ccr.SwapNetwork(badly_routed, initial_mapping),
ccr.SwapNetwork(well_routed, initial_mapping),
])
compiler_mock = MagicMock(side_effect=lambda circuit: circuit)
model_circuit = cirq.Circuit([cirq.X.on_each(qubits)])
swap_network = cirq.contrib.quantum_volume.compile_circuit(
model_circuit,
device=cirq.google.Bristlecone,
compiler=compiler_mock,
router=router_mock,
routing_attempts=2)
assert swap_network.final_mapping() == initial_mapping
assert router_mock.call_count == 2
compiler_mock.assert_called_with(well_routed)
def test_compile_circuit_multiple_routing_attempts():
"""Tests that we make multiple attempts at routing and keep the best one."""
qubits = cirq.LineQubit.range(3)
initial_mapping = dict(zip(qubits, qubits))
more_operations = cirq.Circuit([
cirq.X.on_each(qubits),
cirq.Y.on_each(qubits),
])
more_qubits = cirq.Circuit([
cirq.X.on_each(cirq.LineQubit.range(4)),
])
well_routed = cirq.Circuit([
cirq.X.on_each(qubits),
])
router_mock = MagicMock(side_effect=[
ccr.SwapNetwork(more_operations, initial_mapping),
ccr.SwapNetwork(well_routed, initial_mapping),
ccr.SwapNetwork(more_qubits, initial_mapping),
])
compiler_mock = MagicMock(side_effect=lambda circuit: circuit)
model_circuit = cirq.Circuit([cirq.X.on_each(qubits)])
compilation_result = cirq.contrib.quantum_volume.compile_circuit(
model_circuit,
device_graph=ccr.xmon_device_to_graph(cirq.google.Bristlecone),
compiler=compiler_mock,
router=router_mock,
routing_attempts=3)
assert compilation_result.mapping == initial_mapping
assert router_mock.call_count == 3
compiler_mock.assert_called_with(well_routed)
def test_swap_network_bad_args():
n_qubits = 10
qubits = cirq.LineQubit.range(n_qubits)
circuit = cirq.Circuit()
with pytest.raises(ValueError):
initial_mapping = dict(zip(qubits, range(n_qubits)))
ccr.SwapNetwork(circuit, initial_mapping)
with pytest.raises(ValueError):
initial_mapping = dict(zip(range(n_qubits), qubits))
ccr.SwapNetwork(circuit, initial_mapping)
def test_swap_network_equality(circuits):
et = cirq.testing.EqualsTester()
for circuit in circuits: # NB: tiny prob. that circuits aren't unique
qubits = sorted(circuit.all_qubits())
for y in (0, 1):
mapping = {cirq.GridQubit(x, y): q for x, q in enumerate(qubits)}
et.add_equality_group(ccr.SwapNetwork(circuit, mapping))
def test_compile_circuit_with_readout_correction():
"""Tests that we are able to compile a model circuit with readout error
correction."""
compiler_mock = MagicMock(side_effect=lambda circuit: circuit)
router_mock = MagicMock(
side_effect=lambda circuit, network: ccr.SwapNetwork(circuit, {}))
a, b, c = cirq.LineQubit.range(3)
ap, bp, cp = cirq.LineQubit.range(3, 6)
model_circuit = cirq.Circuit([
cirq.Moment([cirq.X(a), cirq.Y(b), cirq.Z(c)]),
])
compilation_result = cirq.contrib.quantum_volume.compile_circuit(
model_circuit,
device_graph=ccr.xmon_device_to_graph(cirq.google.Bristlecone),
compiler=compiler_mock,
router=router_mock,
routing_attempts=1,
add_readout_error_correction=True)
assert compilation_result.circuit == cirq.Circuit([
cirq.Moment([cirq.X(a), cirq.Y(b), cirq.Z(c)]),
cirq.Moment([cirq.X(a), cirq.X(b), cirq.X(c)]),
cirq.Moment([cirq.CNOT(a, ap),
cirq.CNOT(b, bp),
cirq.CNOT(c, cp)]),
cirq.Moment([cirq.X(a), cirq.X(b), cirq.X(c)]),
])
def test_swap_network_str():
n_qubits = 5
phys_qubits = cirq.GridQubit.rect(n_qubits, 1)
log_qubits = cirq.LineQubit.range(n_qubits)
gates = {(l, ll): cirq.ZZ
for l, ll in itertools.combinations(log_qubits, 2)}
initial_mapping = {p: l for p, l in zip(phys_qubits, log_qubits)}
execution_strategy = cca.GreedyExecutionStrategy(gates, initial_mapping)
routed_circuit = cca.complete_acquaintance_strategy(phys_qubits, 2)
execution_strategy(routed_circuit)
swap_network = ccr.SwapNetwork(routed_circuit, initial_mapping)
actual_str = str(swap_network)
expected_str = """
(0, 0): ───0───ZZ───0───╲0╱───1────────1─────────1───ZZ───1───╲0╱───3────────3─────────3───ZZ───3───╲0╱───4───
│ │ │ │ │ │
(1, 0): ───1───ZZ───1───╱1╲───0───ZZ───0───╲0╱───3───ZZ───3───╱1╲───1───ZZ───1───╲0╱───4───ZZ───4───╱1╲───3───
│ │ │ │
(2, 0): ───2───ZZ───2───╲0╱───3───ZZ───3───╱1╲───0───ZZ───0───╲0╱───4───ZZ───4───╱1╲───1───ZZ───1───╲0╱───2───
│ │ │ │ │ │
(3, 0): ───3───ZZ───3───╱1╲───2───ZZ───2───╲0╱───4───ZZ───4───╱1╲───0───ZZ───0───╲0╱───2───ZZ───2───╱1╲───1───
│ │ │ │
(4, 0): ───4────────4─────────4───ZZ───4───╱1╲───2────────2─────────2───ZZ───2───╱1╲───0────────0─────────0───
""".strip()
assert actual_str == expected_str
def test_sample_heavy_set_with_parity():
"""Test that we correctly sample a circuit's heavy set with a parity map"""
sampler = Mock(spec=cirq.Simulator)
# Construct a result that returns [1, 0, 1, 0] for the physical qubit
# measurement, and [0, 1, 1, 0] for the ancilla qubit measurement. The first
# bitstring "10" is valid and heavy. The second "01" is valid and not
# heavy. The third and fourth bitstraings "11" and "00" are not valid and
# dropped.
result = cirq.TrialResult.from_single_parameter_set(
params=cirq.ParamResolver({}),
measurements={
'0': np.array([[1], [0]]),
'1': np.array([[0], [1]]),
'2': np.array([[1], [1]]),
'3': np.array([[0], [0]])
})
sampler.run = MagicMock(return_value=result)
circuit = cirq.Circuit(cirq.measure(*cirq.LineQubit.range(4)))
compilation_result = CompilationResult(
swap_network=ccr.SwapNetwork(circuit,
{q: q
for q in cirq.LineQubit.range(4)}),
parity_map={
cirq.LineQubit(0): cirq.LineQubit(1),
cirq.LineQubit(2): cirq.LineQubit(3)
})
probability = cirq.contrib.quantum_volume.sample_heavy_set(
compilation_result, [1], sampler=sampler, repetitions=1)
# The first output is in the heavy set. The second one isn't, but it is
# dropped.
assert probability == .5
def test_final_mapping():
n_qubits = 10
qubits = cirq.LineQubit.range(n_qubits)
initial_mapping = dict(zip(qubits, qubits))
expected_final_mapping = dict(zip(qubits, reversed(qubits)))
SWAP = cca.SwapPermutationGate()
circuit = cirq.Circuit(
cirq.Moment(
SWAP(*qubits[i:i + 2]) for i in range(l % 2, n_qubits - 1, 2))
for l in range(n_qubits))
swap_network = ccr.SwapNetwork(circuit, initial_mapping)
assert swap_network.final_mapping() == expected_final_mapping
def test_is_valid_routing_with_bad_args():
p, q, r = cirq.LineQubit.range(3)
x, y = cirq.NamedQubit('x'), cirq.NamedQubit('y')
circuit = cirq.Circuit([cirq.CNOT(x, y), cirq.CZ(x, y)])
routed_circuit = cirq.Circuit([cirq.CNOT(p, q), cirq.CZ(q, r)])
initial_mapping = {p: x, q: y}
swap_network = ccr.SwapNetwork(routed_circuit, initial_mapping)
assert not ccr.is_valid_routing(circuit, swap_network)
def equals(*args):
raise ValueError
with pytest.raises(ValueError):
ccr.is_valid_routing(circuit, swap_network, equals=equals)
def test_sample_heavy_set():
"""Test that we correctly sample a circuit's heavy set"""
sampler = Mock(spec=cirq.Simulator)
# Construct a result that returns "1", "2", "3", "0"
result = cirq.TrialResult.from_single_parameter_set(
params=cirq.ParamResolver({}),
measurements={'mock': np.array([[0, 1], [1, 0], [1, 1], [0, 0]])})
sampler.run = MagicMock(return_value=result)
circuit = cirq.Circuit(cirq.measure(*cirq.LineQubit.range(2)))
compilation_result = CompilationResult(swap_network=ccr.SwapNetwork(
circuit, {}),
parity_map={})
probability = cirq.contrib.quantum_volume.sample_heavy_set(
compilation_result, [1, 2, 3], sampler=sampler, repetitions=10)
# The first 3 of our outputs are in the heavy set, and then the rest are
# not.
assert probability == .75
