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 = swap_network_gate.default_decompose(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 test_swap_network_gate_from_ops():
n_qubits = 10
qubits = cirq.LineQubit.range(n_qubits)
part_lens = (1, 2, 1, 3, 3)
operations = [
cirq.Z(qubits[0]),
cirq.CZ(*qubits[1:3]),
cirq.CCZ(*qubits[4:7]),
cirq.CCZ(*qubits[7:])
]
acquaintance_size = 3
swap_network = SwapNetworkGate.from_operations(qubits, operations,
acquaintance_size)
assert swap_network.acquaintance_size == acquaintance_size
assert swap_network.part_lens == part_lens
def test_swap_network_decomposition():
qubits = cirq.LineQubit.range(8)
swap_network_gate = SwapNetworkGate((4, 4), 5)
operations = swap_network_gate.default_decompose(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 replace_acquaintance_with_swap_network(
circuit: 'cirq.Circuit',
qubit_order: Sequence['cirq.Qid'],
acquaintance_size: Optional[int] = 0,
swap_gate: 'cirq.Gate' = ops.SWAP,
) -> bool:
"""
Replace every moment containing acquaintance gates (after
rectification) with a generalized swap network, with the partition
given by the acquaintance gates in that moment (and singletons for the
free qubits). Accounts for reversing effect of swap networks.
Args:
circuit: The acquaintance strategy.
qubit_order: The qubits, in order, on which the replacing swap network
gate acts on.
acquaintance_size: The acquaintance size of the new swap network gate.
swap_gate: The gate used to swap logical indices.
Returns: Whether or not the overall effect of the inserted swap network
gates is to reverse the order of the qubits, i.e. the parity of the
number of swap network gates inserted.
Raises:
TypeError: circuit is not an acquaintance strategy.
"""
if not is_acquaintance_strategy(circuit):
raise TypeError('not is_acquaintance_strategy(circuit)')
rectify_acquaintance_strategy(circuit)
reflected = False
reverse_map = {q: r for q, r in zip(qubit_order, reversed(qubit_order))}
for moment_index, moment in enumerate(circuit):
if reflected:
moment = moment.transform_qubits(reverse_map.__getitem__)
if all(
isinstance(op.gate, AcquaintanceOpportunityGate)
for op in moment.operations):
swap_network_gate = SwapNetworkGate.from_operations(
qubit_order, moment.operations, acquaintance_size, swap_gate)
swap_network_op = swap_network_gate(*qubit_order)
moment = ops.Moment([swap_network_op])
reflected = not reflected
circuit._moments[moment_index] = moment
return reflected
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_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, ))