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)
