![]() |
Any single qubit Clifford rotation.
Inherits From: SingleQubitGate
, Gate
cirq.SingleQubitCliffordGate(
*,
_clifford_tableau: cirq.CliffordTableau
) -> None
Attributes | |
---|---|
clifford_tableau
|
Methods
H
H(
*args, **kwargs
)
Any single qubit Clifford rotation.
I
I(
*args, **kwargs
)
Any single qubit Clifford rotation.
X
X(
*args, **kwargs
)
Any single qubit Clifford rotation.
X_nsqrt
X_nsqrt(
*args, **kwargs
)
Any single qubit Clifford rotation.
X_sqrt
X_sqrt(
*args, **kwargs
)
Any single qubit Clifford rotation.
Y
Y(
*args, **kwargs
)
Any single qubit Clifford rotation.
Y_nsqrt
Y_nsqrt(
*args, **kwargs
)
Any single qubit Clifford rotation.
Y_sqrt
Y_sqrt(
*args, **kwargs
)
Any single qubit Clifford rotation.
Z
Z(
*args, **kwargs
)
Any single qubit Clifford rotation.
Z_nsqrt
Z_nsqrt(
*args, **kwargs
)
Any single qubit Clifford rotation.
Z_sqrt
Z_sqrt(
*args, **kwargs
)
Any single qubit Clifford rotation.
commutes_with_pauli
commutes_with_pauli(
pauli: cirq.Pauli
) -> bool
commutes_with_single_qubit_gate
commutes_with_single_qubit_gate(
gate: 'SingleQubitCliffordGate'
) -> bool
Tests if the two circuits would be equivalent up to global phase: --self--gate-- and --gate--self--
controlled
controlled(
num_controls: int = None,
control_values: Optional[Sequence[Union[int, Collection[int]]]] = None,
control_qid_shape: Optional[Tuple[int, ...]] = None
) -> 'Gate'
Returns a controlled version of this gate. If no arguments are specified, defaults to a single qubit control.
num_controls: Total number of control qubits.
control_values: For which control qubit values to apply the sub
gate. A sequence of length num_controls
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 sub gate is
applied. If unspecified, control values default to 1.
control_qid_shape: The qid shape of the controls. A tuple of the
expected dimension of each control qid. Defaults to
(2,) * num_controls
. Specify this argument when using qudits.
decompose_rotation
decompose_rotation() -> Sequence[Tuple[Pauli, int]]
Returns ((first_rotation_axis, first_rotation_quarter_turns), ...)
This is a sequence of zero, one, or two rotations.
equivalent_gate_before
equivalent_gate_before(
after: 'SingleQubitCliffordGate'
) -> 'SingleQubitCliffordGate'
Returns a SingleQubitCliffordGate such that the circuits --output--self-- and --self--gate-- are equivalent up to global phase.
from_clifford_tableau
@staticmethod
from_clifford_tableau( tableau:
cirq.CliffordTableau
) -> 'SingleQubitCliffordGate'
from_double_map
@staticmethod
from_double_map( pauli_map_to: Optional[Dict[Pauli, Tuple[Pauli, bool]]] = None, *, x_to: Optional[Tuple[Pauli, bool]] = None, y_to: Optional[Tuple[Pauli, bool]] = None, z_to: Optional[Tuple[Pauli, bool]] = None ) -> 'SingleQubitCliffordGate'
Returns a SingleQubitCliffordGate for the specified transform with a 90 or 180 degree rotation.
Either pauli_map_to or two of (x_to, y_to, z_to) may be specified.
Args | |
---|---|
pauli_map_to
|
A dictionary with two key value pairs describing two transforms. |
x_to
|
The transform from cirq.X |
y_to
|
The transform from cirq.Y |
z_to
|
The transform from cirq.Z |
from_pauli
@staticmethod
from_pauli( pauli:
cirq.Pauli
, sqrt: bool = False ) -> 'SingleQubitCliffordGate'
from_quarter_turns
@staticmethod
from_quarter_turns( pauli:
cirq.Pauli
, quarter_turns: int ) -> 'SingleQubitCliffordGate'
from_single_map
@staticmethod
from_single_map( pauli_map_to: Optional[Dict[Pauli, Tuple[Pauli, bool]]] = None, *, x_to: Optional[Tuple[Pauli, bool]] = None, y_to: Optional[Tuple[Pauli, bool]] = None, z_to: Optional[Tuple[Pauli, bool]] = None ) -> 'SingleQubitCliffordGate'
Returns a SingleQubitCliffordGate for the specified transform with a 90 or 180 degree rotation.
The arguments are exclusive, only one may be specified.
Args | |
---|---|
pauli_map_to
|
A dictionary with a single key value pair describing the transform. |
x_to
|
The transform from cirq.X |
y_to
|
The transform from cirq.Y |
z_to
|
The transform from cirq.Z |
from_unitary
@staticmethod
from_unitary( u: np.ndarray ) -> Optional['SingleQubitCliffordGate']
Creates Clifford gate with given unitary (up to global phase).
Args | |
---|---|
u
|
2x2 unitary matrix of a Clifford gate. |
Returns | |
---|---|
SingleQubitCliffordGate, whose matrix is equal to given matrix (up
to global phase), or None if u is not a matrix of a single-qubit
Clifford gate.
|
from_xz_map
@staticmethod
from_xz_map( x_to: Tuple[
cirq.Pauli
, bool], z_to: Tuple[cirq.Pauli
, bool] ) -> 'SingleQubitCliffordGate'
Returns a SingleQubitCliffordGate for the specified transforms. The Y transform is derived from the X and Z.
Args | |
---|---|
x_to
|
Which Pauli to transform X to and if it should negate. |
z_to
|
Which Pauli to transform Z to and if it should negate. |
merged_with
merged_with(
second: 'SingleQubitCliffordGate'
) -> 'SingleQubitCliffordGate'
Returns a SingleQubitCliffordGate such that the circuits --output-- and --self--second-- are equivalent up to global phase.
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.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. |
to_phased_xz_gate
to_phased_xz_gate() -> cirq.PhasedXZGate
Convert this gate to a PhasedXZGate instance.
The rotation can be categorized by {axis} * {degree}:
* Identity: I
* {x, y, z} * {90, 180, 270} --- {X, Y, Z} + 6 Quarter turn gates
* {+/-xy, +/-yz, +/-zx} * 180 --- 6 Hadamard-like gates
* {middle point of xyz in 4 Quadrant} * {120, 240} --- swapping axis
note 1 + 9 + 6 + 8 = 24 in total.
To associate with Clifford Tableau, it can also be grouped by 4:
* {I,X,Y,Z} is [[1 0], [0, 1]]
* {+/- X_sqrt, 2 Hadamard-like gates acting on the YZ plane} is [[1, 0], [1, 1]]
* {+/- Z_sqrt, 2 Hadamard-like gates acting on the XY plane} is [[1, 1], [0, 1]]
* {+/- Y_sqrt, 2 Hadamard-like gates acting on the XZ plane} is [[0, 1], [1, 0]]
* {middle point of xyz in 4 Quadrant} * 120 is [[0, 1], [1, 1]]
* {middle point of xyz in 4 Quadrant} * 240 is [[1, 1], [1, 0]]
transform
transform(
pauli: cirq.Pauli
) -> cirq.PauliTransform
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_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'
__neg__
__neg__() -> 'cirq.LinearCombinationOfGates'
__pow__
__pow__(
exponent
) -> 'SingleQubitCliffordGate'
__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'