Pauli

class Pauli(data=None, x=None, *, z=None, label=None)

ベースクラス: BasePauli

N-qubit Pauli operator.

This class represents an operator \(P\) from the full \(n\)-qubit Pauli group

\[P = (-i)^{q} P_{n-1} \otimes ... \otimes P_{0}\]

where \(q\in \mathbb{Z}_4\) and \(P_i \in \{I, X, Y, Z\}\) are single-qubit Pauli matrices:

\[\begin{split}I = \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix}, X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}, Y = \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix}, Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}.\end{split}\]

Initialization

A Pauli object can be initialized in several ways:

Pauli(obj)

where obj is a Pauli string, Pauli or ScalarOp operator, or a Pauli gate or QuantumCircuit containing only Pauli gates.

Pauli((z, x, phase))

where z and x are boolean numpy.ndarrays and phase is an integer in [0, 1, 2, 3].

Pauli((z, x))

equivalent to Pauli((z, x, 0)) with trivial phase.

String representation

An \(n\)-qubit Pauli may be represented by a string consisting of \(n\) characters from ['I', 'X', 'Y', 'Z'], and optionally phase coefficient in \(['', '-i', '-', 'i']\). For example: XYZ or '-iZIZ'.

In the string representation qubit-0 corresponds to the right-most Pauli character, and qubit-\((n-1)\) to the left-most Pauli character. For example 'XYZ' represents \(X\otimes Y \otimes Z\) with 'Z' on qubit-0, 'Y' on qubit-1, and 'X' on qubit-3.

The string representation can be converted to a Pauli using the class initialization (Pauli('-iXYZ')). A Pauli object can be converted back to the string representation using the to_label() method or str(pauli).

注釈

Using str to convert a Pauli to a string will truncate the returned string for large numbers of qubits while to_label() will return the full string with no truncation. The default truncation length is 50 characters. The default value can be changed by setting the class __truncate__ attribute to an integer value. If set to 0 no truncation will be performed.

Array Representation

The internal data structure of an \(n\)-qubit Pauli is two length-\(n\) boolean vectors \(z \in \mathbb{Z}_2^N\), \(x \in \mathbb{Z}_2^N\), and an integer \(q \in \mathbb{Z}_4\) defining the Pauli operator

\[P = (-i)^{q + z\cdot x} Z^z \cdot X^x.\]

The \(k\) and \(x\) arrays

\[\begin{split}P &= P_{n-1} \otimes ... \otimes P_{0} \\ P_k &= (-i)^{z[k] * x[k]} Z^{z[k]}\cdot X^{x[k]}\end{split}\]

where z[k] = P.z[k], x[k] = P.x[k] respectively.

The \(z\) and \(x\) arrays can be accessed and updated using the z and x properties respectively. The phase integer \(q\) can be accessed and updated using the phase property.

Matrix Operator Representation

Pauli’s can be converted to \((2^n, 2^n)\) Operator using the to_operator() method, or to a dense or sparse complex matrix using the to_matrix() method.

Data Access

The individual qubit Paulis can be accessed and updated using the [] operator which accepts integer, lists, or slices for selecting subsets of Paulis. Note that selecting subsets of Pauli’s will discard the phase of the current Pauli.

For example

p = Pauli('-iXYZ')

print('P[0] =', repr(P[0]))
print('P[1] =', repr(P[1]))
print('P[2] =', repr(P[2]))
print('P[:] =', repr(P[:]))
print('P[::-1] =, repr(P[::-1]))

Initialize the Pauli.

When using the symplectic array input data both z and x arguments must be provided, however the first (z) argument can be used alone for string label, Pauli operator, or ScalarOp input data.

パラメータ

data (str or tuple or Pauli or ScalarOp) – input data for Pauli. If input is a tuple it must be of the form (z, x) or (z, x, phase)`` where z and x are boolean Numpy arrays, and phase is an integer from Z_4. If input is a string, it must be a concatenation of a phase and a Pauli string (e.g. 『XYZ』, 『-iZIZ』) where a phase string is a combination of at most three characters from [『+』, 『-『, 『』], [『1』, 『』], and [『i』, 『j』, 『』] in this order, e.g. 『』, 『-1j』 while a Pauli string is 1 or more characters of 『I』, 『X』, 『Y』 or 『Z』, e.g. 『Z』, 『XIYY』.

例外

QiskitError – if input array is invalid shape.

Methods

adjoint	Return the adjoint of the Operator.
anticommutes	Return True if other Pauli anticommutes with self.
commutes	Return True if the Pauli commutes with other.
compose	Return the operator composition with another Pauli.
conjugate	Return the conjugate of each Pauli in the list.
copy	Make a deep copy of current operator.
delete	Return a Pauli with qubits deleted.
dot	Return the right multiplied operator self * other.
equiv	Return True if Pauli's are equivalent up to group phase.
evolve	Heisenberg picture evolution of a Pauli by a Clifford.
expand	Return the reverse-order tensor product with another Pauli.
input_dims	Return tuple of input dimension for specified subsystems.
insert	Insert a Pauli at specific qubit value.
inverse	Return the inverse of the Pauli.
output_dims	Return tuple of output dimension for specified subsystems.
power	Return the compose of a operator with itself n times.
reshape	Return a shallow copy with reshaped input and output subsystem dimensions.
set_truncation	Set the max number of Pauli characters to display before truncation/
tensor	Return the tensor product with another Pauli.
to_instruction	Convert to Pauli circuit instruction.
to_label	Convert a Pauli to a string label.
to_matrix	Convert to a Numpy array or sparse CSR matrix.
transpose	Return the transpose of each Pauli in the list.

Attributes

dim

Return tuple (input_shape, output_shape).

name

Unique string identifier for operation type.

num_clbits

Number of classical bits.

num_qubits

Return the number of qubits if a N-qubit operator or None otherwise.

phase

Return the group phase exponent for the Pauli.

qargs

Return the qargs for the operator.

settings

Return settings.

戻り値の型

Dict

x

The x vector for the Pauli.

z

The z vector for the Pauli.