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