def optimization_at(
self, circuit: circuits.Circuit, index: int,
op: ops.Operation) -> Optional[circuits.PointOptimizationSummary]:
if len(op.qubits) != 2:
return None
old_operations, indices, matrix = (
self._scan_two_qubit_ops_into_matrix(circuit, index, op.qubits))
# Find a max-3-cz construction.
new_operations = decompositions.two_qubit_matrix_to_native_gates(
op.qubits[0], op.qubits[1], matrix, self.allow_partial_czs,
self.tolerance)
old_interaction_count = len(
[old_op for old_op in old_operations if len(old_op.qubits) == 2])
new_interaction_count = len(
[new_op for new_op in new_operations if len(new_op.qubits) == 2])
switch_to_new = False
switch_to_new |= new_interaction_count < old_interaction_count
switch_to_new |= any(not xmon_gates.XmonGate.is_xmon_op(old_op)
for old_op in old_operations)
if not switch_to_new:
return None
converter = convert_to_xmon_gates.ConvertToXmonGates()
new_xmon_operations = [
converter.convert(new_op) for new_op in new_operations
]
return circuits.PointOptimizationSummary(
clear_span=max(indices) + 1 - index,
clear_qubits=op.qubits,
new_operations=new_xmon_operations)
def _to_xmon_circuit(
self, circuit: circuits.Circuit, param_resolver: study.ParamResolver
) -> Tuple[circuits.Circuit, Set[str]]:
# TODO: Use one optimization pass.
xmon_circuit = protocols.resolve_parameters(circuit, param_resolver)
convert_to_xmon_gates.ConvertToXmonGates().optimize_circuit(
xmon_circuit)
circuits.DropEmptyMoments().optimize_circuit(xmon_circuit)
keys = find_measurement_keys(xmon_circuit)
return xmon_circuit, keys
def program_as_schedule(self, program: TProgram) -> schedules.Schedule:
if isinstance(program, circuits.Circuit):
device = program.device
circuit_copy = program.copy()
convert_to_xmon_gates.ConvertToXmonGates().optimize_circuit(
circuit_copy)
optimizers.DropEmptyMoments().optimize_circuit(circuit_copy)
device.validate_circuit(circuit_copy)
return schedules.moment_by_moment_schedule(device, circuit_copy)
if isinstance(program, schedules.Schedule):
return program
raise TypeError('Unexpected program type.')
def optimization_at(self, circuit, index, op):
if len(op.qubits) != 1:
return
indices, gates = self._scan_single_qubit_ops(circuit, index,
op.qubits[0])
if not gates or (len(gates) == 1 and isinstance(gates[0], XmonGate)):
return
# Replace the gates with a max-2-op XY + Z construction.
new_operations = self._merge_rotations(op.qubits[0], gates)
converter = convert_to_xmon_gates.ConvertToXmonGates()
new_xmon_operations = [
converter.convert(new_op) for new_op in new_operations
]
return PointOptimizationSummary(clear_span=max(indices) + 1 - index,
clear_qubits=op.qubits,
new_operations=new_xmon_operations)
def decompose_operation(self, operation: ops.Operation) -> ops.OP_TREE:
return convert_to_xmon_gates.ConvertToXmonGates().convert(operation)
# See the License for the specific language governing permissions and
# limitations under the License.
"""A combination of several optimizations targeting XmonDevice."""
from typing import Optional, Callable, cast
from cirq import circuits, devices, ops, optimizers
from cirq.google import (
convert_to_xmon_gates,
merge_rotations,
xmon_device)
_TOLERANCE = 1e-5
_OPTIMIZERS = [
convert_to_xmon_gates.ConvertToXmonGates(),
optimizers.MergeInteractions(tolerance=_TOLERANCE,
allow_partial_czs=False),
convert_to_xmon_gates.ConvertToXmonGates(),
merge_rotations.MergeRotations(tolerance=_TOLERANCE),
optimizers.EjectPhasedPaulis(tolerance=_TOLERANCE),
optimizers.EjectZ(tolerance=_TOLERANCE),
optimizers.DropNegligible(tolerance=_TOLERANCE),
merge_rotations.MergeRotations(tolerance=_TOLERANCE),
]
_OPTIMIZERS_PART_CZ = [
convert_to_xmon_gates.ConvertToXmonGates(),
optimizers.MergeInteractions(tolerance=_TOLERANCE,
from cirq import circuits, devices, optimizers
from cirq.google import convert_to_xmon_gates, xmon_device
if TYPE_CHECKING:
import cirq
_TOLERANCE = 1e-5
def _merge_rots(c: 'cirq.Circuit'):
return optimizers.merge_single_qubit_gates_into_phased_x_z(c, _TOLERANCE)
_OPTIMIZERS: List[Callable[['cirq.Circuit'], None]] = [
convert_to_xmon_gates.ConvertToXmonGates().optimize_circuit,
optimizers.MergeInteractions(tolerance=_TOLERANCE,
allow_partial_czs=False).optimize_circuit,
_merge_rots,
optimizers.EjectPhasedPaulis(tolerance=_TOLERANCE).optimize_circuit,
optimizers.EjectZ(tolerance=_TOLERANCE).optimize_circuit,
optimizers.DropNegligible(tolerance=_TOLERANCE).optimize_circuit,
]
_OPTIMIZERS_PART_CZ: List[Callable[['cirq.Circuit'], None]] = [
convert_to_xmon_gates.ConvertToXmonGates().optimize_circuit,
optimizers.MergeInteractions(tolerance=_TOLERANCE,
allow_partial_czs=True).optimize_circuit,
_merge_rots,
optimizers.EjectPhasedPaulis(tolerance=_TOLERANCE).optimize_circuit,
optimizers.EjectZ(tolerance=_TOLERANCE).optimize_circuit,
def decompose_operation(self,
operation: 'cirq.Operation') -> 'cirq.OP_TREE':
return convert_to_xmon_gates.ConvertToXmonGates().convert(operation)
