View source on GitHub
|
A gate that rotates around the X axis of the Bloch sphere.
Inherits From: EigenGate, SingleQubitGate, SupportsOnEachGate, Gate
cirq.ops.XPowGate(
*,
exponent: cirq.value.TParamVal = 1.0,
global_shift: float = 0.0
) -> None
Used in the notebooks
| Used in the tutorials |
|---|
The unitary matrix of XPowGate(exponent=t) is:
[[g·c, -i·g·s],
[-i·g·s, g·c]]
where:
c = cos(π·t/2)
s = sin(π·t/2)
g = exp(i·π·t/2).
Note in particular that this gate has a global phase factor of
e^{i·π·t/2} vs the traditionally defined rotation matrices
about the Pauli X axis. See cirq.rx for rotations without the global
phase. The global phase factor can be adjusted by using the global_shift
parameter when initializing.
cirq.X, the Pauli X gate, is an instance of this gate at exponent=1.
Args | |
|---|---|
exponent
|
The t in gate**t. Determines how much the eigenvalues of
the gate are scaled 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:
exp(i * pi * global_shift * exponent) For example, |
Attributes | |
|---|---|
exponent
|
|
global_shift
|
|
phase_exponent
|
|
Methods
controlled
controlled(
num_controls: int = None,
control_values: Optional[Sequence[Union[int, Collection[int]]]] = None,
control_qid_shape: Optional[Tuple[int, ...]] = None
) -> cirq.ops.Gate
Returns a controlled XPowGate, using a CXPowGate where possible.
The controlled method of the Gate class, of which this class is a
child, returns a ControlledGate. This method overrides this behavior
to return a CXPowGate or a ControlledGate of a CXPowGate, when
this is possible.
The conditions for the override to occur are:
* The `global_shift` of the `XPowGate` is 0.
* The `control_values` and `control_qid_shape` are compatible with
the `CXPowGate`:
* The last value of `control_qid_shape` is a qubit.
* The last value of `control_values` corresponds to the
control being satisfied if that last qubit is 1 and
not satisfied if the last qubit is 0.
If these conditions are met, then the returned object is a CXPowGate
or, in the case that there is more than one controlled qudit, a
ControlledGate with the Gate being a CXPowGate. In the
latter case the ControlledGate is controlled by one less qudit
than specified in control_values and control_qid_shape (since
one of these, the last qubit, is used as the control for the
CXPowGate).
If the above conditions are not met, a ControlledGate of this
gate will be returned.
in_su2
in_su2() -> "Rx"
Returns an equal-up-global-phase gate from the group SU2.
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. |
on_each
on_each(
*targets
) -> List[cirq.ops.Operation]
Returns a list of operations applying the gate to all targets.
| Args | |
|---|---|
*targets
|
The qubits to apply this gate to. |
| Returns | |
|---|---|
| Operations applying this gate to the target qubits. |
| Raises | |
|---|---|
| ValueError if targets are not instances of Qid or List[Qid]. ValueError if the gate operates on two or more Qids. |
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. |
Throws:
ValueError: The gate can't be applied to the qubits.
with_canonical_global_phase
with_canonical_global_phase() -> "XPowGate"
Returns an equal-up-global-phase standardized form of the gate.
with_probability
with_probability(
probability: "cirq.TParamVal"
) -> "cirq.Gate"
wrap_in_linear_combination
wrap_in_linear_combination(
coefficient: Union[complex, float, int] = 1
) -> "cirq.LinearCombinationOfGates"
__add__
__add__(
other: Union['Gate', 'cirq.LinearCombinationOfGates']
) -> "cirq.LinearCombinationOfGates"
__call__
__call__(
*args, **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"