def test_shift_swap_network_gate_acquaintance_opps(left_part_lens,
right_part_lens):
gate = cca.ShiftSwapNetworkGate(left_part_lens, right_part_lens)
n_qubits = gate.qubit_count()
qubits = cirq.LineQubit.range(n_qubits)
strategy = cirq.Circuit(gate(*qubits),
device=cca.UnconstrainedAcquaintanceDevice)
# actual_opps
initial_mapping = {q: i for i, q in enumerate(qubits)}
actual_opps = cca.get_logical_acquaintance_opportunities(
strategy, initial_mapping)
# expected opps
i = 0
sides = ('left', 'right')
parts = {side: [] for side in sides}
for side, part_lens in zip(sides, (left_part_lens, right_part_lens)):
for part_len in part_lens:
parts[side].append(set(range(i, i + part_len)))
i += part_len
expected_opps = set(
frozenset(left_part | right_part) for left_part, right_part in
itertools.product(parts['left'], parts['right']))
assert actual_opps == expected_opps
def test_get_logical_acquaintance_opportunities(n_qubits, acquaintance_size):
qubits = cirq.LineQubit.range(n_qubits)
acquaintance_strategy = cca.complete_acquaintance_strategy(
qubits, acquaintance_size)
initial_mapping = {q: i for i, q in enumerate(qubits)}
opps = cca.get_logical_acquaintance_opportunities(
acquaintance_strategy, initial_mapping)
assert opps == set(frozenset(s) for s in
combinations(range(n_qubits), acquaintance_size))
def test_cubic_acquaintance_strategy(n_qubits):
qubits = tuple(cirq.LineQubit.range(n_qubits))
strategy = cca.cubic_acquaintance_strategy(qubits)
initial_mapping = {q: i for i, q in enumerate(qubits)}
opps = cca.get_logical_acquaintance_opportunities(strategy,
initial_mapping)
assert set(len(opp) for opp in opps) == set([3])
expected_opps = set(
frozenset(ijk) for ijk in itertools.combinations(range(n_qubits), 3))
assert opps == expected_opps
def test_acquaint_part_pairs(part_lens):
parts = []
n_qubits = 0
for part_len in part_lens:
parts.append(tuple(range(n_qubits, n_qubits + part_len)))
n_qubits += part_len
qubits = cirq.LineQubit.range(n_qubits)
swap_network_op = cca.SwapNetworkGate(part_lens, acquaintance_size=None)(*qubits)
swap_network = cirq.Circuit(swap_network_op)
initial_mapping = {q: i for i, q in enumerate(qubits)}
actual_opps = cca.get_logical_acquaintance_opportunities(swap_network, initial_mapping)
expected_opps = set(frozenset(s + t) for s, t in combinations(parts, 2))
assert expected_opps == actual_opps
def get_phase_sep_circuit(
gates: LogicalGates,
qubits: Sequence[cirq.Qid],
initial_mapping: LogicalMapping,
verbose: bool = True,
):
# An acquaintance strategy containing permutation gates and acquaintance
# opportunity gates.
circuit = cca.complete_acquaintance_strategy(qubits, 2)
if verbose:
print('Circuit containing a single complete linear swap network:')
print(circuit)
print('\n\n')
acquaintance_opportunities = cca.get_logical_acquaintance_opportunities(
circuit, initial_mapping
)
assert set(frozenset(edge) for edge in gates) <= acquaintance_opportunities
cca.expose_acquaintance_gates(circuit)
if verbose:
print('Circuit with acquaintance opportunities show explicitly:')
print(circuit)
print('\n\n')
# The greedy execution strategy replaces inserts the logical gates into the
# circuit at the first opportunity.
execution_strategy = cca.GreedyExecutionStrategy(gates, initial_mapping)
# The final mapping may be different from the initial one.
# In this case, the mapping is simply reversed
final_mapping = execution_strategy(circuit)
for p, q in zip(qubits, reversed(qubits)):
assert initial_mapping[p] == final_mapping[q]
if verbose:
print('Circuit with logical gates:')
print(circuit)
print('\n\n')
# All of the operations act on adjacent qubits now
positions = {q: x for x, q in enumerate(qubits)}
for op in circuit.all_operations():
p, q = op.qubits
assert abs(positions[p] - positions[q]) == 1
return circuit
def test_quartic_paired_acquaintances(index_pairs):
n_pairs = len(index_pairs)
qubit_pairs = tuple(
tuple(cirq.LineQubit(x) for x in index_pair)
for index_pair in index_pairs)
strategy, qubits = cca.quartic_paired_acquaintance_strategy(qubit_pairs)
initial_mapping = {q: q.x for q in qubits}
opps = cca.get_logical_acquaintance_opportunities(strategy,
initial_mapping)
assert set(len(opp) for opp in opps) == set([2, 4])
quadratic_opps = set(opp for opp in opps if len(opp) == 2)
expected_quadratic_opps = set(
frozenset(index_pair)
for index_pair in itertools.combinations(range(2 * n_pairs), 2))
assert quadratic_opps == expected_quadratic_opps
quartic_opps = set(opp for opp in opps if len(opp) == 4)
expected_quartic_opps = set(
frozenset(I + J) for I, J in itertools.combinations(index_pairs, 2))
assert quartic_opps == expected_quartic_opps
