Pauli

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

Bases: qiskit.quantum_info.operators.symplectic.base_pauli.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 $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.

Parameters

data (str or tuple or Pauli orScalarOp) – 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.

Methods

adjoint

Pauli.adjoint()

Return the adjoint of the Operator.

anticommutes

Pauli.anticommutes(other, qargs=None)

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

Pauli.commutes(other, qargs=None)

Return True if the Pauli commutes with other.

Parameters

other (Pauli orPauliList) – 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

Pauli.compose(other, qargs=None, front=False, inplace=False)

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

Pauli.conjugate()

Return the conjugate of each Pauli in the list.

copy

Pauli.copy()

Make a deep copy of current operator.

delete

Pauli.delete(qubits)

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

Pauli.dot(other, qargs=None, inplace=False)

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

Pauli.equiv(other)

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

Pauli.evolve(other, qargs=None, frame='h')

Heisenberg picture evolution of a Pauli by a Clifford.

This returns the Pauli $P^\prime = C^\dagger.P.C$ .

By choosing the parameter frame=’s’, this function returns the Schrödinger evolution of the Pauli $P^\prime = C.P.C^\dagger$ . This option yields a faster calculation.

Parameters

other (Pauli orClifford orQuantumCircuit) – The Clifford operator to evolve by.
qargs (list) – a list of qubits to apply the Clifford to.
frame (string) – ‘h’ for Heisenberg or ‘s’ for Schrödinger framework.

Returns

the Pauli $C^\dagger.P.C$ .

Return type

Pauli

Raises

QiskitError – if the Clifford number of qubits and qargs don’t match.

expand

Pauli.expand(other)

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

Pauli.input_dims(qargs=None)

Return tuple of input dimension for specified subsystems.

insert

Pauli.insert(qubits, value)

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

Pauli.inverse()

Return the inverse of the Pauli.

output_dims

Pauli.output_dims(qargs=None)

Return tuple of output dimension for specified subsystems.

power

Pauli.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

Pauli

Raises

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

reshape

Pauli.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.

set_truncation

classmethod Pauli.set_truncation(val)

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

Pauli.tensor(other)

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

Pauli.to_instruction()

Convert to Pauli circuit instruction.

to_label

Pauli.to_label()

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

Pauli.to_matrix(sparse=False)

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

Pauli.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.

Return type

Dict

x

The x vector for the Pauli.

z

The z vector for the Pauli.

Was this page helpful?

Report a bug or request content on GitHub.