def test_executor_explicit(): num_qubits = 8 qubits = cirq.LineQubit.range(num_qubits) circuit = cca.complete_acquaintance_strategy(qubits, 2) gates = {(i, j): ExampleGate([str(k) for k in ij]) for ij in combinations(range(num_qubits), 2) for i, j in (ij, ij[::-1])} initial_mapping = {q: i for i, q in enumerate(sorted(qubits))} execution_strategy = cca.GreedyExecutionStrategy(gates, initial_mapping) executor = cca.StrategyExecutor(execution_strategy) with pytest.raises(NotImplementedError): bad_gates = { (0, ): ExampleGate(['0']), (0, 1): ExampleGate(['0', '1']) } cca.GreedyExecutionStrategy(bad_gates, initial_mapping) with pytest.raises(TypeError): executor(cirq.Circuit()) with pytest.raises(TypeError): bad_strategy = cirq.Circuit.from_ops(cirq.X(qubits[0])) executor(bad_strategy) with pytest.raises(TypeError): op = cirq.X(qubits[0]) bad_strategy = cirq.Circuit.from_ops(op) executor.optimization_at(bad_strategy, 0, op) executor(circuit) expected_text_diagram = """ 0: ───0───1───╲0╱─────────────────1───3───╲0╱─────────────────3───5───╲0╱─────────────────5───7───╲0╱───────────────── │ │ │ │ │ │ │ │ │ │ │ │ 1: ───1───0───╱1╲───0───3───╲0╱───3───1───╱1╲───1───5───╲0╱───5───3───╱1╲───3───7───╲0╱───7───5───╱1╲───5───6───╲0╱─── │ │ │ │ │ │ │ │ │ │ │ │ 2: ───2───3───╲0╱───3───0───╱1╲───0───5───╲0╱───5───1───╱1╲───1───7───╲0╱───7───3───╱1╲───3───6───╲0╱───6───5───╱1╲─── │ │ │ │ │ │ │ │ │ │ │ │ 3: ───3───2───╱1╲───2───5───╲0╱───5───0───╱1╲───0───7───╲0╱───7───1───╱1╲───1───6───╲0╱───6───3───╱1╲───3───4───╲0╱─── │ │ │ │ │ │ │ │ │ │ │ │ 4: ───4───5───╲0╱───5───2───╱1╲───2───7───╲0╱───7───0───╱1╲───0───6───╲0╱───6───1───╱1╲───1───4───╲0╱───4───3───╱1╲─── │ │ │ │ │ │ │ │ │ │ │ │ 5: ───5───4───╱1╲───4───7───╲0╱───7───2───╱1╲───2───6───╲0╱───6───0───╱1╲───0───4───╲0╱───4───1───╱1╲───1───2───╲0╱─── │ │ │ │ │ │ │ │ │ │ │ │ 6: ───6───7───╲0╱───7───4───╱1╲───4───6───╲0╱───6───2───╱1╲───2───4───╲0╱───4───0───╱1╲───0───2───╲0╱───2───1───╱1╲─── │ │ │ │ │ │ │ │ │ │ │ │ 7: ───7───6───╱1╲─────────────────6───4───╱1╲─────────────────4───2───╱1╲─────────────────2───0───╱1╲───────────────── """.strip() ct.assert_has_diagram(circuit, expected_text_diagram)
def test_remove_redundant_acquaintance_opportunities(): device = cca.UnconstrainedAcquaintanceDevice a, b, c, d, e = cirq.LineQubit.range(5) swap = cca.SwapPermutationGate() with pytest.raises(TypeError): ops = [cca.acquaint(a, b)] strategy = cirq.Circuit.from_ops(ops) cca.remove_redundant_acquaintance_opportunities(strategy) ops = [cca.acquaint(a, b), cca.acquaint(a, b)] strategy = cirq.Circuit.from_ops(ops, device=device) diagram_before = """ 0: ───█───█─── │ │ 1: ───█───█─── """ ct.assert_has_diagram(strategy, diagram_before) cca.remove_redundant_acquaintance_opportunities(strategy) cca.remove_redundant_acquaintance_opportunities(strategy) diagram_after = """ 0: ───█─────── │ 1: ───█─────── """ ct.assert_has_diagram(strategy, diagram_after) ops = [ cca.acquaint(a, b), cca.acquaint(c, d), swap(d, e), swap(c, d), cca.acquaint(d, e) ] strategy = cirq.Circuit.from_ops(ops, device=device) diagram_before = """ 0: ───█─────────────────── │ 1: ───█─────────────────── 2: ───█─────────0↦1─────── │ │ 3: ───█───0↦1───1↦0───█─── │ │ 4: ───────1↦0─────────█─── """ ct.assert_has_diagram(strategy, diagram_before) cca.remove_redundant_acquaintance_opportunities(strategy) diagram_after = """ 0: ───█─────────────────── │ 1: ───█─────────────────── 2: ───█─────────0↦1─────── │ │ 3: ───█───0↦1───1↦0─────── │ 4: ───────1↦0───────────── """ ct.assert_has_diagram(strategy, diagram_after)
def test_remove_redundant_acquaintance_opportunities(): a, b, c, d, e = cirq.LineQubit.range(5) swap = cca.SwapPermutationGate() ops = [cca.acquaint(a, b), cca.acquaint(a, b)] strategy = cirq.Circuit(ops) diagram_before = """ 0: ───█───█─── │ │ 1: ───█───█─── """ ct.assert_has_diagram(strategy, diagram_before) cca.remove_redundant_acquaintance_opportunities(strategy) diagram_after = """ 0: ───█─────── │ 1: ───█─────── """ ct.assert_has_diagram(strategy, diagram_after) ops = [ cca.acquaint(a, b), cca.acquaint(c, d), swap(d, e), swap(c, d), cca.acquaint(d, e) ] strategy = cirq.Circuit(ops) diagram_before = """ 0: ───█─────────────────── │ 1: ───█─────────────────── 2: ───█─────────0↦1─────── │ │ 3: ───█───0↦1───1↦0───█─── │ │ 4: ───────1↦0─────────█─── """ ct.assert_has_diagram(strategy, diagram_before) cca.remove_redundant_acquaintance_opportunities(strategy) diagram_after = """ 0: ───█─────────────────── │ 1: ───█─────────────────── 2: ───█─────────0↦1─────── │ │ 3: ───█───0↦1───1↦0─────── │ 4: ───────1↦0───────────── """ ct.assert_has_diagram(strategy, diagram_after)
def test_swap_network_decomposition(): qubits = cirq.LineQubit.range(8) swap_network_gate = cca.SwapNetworkGate((4, 4), 5) operations = cirq.decompose_once_with_qubits(swap_network_gate, qubits) circuit = cirq.Circuit(operations) expected_text_diagram = """ 0: ───█─────────────█─────────────╲0╱─────────────█─────────█───────0↦2─── │ │ │ │ │ │ 1: ───█─────────────█─────────────╲1╱─────────────█─────────█───────1↦3─── │ │ │ │ │ │ 2: ───█─────────────█───1↦0───────╲2╱───────1↦0───█─────────█───────2↦0─── │ │ │ │ │ │ │ │ 3: ───█───█─────────█───0↦1───█───╲3╱───█───0↦1───█─────────█───█───3↦1─── │ │ │ │ │ │ │ │ │ │ 4: ───█───█───0↦1───█─────────█───╱4╲───█─────────█───0↦1───█───█───4↦6─── │ │ │ │ │ │ │ │ 5: ───────█───1↦0─────────────█───╱5╲───█─────────────1↦0───────█───5↦7─── │ │ │ │ │ │ 6: ───────█───────────────────█───╱6╲───█───────────────────────█───6↦4─── │ │ │ │ │ │ 7: ───────█───────────────────█───╱7╲───█───────────────────────█───7↦5─── """.strip() ct.assert_has_diagram(circuit, expected_text_diagram)
def test_swap_network_gate(): qubits = tuple(cirq.NamedQubit(s) for s in alphabet) acquaintance_size = 3 n_parts = 3 part_lens = (acquaintance_size - 1, ) * n_parts n_qubits = sum(part_lens) swap_network_op = cca.SwapNetworkGate( part_lens, acquaintance_size=acquaintance_size)(*qubits[:n_qubits]) swap_network = cirq.Circuit(swap_network_op) expected_text_diagram = """ a: ───×(0,0)─── │ b: ───×(0,1)─── │ c: ───×(1,0)─── │ d: ───×(1,1)─── │ e: ───×(2,0)─── │ f: ───×(2,1)─── """.strip() ct.assert_has_diagram(swap_network, expected_text_diagram) no_decomp = lambda op: isinstance(op.gate, (cca.CircularShiftGate, cca. LinearPermutationGate)) expander = cirq.ExpandComposite(no_decomp=no_decomp) expander(swap_network) expected_text_diagram = """ a: ───█───────╲0╱───█─────────────────█───────────╲0╱───█───────0↦1─── │ │ │ │ │ │ │ b: ───█───█───╲1╱───█───█─────────────█───█───────╲1╱───█───█───1↦0─── │ │ │ │ │ │ │ │ │ │ │ c: ───█───█───╱2╲───█───█───█───╲0╱───█───█───█───╱2╲───█───█───2↦3─── │ │ │ │ │ │ │ │ │ │ d: ───────█───╱3╲───█───█───█───╲1╱───█───█───█───╱3╲───────█───3↦2─── │ │ │ │ │ │ e: ─────────────────█───────█───╱2╲───█───────█─────────────────4↦5─── │ │ │ │ f: ─────────────────█───────────╱3╲───█─────────────────────────5↦4─── """.strip() ct.assert_has_diagram(swap_network, expected_text_diagram) no_decomp = lambda op: isinstance(op.gate, cca.CircularShiftGate) expander = cirq.ExpandComposite(no_decomp=no_decomp) acquaintance_size = 3 n_parts = 6 part_lens = (1, ) * n_parts n_qubits = sum(part_lens) swap_network_op = cca.SwapNetworkGate( part_lens, acquaintance_size=acquaintance_size)(*qubits[:n_qubits]) swap_network = cirq.Circuit(swap_network_op) expander(swap_network) expected_text_diagram = """ a: ───╲0╱─────────╲0╱─────────╲0╱───────── │ │ │ b: ───╱1╲───╲0╱───╱1╲───╲0╱───╱1╲───╲0╱─── │ │ │ c: ───╲0╱───╱1╲───╲0╱───╱1╲───╲0╱───╱1╲─── │ │ │ d: ───╱1╲───╲0╱───╱1╲───╲0╱───╱1╲───╲0╱─── │ │ │ e: ───╲0╱───╱1╲───╲0╱───╱1╲───╲0╱───╱1╲─── │ │ │ f: ───╱1╲─────────╱1╲─────────╱1╲───────── """.strip() ct.assert_has_diagram(swap_network, expected_text_diagram)