def test_two_operations_on_single_qubit():
"""Tests that a new qubit is NOT allocated for every gate."""
qubit = cirq.NamedQubit("a")
c = cirq.Circuit(*[cirq.X(qubit)] * 99)
device = cirq.google.Sycamore23
t = ct.ConnectivityHeuristicCircuitTransformer(device)
device.validate_circuit(t.transform(c))
def test_edges_within(device):
"""
The circuit looks like:
a1 --- a4 --- a3 --- a2 d1
| | |
b2 b1 --- c3
"""
transformer = ct.ConnectivityHeuristicCircuitTransformer(device)
circuit = cirq.Circuit(cirq.X(d1),
cirq.ISWAP(a1, a4)**0.5, cirq.ISWAP(a4, b2),
cirq.ISWAP(a4, a3), cirq.ISWAP(a3, b1),
cirq.ISWAP(a3, a2), cirq.ISWAP(b1, c3),
cirq.ISWAP(a2, c3))
graph = {}
for moment in circuit:
for op in moment:
if len(op.qubits) == 2:
q1, q2 = op.qubits
if q1 not in graph:
graph[q1] = []
if q2 not in graph:
graph[q2] = []
if q2 not in graph[q1]:
graph[q1].append(q2)
if q1 not in graph[q2]:
graph[q2].append(q1)
assert transformer.edges_within(0, cirq.NamedQubit('a3'), graph,
set()) == 1
assert transformer.edges_within(1, cirq.NamedQubit('a3'), graph,
set()) == 4
assert transformer.edges_within(2, cirq.NamedQubit('a3'), graph,
set()) == 7
assert transformer.edges_within(10, cirq.NamedQubit('a3'), graph,
set()) == 7
def test_too_many_qubits():
c = cirq.Circuit()
for i in range(24):
c.append(cirq.X(cirq.NamedQubit("q" + str(i))))
t = ct.ConnectivityHeuristicCircuitTransformer(cirq.google.Sycamore23)
with pytest.raises(ct.DeviceMappingError, match="Qubits exhausted"):
t.transform(c)
def test_split_then_merge(device):
transformer = ct.ConnectivityHeuristicCircuitTransformer(device)
c = cirq.Circuit(qm.split_move(a1, a2, b1), qm.split_move(a2, a3, b3),
qm.split_move(b1, c1, c2), qm.normal_move(c1, d1),
qm.normal_move(a3, a4), qm.merge_move(a4, d1, a1))
transformer.qubit_mapping(c)
device.validate_circuit(transformer.transform(c))
def test_qubits_within(device):
"""Coupling graph of grid qubits looks like:
Q0 = Q1 = Q2
|| || ||
Q3 = Q4 = Q5
"""
transformer = ct.ConnectivityHeuristicCircuitTransformer(device)
grid_qubits = cirq.GridQubit.rect(2, 3)
assert transformer.qubits_within(0, grid_qubits[0], grid_qubits,
set()) == 1
assert transformer.qubits_within(1, grid_qubits[0], grid_qubits,
set()) == 3
assert transformer.qubits_within(2, grid_qubits[0], grid_qubits,
set()) == 5
assert transformer.qubits_within(3, grid_qubits[0], grid_qubits,
set()) == 6
assert transformer.qubits_within(10, grid_qubits[0], grid_qubits,
set()) == 6
def main(input_files: List[str]) -> None:
device = cirq.google.Sycamore
transformers = {
'dynamic look-ahead placement':
ct.DynamicLookAheadHeuristicCircuitTransformer(device),
'middle-out placement':
ct.ConnectivityHeuristicCircuitTransformer(device),
}
for input_file in input_files:
circuit = load_circuit_file(input_file)
optimized = optimize(input_file, circuit)
for name, transformer in transformers.items():
suffix = f'{input_file} with {name}'
try:
transformed = benchmark_transform(suffix, optimized,
transformer)
device.validate_circuit(transformed)
except Exception as e:
print(f'failed: {suffix}')
print(e)
def __init__(self,
init_basis_state: int,
sampler: cirq.Sampler = cirq.Simulator(),
device: Optional[cirq.Device] = None,
error_mitigation: Optional[
enums.ErrorMitigation] = enums.ErrorMitigation.Nothing,
noise_mitigation: Optional[float] = 0.0,
transformer: Optional[ct.CircuitTransformer] = None):
self.device = device
self.sampler = sampler
if device is not None:
self.transformer = (
transformer
or ct.ConnectivityHeuristicCircuitTransformer(device))
self.with_state(init_basis_state)
self.error_mitigation = error_mitigation
self.noise_mitigation = noise_mitigation
# None if there is no cache, stores the repetition number if there is a cache.
self.accumulations_repetitions = None
def test_move_around_square(device):
transformer = ct.ConnectivityHeuristicCircuitTransformer(device)
c = cirq.Circuit(qm.normal_move(a1, a2), qm.normal_move(a2, b2),
qm.normal_move(b2, b1), qm.normal_move(b1, a1))
transformer.qubit_mapping(c)
device.validate_circuit(transformer.transform(c))
def test_disconnected(device):
transformer = ct.ConnectivityHeuristicCircuitTransformer(device)
c = cirq.Circuit(qm.split_move(a1, a2, a3), qm.split_move(a3, a4, d1),
qm.split_move(b1, b2, b3), qm.split_move(c1, c2, c3))
transformer.qubit_mapping(c)
device.validate_circuit(transformer.transform(c))
def test_three_split_moves(device):
transformer = ct.ConnectivityHeuristicCircuitTransformer(device)
c = cirq.Circuit(qm.split_move(a1, a2, b1), qm.split_move(a2, a3, b3),
qm.split_move(b1, c1, c2))
transformer.qubit_mapping(c)
device.validate_circuit(transformer.transform(c))
def test_single_qubit_with_two_qubits(device):
transformer = ct.ConnectivityHeuristicCircuitTransformer(device)
c = cirq.Circuit(cirq.X(a1), cirq.X(a2), cirq.X(a3),
cirq.ISWAP(a3, a4)**0.5)
transformer.qubit_mapping(c)
device.validate_circuit(transformer.transform(c))
def test_single_qubit_ops(device):
transformer = ct.ConnectivityHeuristicCircuitTransformer(device)
c = cirq.Circuit(cirq.X(a1), cirq.X(a2), cirq.X(a3))
transformer.qubit_mapping(c)
c = transformer.transform(c)
device.validate_circuit(c)