Portuguese
Idiomas
English
Bengali
French
German
Japanese
Korean
Portuguese
Spanish
Tamil

Pauli

class Pauli(data=None, x=None, *, z=None, label=None)[código fonte]

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

Nota

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.

Parâmetros

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

Levanta

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.

x

The x vector for the Pauli.

z

The z vector for the Pauli.