View source on GitHub |
An effect applied to a collection of qubits.
The most common kind of Operation is a GateOperation, which separates its effect into a qubit-independent Gate and the qubits it should be applied to.
Attributes | |
---|---|
classical_controls
|
The classical controls gating this operation. |
gate
|
|
qubits
|
|
tags
|
Returns a tuple of the operation's tags. |
untagged
|
Returns the underlying operation without any tags. |
Methods
controlled_by
controlled_by(
*control_qubits,
control_values: Optional[Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
] = None
) -> 'cirq.Operation'
Returns a controlled version of this operation. If no control_qubits are specified, returns self.
Args | |
---|---|
*control_qubits
|
Qubits to control the operation by. Required. |
control_values
|
For which control qubit values to apply the
operation. A sequence of the same length as control_qubits
where each entry is an integer (or set of integers)
corresponding to the qubit value (or set of possible values)
where that control is enabled. When all controls are enabled,
the operation is applied. If unspecified, control values
default to 1.
|
transform_qubits
transform_qubits(
qubit_map: Union[Dict['cirq.Qid', 'cirq.Qid'], Callable[['cirq.Qid'], 'cirq.Qid']]
) -> Self
Returns the same operation, but with different qubits.
Args | |
---|---|
qubit_map
|
A function or a dict mapping each current qubit into a desired new qubit. |
Returns | |
---|---|
The receiving operation but with qubits transformed by the given function. |
Raises | |
---|---|
TypeError
|
qubit_map was not a function or dict mapping qubits to qubits. |
validate_args
validate_args(
qubits: Sequence['cirq.Qid']
)
Raises an exception if the qubits
don't match this operation's qid shape.
Call this method from a subclass's with_qubits
method.
Args | |
---|---|
qubits
|
The new qids for the operation. |
Raises | |
---|---|
ValueError
|
The operation had qids that don't match it's qid shape. |
with_classical_controls
with_classical_controls(
*conditions
) -> 'cirq.Operation'
Returns a classically controlled version of this operation.
An operation that is classically controlled is executed iff all
conditions evaluate to True. Conditions can be either a measurement key
or a user-specified cirq.Condition
. A measurement key evaluates to
True iff any qubit in the corresponding measurement operation evaluated
to a non-zero value; cirq.Condition
supports more complex,
user-defined conditions.
If no conditions are specified, returns self.
The classical control will remove any tags on the existing operation, since tags are fragile, and we always opt to get rid of the tags when the underlying operation is changed.
Args | |
---|---|
*conditions
|
A list of measurement keys, strings that can be parsed into measurement keys, or sympy expressions where the free symbols are measurement key strings. |
Returns | |
---|---|
A ClassicallyControlledOperation wrapping the operation. If no conditions
are specified, returns self.
|
with_probability
with_probability(
probability: 'cirq.TParamVal'
) -> 'cirq.Operation'
Creates a probabilistic channel with this operation.
Args | |
---|---|
probability
|
floating point value between 0 and 1, giving the probability this gate is applied. |
Returns | |
---|---|
cirq.RandomGateChannel that applies self with probability
probability and the identity with probability 1-p .
|
Raises | |
---|---|
NotImplementedError
|
if called on an operation that lacks a gate. |
with_qubits
@abc.abstractmethod
with_qubits( *new_qubits ) -> Self
Returns the same operation, but applied to different qubits.
Args | |
---|---|
*new_qubits
|
The new qubits to apply the operation to. The order must
exactly match the order of qubits returned from the operation's
qubits property.
|
with_tags
with_tags(
*new_tags
) -> 'cirq.Operation'
Creates a new TaggedOperation, with this op and the specified tags.
This method can be used to attach meta-data to specific operations without affecting their functionality. The intended usage is to attach classes intended for this purpose or strings to mark operations for specific usage that will be recognized by consumers. Specific examples include ignoring this operation in optimization passes, hardware-specific functionality, or circuit diagram customizability.
Tags can be a list of any type of object that is useful to identify this operation as long as the type is hashable. If you wish the resulting operation to be eventually serialized into JSON, you should also restrict the operation to be JSON serializable.
Args | |
---|---|
*new_tags
|
The tags to wrap this operation in. |
without_classical_controls
without_classical_controls() -> 'cirq.Operation'
Removes all classical controls from the operation.
This function removes all classical controls gating the operation. It acts recursively, so that all classical control wrappers are always removed from the current operation.
If there are no classical controls on the operation, it will return
self
.
Since tags are fragile, this will also remove any tags from the operation,
when called on TaggedOperation
(unless there are no classical controls on it).
If a TaggedOperation
is under all the classical control layers,
that TaggedOperation
will be returned from this function.
Returns | |
---|---|
The operation with all classical controls removed. |