# Pauli#

class qiskit.quantum_info.Pauli(data=None)[source]#

Bases: 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).

Note

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 $$kth qubit corresponds to the :math:kth entry in the :math:z$$ 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.

Parameters:

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â€™.

Raises:

QiskitError â€“ if input array is invalid shape.

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.

x#

The x vector for the Pauli.

z#

The z vector for the Pauli.

Methods

Return the adjoint of the Operator.

anticommutes(other, qargs=None)[source]#

Return True if other Pauli anticommutes with self.

Parameters:
• other (Pauli) â€“ another Pauli operator.

• qargs (list) â€“ qubits to apply dot product on (default: None).

Returns:

True if Pauliâ€™s anticommute, False if they commute.

Return type:

bool

commutes(other, qargs=None)[source]#

Return True if the Pauli commutes with other.

Parameters:
• other (Pauli or PauliList) â€“ another Pauli operator.

• qargs (list) â€“ qubits to apply dot product on (default: None).

Returns:

True if Pauliâ€™s commute, False if they anti-commute.

Return type:

bool

compose(other, qargs=None, front=False, inplace=False)[source]#

Return the operator composition with another Pauli.

Parameters:
• other (Pauli) â€“ a Pauli object.

• qargs (list or None) â€“ Optional, qubits to apply dot product on (default: None).

• front (bool) â€“ If True compose using right operator multiplication, instead of left multiplication [default: False].

• inplace (bool) â€“ If True update in-place (default: False).

Returns:

The composed Pauli.

Return type:

Pauli

Raises:

QiskitError â€“ if other cannot be converted to an operator, or has incompatible dimensions for specified subsystems.

Note

Composition (&) by default is defined as left matrix multiplication for matrix operators, while dot() is defined as right matrix multiplication. That is that A & B == A.compose(B) is equivalent to B.dot(A) when A and B are of the same type.

Setting the front=True kwarg changes this to right matrix multiplication and is equivalent to the dot() method A.dot(B) == A.compose(B, front=True).

conjugate()[source]#

Return the conjugate of each Pauli in the list.

copy()#

Make a deep copy of current operator.

delete(qubits)[source]#

Return a Pauli with qubits deleted.

Parameters:

qubits (int or list) â€“ qubits to delete from Pauli.

Returns:

the resulting Pauli with the specified qubits removed.

Return type:

Pauli

Raises:

QiskitError â€“ if ind is out of bounds for the array size or number of qubits.

dot(other, qargs=None, inplace=False)[source]#

Return the right multiplied operator self * other.

Parameters:
• other (Pauli) â€“ an operator object.

• qargs (list or None) â€“ Optional, qubits to apply dot product on (default: None).

• inplace (bool) â€“ If True update in-place (default: False).

Returns:

The operator self * other.

Return type:

Pauli

equiv(other)[source]#

Return True if Pauliâ€™s are equivalent up to group phase.

Parameters:

other (Pauli) â€“ an operator object.

Returns:

True if the Pauliâ€™s are equivalent up to group phase.

Return type:

bool

evolve(other, qargs=None, frame='h')[source]#

Performs either Heisenberg (default) or SchrÃ¶dinger picture evolution of the Pauli by a Clifford and returns the evolved Pauli.

SchrÃ¶dinger picture evolution can be chosen by passing parameter frame='s'. This option yields a faster calculation.

Heisenberg picture evolves the Pauli as $$P^\prime = C^\dagger.P.C$$.

SchrÃ¶dinger picture evolves the Pauli as $$P^\prime = C.P.C^\dagger$$.

Parameters:
• other (Pauli or Clifford or QuantumCircuit) â€“ The Clifford operator to evolve by.

• qargs (list) â€“ a list of qubits to apply the Clifford to.

• frame (string) â€“ 'h' for Heisenberg (default) or 's' for

• framework. (SchrÃ¶dinger) â€“

Returns:

the Pauli $$C^\dagger.P.C$$ (Heisenberg picture) or the Pauli $$C.P.C^\dagger$$ (SchrÃ¶dinger picture).

Return type:

Pauli

Raises:

QiskitError â€“ if the Clifford number of qubits and qargs donâ€™t match.

expand(other)[source]#

Return the reverse-order tensor product with another Pauli.

Parameters:

other (Pauli) â€“ a Pauli object.

Returns:

the tensor product $$b \otimes a$$, where $$a$$

is the current Pauli, and $$b$$ is the other Pauli.

Return type:

Pauli

input_dims(qargs=None)#

Return tuple of input dimension for specified subsystems.

insert(qubits, value)[source]#

Insert a Pauli at specific qubit value.

Parameters:
• qubits (int or list) â€“ qubits index to insert at.

• value (Pauli) â€“ value to insert.

Returns:

the resulting Pauli with the entries inserted.

Return type:

Pauli

Raises:

QiskitError â€“ if the insertion qubits are invalid.

inverse()[source]#

Return the inverse of the Pauli.

output_dims(qargs=None)#

Return tuple of output dimension for specified subsystems.

power(n)#

Return the compose of a operator with itself n times.

Parameters:

n (int) â€“ the number of times to compose with self (n>0).

Returns:

the n-times composed operator.

Return type:

Clifford

Raises:

QiskitError â€“ if the input and output dimensions of the operator are not equal, or the power is not a positive integer.

reshape(input_dims=None, output_dims=None, num_qubits=None)#

Return a shallow copy with reshaped input and output subsystem dimensions.

Parameters:
• input_dims (None or tuple) â€“ new subsystem input dimensions. If None the original input dims will be preserved [Default: None].

• output_dims (None or tuple) â€“ new subsystem output dimensions. If None the original output dims will be preserved [Default: None].

• num_qubits (None or int) â€“ reshape to an N-qubit operator [Default: None].

Returns:

returns self with reshaped input and output dimensions.

Return type:

BaseOperator

Raises:

QiskitError â€“ if combined size of all subsystem input dimension or subsystem output dimensions is not constant.

classmethod set_truncation(val)[source]#

Set the max number of Pauli characters to display before truncation/

Parameters:

val (int) â€“ the number of characters.

Note

Truncation will be disabled if the truncation value is set to 0.

tensor(other)[source]#

Return the tensor product with another Pauli.

Parameters:

other (Pauli) â€“ a Pauli object.

Returns:

the tensor product $$a \otimes b$$, where $$a$$

is the current Pauli, and $$b$$ is the other Pauli.

Return type:

Pauli

Note

The tensor product can be obtained using the ^ binary operator. Hence a.tensor(b) is equivalent to a ^ b.

to_instruction()[source]#

Convert to Pauli circuit instruction.

to_label()[source]#

Convert a Pauli to a string label.

Note

The difference between to_label and __str__() is that the later will truncate the output for large numbers of qubits.

Returns:

the Pauli string label.

Return type:

str

to_matrix(sparse=False)[source]#

Convert to a Numpy array or sparse CSR matrix.

Parameters:

sparse (bool) â€“ if True return sparse CSR matrices, otherwise return dense Numpy arrays (default: False).

Returns:

The Pauli matrix.

Return type:

array

transpose()[source]#

Return the transpose of each Pauli in the list.