def test_executor_explicit(): n_qubits = 8 qubits = cirq.LineQubit.range(n_qubits) circuit = complete_acquaintance_strategy(qubits, 2) gates = {(i, j): ExampleGate([str(k) for k in ij]) for ij in combinations(range(n_qubits), 2) for i, j in (ij, ij[::-1])} initial_mapping = {q: i for i, q in enumerate(sorted(qubits))} execution_strategy = GreedyExecutionStrategy(gates, initial_mapping) executor = StrategyExecutor(execution_strategy) with pytest.raises(NotImplementedError): bad_gates = { (0, ): ExampleGate(['0']), (0, 1): ExampleGate(['0', '1']) } 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) actual_text_diagram = circuit.to_text_diagram().strip() 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() print(actual_text_diagram) assert actual_text_diagram == expected_text_diagram
def test_executor_random(n_qubits: int, acquaintance_size: int, gates: Dict[Tuple[cirq.QubitId, ...], cirq.Gate]): qubits = cirq.LineQubit.range(n_qubits) circuit = complete_acquaintance_strategy(qubits, acquaintance_size) logical_circuit = cirq.Circuit.from_ops([g(*Q) for Q, g in gates.items()]) expected_unitary = logical_circuit.to_unitary_matrix() initial_mapping = {q: q for q in qubits} execution_strategy = GreedyExecutionStrategy(gates, initial_mapping) executor = StrategyExecutor(execution_strategy) final_mapping = executor(circuit) permutation = {q.x: qq.x for q, qq in final_mapping.items()} circuit.append(LinearPermutationGate(permutation)(*qubits)) actual_unitary = circuit.to_unitary_matrix() np.testing.assert_allclose(actual=actual_unitary, desired=expected_unitary, verbose=True)
def test_complete_acquaintance_strategy(): qubits = [cirq.NamedQubit(s) for s in alphabet] with pytest.raises(ValueError): _ = complete_acquaintance_strategy(qubits, -1) empty_strategy = complete_acquaintance_strategy(qubits) assert empty_strategy._moments == [] trivial_strategy = complete_acquaintance_strategy(qubits[:4], 1) actual_text_diagram = trivial_strategy.to_text_diagram().strip() expected_text_diagram = """ a: ───█─── b: ───█─── c: ───█─── d: ───█─── """.strip() assert actual_text_diagram == expected_text_diagram assert get_acquaintance_size(trivial_strategy) == 1 is_shift_or_lin_perm = lambda op: isinstance(op.gate, ( CircularShiftGate, LinearPermutationGate)) expand = cirq.ExpandComposite(no_decomp=is_shift_or_lin_perm) quadratic_strategy = complete_acquaintance_strategy(qubits[:8], 2) actual_text_diagram = quadratic_strategy.to_text_diagram().strip() expected_text_diagram = """ a: ───×(0,0)─── │ b: ───×(1,0)─── │ c: ───×(2,0)─── │ d: ───×(3,0)─── │ e: ───×(4,0)─── │ f: ───×(5,0)─── │ g: ───×(6,0)─── │ h: ───×(7,0)─── """.strip() assert actual_text_diagram == expected_text_diagram assert get_acquaintance_size(quadratic_strategy) == 2 expand(quadratic_strategy) actual_text_diagram = quadratic_strategy.to_text_diagram( transpose=True).strip() expected_text_diagram = '\n'.join( ("a b c d e f g h ".strip(), "│ │ │ │ │ │ │ │ ".strip(), "█───█ █───█ █───█ █───█ ".strip(), "│ │ │ │ │ │ │ │ ".strip(), "╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ ".strip(), "│ │ │ │ │ │ │ │ ".strip(), "│ █───█ █───█ █───█ │ ".strip(), "│ │ │ │ │ │ │ │ ".strip(), "│ ╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ │ ".strip(), "│ │ │ │ │ │ │ │ ".strip(), "█───█ █───█ █───█ █───█ ".strip(), "│ │ │ │ │ │ │ │ ".strip(), "╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ ".strip(), "│ │ │ │ │ │ │ │ ".strip(), "│ █───█ █───█ █───█ │ ".strip(), "│ │ │ │ │ │ │ │ ".strip(), "│ ╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ │ ".strip(), "│ │ │ │ │ │ │ │ ".strip(), "█───█ █───█ █───█ █───█ ".strip(), "│ │ │ │ │ │ │ │ ".strip(), "╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ ".strip(), "│ │ │ │ │ │ │ │ ".strip(), "│ █───█ █───█ █───█ │ ".strip(), "│ │ │ │ │ │ │ │ ".strip(), "│ ╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ │ ".strip(), "│ │ │ │ │ │ │ │ ".strip(), "█───█ █───█ █───█ █───█ ".strip(), "│ │ │ │ │ │ │ │ ".strip(), "╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ ".strip(), "│ │ │ │ │ │ │ │ ".strip(), "│ █───█ █───█ █───█ │ ".strip(), "│ │ │ │ │ │ │ │ ".strip(), "│ ╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ │ ".strip(), "│ │ │ │ │ │ │ │ ".strip())) assert actual_text_diagram == expected_text_diagram assert get_acquaintance_size(quadratic_strategy) == 2 cubic_strategy = complete_acquaintance_strategy(qubits[:4], 3) actual_text_diagram = cubic_strategy.to_text_diagram( transpose=True).strip() expected_text_diagram = """ a b c d │ │ │ │ ×(0,0)─×(0,1)─×(1,0)─×(1,1) │ │ │ │ ╱1╲────╲0╱ ╱1╲────╲0╱ │ │ │ │ ×(0,0)─×(1,0)─×(1,1)─×(2,0) │ │ │ │ │ ╲0╱────╱1╲ │ │ │ │ │ ×(0,0)─×(0,1)─×(1,0)─×(1,1) │ │ │ │ ╱1╲────╲0╱ ╱1╲────╲0╱ │ │ │ │ ×(0,0)─×(1,0)─×(1,1)─×(2,0) │ │ │ │ │ ╲0╱────╱1╲ │ │ │ │ │ """.strip() assert actual_text_diagram == expected_text_diagram assert get_acquaintance_size(cubic_strategy) == 3