View source on GitHub
|
A doubly-controlled-Z that can be raised to a power.
Inherits From: InterchangeableQubitsGate, EigenGate, Gate
cirq.CCZPowGate(
*,
exponent: cirq.TParamVal = 1.0,
global_shift: float = 0.0
) -> None
The unitary matrix of CCZ**t is (empty elements are \(0\)):
\[ \begin{bmatrix} 1 & & & & & & & \\ & 1 & & & & & & \\ & & 1 & & & & & \\ & & & 1 & & & & \\ & & & & 1 & & & \\ & & & & & 1 & & \\ & & & & & & 1 & \\ & & & & & & & e^{i \pi t} \end{bmatrix} \]
Args | |
|---|---|
exponent
|
The t in gate**t. Determines how much the eigenvalues of
the gate are phased by. For example, eigenvectors phased by -1
when gate**1 is applied will gain a relative phase of
e^{i pi exponent} when gate**exponent is applied (relative to
eigenvectors unaffected by gate**1).
|
global_shift
|
Offsets the eigenvalues of the gate at exponent=1.
In effect, this controls a global phase factor on the gate's
unitary matrix. The factor is:
For example, |
Raises | |
|---|---|
ValueError
|
If the supplied exponent is a complex number with an imaginary component. |
Attributes | |
|---|---|
exponent
|
|
global_shift
|
|
Methods
controlled
controlled(
num_controls: Optional[int] = None,
control_values: Optional[Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
] = None,
control_qid_shape: Optional[Tuple[int, ...]] = None
) -> cirq.Gate
Returns a controlled ZPowGate with two additional controls.
The controlled method of the Gate class, of which this class is a
child, returns a ControlledGate with sub_gate = self. This method
overrides this behavior to return a ControlledGate with
sub_gate = ZPowGate.
num_qubits
num_qubits() -> int
The number of qubits this gate acts on.
on
on(
*qubits
) -> 'Operation'
Returns an application of this gate to the given qubits.
| Args | |
|---|---|
*qubits
|
The collection of qubits to potentially apply the gate to. |
Returns: a cirq.Operation which is this gate applied to the given
qubits.
on_each
on_each(
*targets
) -> List['cirq.Operation']
Returns a list of operations applying the gate to all targets.
| Args | |
|---|---|
*targets
|
The qubits to apply this gate to. For single-qubit gates
this can be provided as varargs or a combination of nested
iterables. For multi-qubit gates this must be provided as an
Iterable[Sequence[Qid]], where each sequence has num_qubits
qubits.
|
| Returns | |
|---|---|
| Operations applying this gate to the target qubits. |
| Raises | |
|---|---|
ValueError
|
If targets are not instances of Qid or Iterable[Qid]. If the gate qubit number is incompatible. |
TypeError
|
If a single target is supplied and it is not iterable. |
qubit_index_to_equivalence_group_key
qubit_index_to_equivalence_group_key(
index: int
) -> int
Returns a key that differs between non-interchangeable qubits.
validate_args
validate_args(
qubits: Sequence['cirq.Qid']
) -> None
Checks if this gate can be applied to the given qubits.
By default checks that:
- inputs are of type
Qid - len(qubits) == num_qubits()
- qubit_i.dimension == qid_shape[i] for all qubits
Child classes can override. The child implementation should call
super().validate_args(qubits) then do custom checks.
| Args | |
|---|---|
qubits
|
The sequence of qubits to potentially apply the gate to. |
| Raises | |
|---|---|
ValueError
|
The gate can't be applied to the qubits. |
with_probability
with_probability(
probability: 'cirq.TParamVal'
) -> 'cirq.Gate'
Creates a probabilistic channel with this gate.
| 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.
|
wrap_in_linear_combination
wrap_in_linear_combination(
coefficient: Union[complex, float, int] = 1
) -> 'cirq.LinearCombinationOfGates'
Returns a LinearCombinationOfGates with this gate.
| Args | |
|---|---|
coefficient
|
number coefficient to use in the resulting
cirq.LinearCombinationOfGates object.
|
| Returns | |
|---|---|
cirq.LinearCombinationOfGates containing self with a
coefficient of coefficient.
|
__add__
__add__(
other: Union['Gate', 'cirq.LinearCombinationOfGates']
) -> 'cirq.LinearCombinationOfGates'
__call__
__call__(
*qubits, **kwargs
)
Call self as a function.
__eq__
__eq__(
other: _SupportsValueEquality
) -> bool
__mul__
__mul__(
other: Union[complex, float, int]
) -> 'cirq.LinearCombinationOfGates'
__ne__
__ne__(
other: _SupportsValueEquality
) -> bool
__neg__
__neg__() -> 'cirq.LinearCombinationOfGates'
__pow__
__pow__(
exponent: Union[float, sympy.Symbol]
) -> 'EigenGate'
__rmul__
__rmul__(
other: Union[complex, float, int]
) -> 'cirq.LinearCombinationOfGates'
__sub__
__sub__(
other: Union['Gate', 'cirq.LinearCombinationOfGates']
) -> 'cirq.LinearCombinationOfGates'
__truediv__
__truediv__(
other: Union[complex, float, int]
) -> 'cirq.LinearCombinationOfGates'