 View source on GitHub |
Abstract base class to create two-qubit target gatesets.
Inherits From: CompilationTargetGateset, Gateset
cirq.TwoQubitCompilationTargetGateset( *gates, name: (str | None) = None, unroll_circuit_op: bool = True, preserve_moment_structure: bool = True, reorder_operations: bool = False ) This base class can be used to create two-qubit compilation target gatesets. It automatically implements the logic to
1. Apply `self.preprocess_transformers` to the input circuit, which by default will: a) Expand composite gates acting on > 2 qubits using <a href="../cirq/expand_composite"><code>cirq.expand_composite</code></a>. b) Merge connected components of 1 & 2 qubit unitaries into tagged <a href="../cirq/CircuitOperation"><code>cirq.CircuitOperation</code></a> using <a href="../cirq/merge_k_qubit_unitaries"><code>cirq.merge_k_qubit_unitaries</code></a>. 2. Apply `self.decompose_to_target_gateset` to rewrite each operation (including merged connected components from 1b) using gates from this gateset. a) Uses `self._decompose_single_qubit_operation`, `self._decompose_two_qubit_operation` and `self._decompose_multi_qubit_operation` to figure out how to rewrite (merged connected components of) operations using only gates from this gateset. b) A merged connected component containing only 1 & 2q gates from this gateset is replaced with a more efficient rewrite using `self._decompose_two_qubit_operation` iff the rewritten op-tree is lesser number of 2q interactions. Replace connected components with inefficient implementations (higher number of 2q interactions) with efficient rewrites to minimize total number of 2q interactions. 3. Apply `self.postprocess_transformers` to the transformed circuit, which by default will: a) Apply <a href="../cirq/merge_single_qubit_moments_to_phxz"><code>cirq.merge_single_qubit_moments_to_phxz</code></a> to preserve moment structure (eg: alternating layers of single/two qubit gates). b) Apply <a href="../cirq/drop_negligible_operations"><code>cirq.drop_negligible_operations</code></a> and <a href="../cirq/drop_empty_moments"><code>cirq.drop_empty_moments</code></a> to minimize circuit depth. Derived classes should simply implement self._decompose_two_qubit_operation abstract method and provide analytical decomposition of any 2q unitary using gates from the target gateset.
Args | |
|---|---|
*gates | A list of cirq.Gate subclasses / cirq.Gate instances / cirq.GateFamily instances to initialize the Gateset. |
name | (Optional) Name for the Gateset. Useful for description. |
unroll_circuit_op | If True, cirq.CircuitOperation is recursively validated by validating the underlying cirq.Circuit. |
preserve_moment_structure | Whether to preserve the moment structure of the circuit during compilation or not. |
reorder_operations | Whether to attempt to reorder the operations in order to reduce circuit depth or not (can be True only if preserve_moment_structure=False). |
Raises | |
|---|---|
ValueError | If both reorder_operations and preserve_moment_structure are True. |
Methods
decompose_to_target_gateset
decompose_to_target_gateset( op: cirq.Operation, moment_idx: int ) -> DecomposeResult Method to rewrite the given operation using gates from this gateset.
| Args | |
|---|---|
op | cirq.Operation to be rewritten using gates from this gateset. |
moment_idx | Moment index where the given operation op occurs in a circuit. |
| Returns | |
|---|---|
|
validate
validate( circuit_or_optree: (cirq.AbstractCircuit | op_tree.OP_TREE) ) -> bool Validates gates forming circuit_or_optree should be contained in Gateset.
| Args | |
|---|---|
circuit_or_optree | The cirq.Circuit or cirq.OP_TREE to validate. |
with_params
with_params( *, name: (str | None) = None, unroll_circuit_op: (bool | None) = None ) -> Gateset Returns a copy of this Gateset with identical gates and new values for named arguments.
If a named argument is None then corresponding value of this Gateset is used instead.
| Args | |
|---|---|
name | New name for the Gateset. |
unroll_circuit_op | If True, new Gateset will recursively validate cirq.CircuitOperation by validating the underlying cirq.Circuit. |
| Returns | |
|---|---|
self if all new values are None or identical to the values of current Gateset. else a new Gateset with identical gates and new values for named arguments. |
__contains__
__contains__( item: (raw_types.Gate | raw_types.Operation) ) -> bool Check for containment of a given Gate/Operation in this Gateset.
Containment checks are handled as follows:
- For Gates or Operations that have an underlying gate (i.e. op.gate is not None):
- Forwards the containment check to the underlying
cirq.GateFamilyobjects. - Examples of such operations include
cirq.GateOperations and their controlled and tagged variants (i.e. instances ofcirq.TaggedOperation,cirq.ControlledOperationwhereop.gateis not None) etc.
- Forwards the containment check to the underlying
- For Operations that do not have an underlying gate:
- Forwards the containment check to
self._validate_operation(item). - Examples of such operations include
cirq.CircuitOperations and their controlled and tagged variants (i.e. instances ofcirq.TaggedOperation,cirq.ControlledOperationwhereop.gateis None) etc.
- Forwards the containment check to
The complexity of the method in terms of the number of gates, n, is
- O(1) when any default
cirq.GateFamilyinstance accepts the given item, except for an Instance GateFamily trying to match an item with a different global phase. - O(n) for all other cases: matching against custom gate families, matching across global phase for the default Instance GateFamily, no match against any underlying gate family.
| Args | |
|---|---|
item | The cirq.Gate or cirq.Operation instance to check containment for. |
__eq__
__eq__( other: _SupportsValueEquality ) -> bool __ne__
__ne__( other: _SupportsValueEquality ) -> bool