def test_get_acquaintance_size():
qubits = cirq.LineQubit.range(5)
op = OtherOperation(qubits)
assert op.with_qubits(qubits) == op
assert get_acquaintance_size(op) == 0
for s, _ in enumerate(qubits):
op = ACQUAINT(*qubits[:s + 1])
assert get_acquaintance_size(op) == s + 1
part_lens = (2, 2, 2, 2)
acquaintance_size = 3
gate = SwapNetworkGate(part_lens, acquaintance_size)
op = gate(*qubits[:sum(part_lens)])
assert get_acquaintance_size(op) == 3
part_lens = (2, 2, 2, 2)
acquaintance_size = 4
gate = SwapNetworkGate(part_lens, acquaintance_size)
op = gate(*qubits[:sum(part_lens)])
assert get_acquaintance_size(op) == 0
part_lens = (2, 2, 2, 2)
acquaintance_size = 1
gate = SwapNetworkGate(part_lens, acquaintance_size)
op = gate(*qubits[:sum(part_lens)])
assert get_acquaintance_size(op) == 0
part_lens = (2, 2, 2, 2)
acquaintance_size = 1
gate = SwapNetworkGate(part_lens, acquaintance_size)
op = gate(*qubits[:sum(part_lens)])
assert get_acquaintance_size(op) == 0
def test_swap_network_permutation(part_lens, acquaintance_size):
n_qubits = sum(part_lens)
gate = SwapNetworkGate(part_lens, acquaintance_size)
expected_permutation = {
i: j
for i, j in zip(range(n_qubits), reversed(range(n_qubits)))
}
assert gate.permutation(n_qubits) == expected_permutation
def test_swap_network_gate_permutation(part_lens, acquaintance_size):
n_qubits = sum(part_lens)
qubits = cirq.LineQubit.range(n_qubits)
swap_network_gate = SwapNetworkGate(part_lens, acquaintance_size)
operations = cirq.decompose_once_with_qubits(swap_network_gate, qubits)
operations = list(cirq.flatten_op_tree(operations))
mapping = {q: i for i, q in enumerate(qubits)}
update_mapping(mapping, operations)
assert mapping == {q: i for i, q in enumerate(reversed(qubits))}
def test_acquaintance_device():
with pytest.raises(ValueError):
op = cirq.X(cirq.NamedQubit('q'))
UnconstrainedAcquaintanceDevice.validate_operation(op)
qubits = cirq.LineQubit.range(4)
ACQUAINT = AcquaintanceOpportunityGate()
swap_network = SwapNetworkGate((1, 2, 1))
UnconstrainedAcquaintanceDevice.validate_operation(ACQUAINT(*qubits[:2]))
UnconstrainedAcquaintanceDevice.validate_operation(swap_network(*qubits))
def quartic_paired_acquaintance_strategy(
qubit_pairs: Iterable[Tuple['cirq.Qid', ops.Qid]]
) -> Tuple['cirq.Circuit', Sequence['cirq.Qid']]:
"""Acquaintance strategy for pairs of pairs.
Implements UpCCGSD ansatz from arXiv:1810.02327.
"""
qubit_pairs = tuple(
cast(Tuple['cirq.Qid', ops.Qid], tuple(qubit_pair)) for qubit_pair in qubit_pairs
)
qubits = qubit_pairs_to_qubit_order(qubit_pairs)
n_qubits = len(qubits)
swap_network = SwapNetworkGate((1,) * n_qubits, 2)(*qubits)
strategy = circuits.Circuit(swap_network, device=UnconstrainedAcquaintanceDevice)
expose_acquaintance_gates(strategy)
for i in reversed(range(0, n_qubits, 2)):
moment = ops.Moment([acquaint(*qubits[j : j + 4]) for j in range(i % 4, n_qubits - 3, 4)])
strategy.insert(2 * i, moment)
return strategy, qubits
def test_swap_network_decomposition():
qubits = cirq.LineQubit.range(8)
swap_network_gate = SwapNetworkGate((4, 4), 5)
operations = cirq.decompose_once_with_qubits(swap_network_gate, qubits)
circuit = cirq.Circuit.from_ops(operations)
actual_text_diagram = circuit.to_text_diagram()
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───█───█───0↦2───
│ │ │ │ │ │ │ │
5: ───────█───1↦0─────────────█───╱5╲───█─────────────1↦0───────█───1↦3───
│ │ │ │ │ │
6: ───────█───────────────────█───╱6╲───█───────────────────────█───2↦0───
│ │ │ │ │ │
7: ───────█───────────────────█───╱7╲───█───────────────────────█───3↦1───
""".strip()
assert actual_text_diagram == 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 = SwapNetworkGate(
part_lens, acquaintance_size=acquaintance_size)(*qubits[:n_qubits])
swap_network = cirq.Circuit.from_ops(swap_network_op)
actual_text_diagram = swap_network.to_text_diagram().strip()
expected_text_diagram = """
a: ───×(0,0)───
│
b: ───×(0,1)───
│
c: ───×(1,0)───
│
d: ───×(1,1)───
│
e: ───×(2,0)───
│
f: ───×(2,1)───
""".strip()
assert actual_text_diagram == expected_text_diagram
no_decomp = lambda op: isinstance(op.gate, (CircularShiftGate,
LinearPermutationGate))
expander = cirq.ExpandComposite(no_decomp=no_decomp)
expander(swap_network)
actual_text_diagram = swap_network.to_text_diagram().strip()
expected_text_diagram = """
a: ───█───────╲0╱───█─────────────────█───────────╲0╱───█───────0↦1───
│ │ │ │ │ │ │
b: ───█───█───╲1╱───█───█─────────────█───█───────╲1╱───█───█───1↦0───
│ │ │ │ │ │ │ │ │ │
c: ───█───█───╱2╲───█───█───█───╲0╱───█───█───█───╱2╲───█───█───0↦1───
│ │ │ │ │ │ │ │ │ │
d: ───────█───╱3╲───█───█───█───╲1╱───█───█───█───╱3╲───────█───1↦0───
│ │ │ │ │
e: ─────────────────█───────█───╱2╲───█───────█───0↦1─────────────────
│ │ │ │
f: ─────────────────█───────────╱3╲───█───────────1↦0─────────────────
""".strip()
assert actual_text_diagram == expected_text_diagram
no_decomp = lambda op: isinstance(op.gate, 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 = SwapNetworkGate(
part_lens, acquaintance_size=acquaintance_size)(*qubits[:n_qubits])
swap_network = cirq.Circuit.from_ops(swap_network_op)
expander(swap_network)
actual_text_diagram = swap_network.to_text_diagram().strip()
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()
assert actual_text_diagram == expected_text_diagram
def test_swap_network_permutation_error():
gate = SwapNetworkGate((1, 1))
with pytest.raises(ValueError):
gate.permutation(1)
def test_swap_network_init_error():
with pytest.raises(ValueError):
SwapNetworkGate(())
with pytest.raises(ValueError):
SwapNetworkGate((3, ))