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