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:

\[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}.\]

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

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\)-th qubit corresponds to the \(k\)-th entry in the \(z\) and \(x\) arrays

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

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

adjoint()[source]¶: 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.

Pauli¶

Qiskit

Navigation

Related Topics