PauliRep Class

[dsvandet]

These notes are related to the PaulRep class for dealing with different string representations for Pauli Operators

TODO: A detailed requirement is required

Location of Code

Currently the class is located at dsvandet/qiskit-terra/tree/paulilist_representations.

TODO

The following needs to be done:

• Convert remaining existing uses of older, single format/representation methods to more general methods.
• Add ability to output Pauli strings is different representations (currently the conversion tools exist but are not used when printing a Pauli)
• Unit tests

PauliRep Class

Note: This material was originally is the #6 Discussion but has been moved here as a stand alone discussion topic

PauliRep Class: Representations

The BasePauli class internally stores a list of Pauli operators a symplectic matrix plus a phase vector. The symplectic matrix is actually stored as two matrices: an $X$ and and $Z$ type matrix. If phases are not of interest then the symplectic representation is the same for a wide range of representations (see below) of Pauli operators. The only point that needs to be mentioned is that you need to know which is the $X$ and $Z$ parts. If phases are included, then how the symplectic representation and phase combine to create a Pauli changes.

The symplectic representation within the BasePauli, Pauli and PauliList classes is stored as a pair of boolean numpy arrays. This representation is good when these matrices are dense but quickly become inefficient once when the matrices are sparse - especially as the number of qubits grows.

TODO: Change PauliBase and associated classes (Pauli and PauliList) so that different storage methods are possible. One possible internal storage is alist format. At the very least we should be and to read in and give output in alist format.

Given the minimal generating set for the $n$-qubit Paulis $\langle iI,X_1,X_2,\dots,X_n,Z_1,Z_2,\dots,Z_n \rangle$ any Pauli operator $P\in\mathcal{P}_n$ can be represented by a pair $(\phi{},S)$ where $\phi\in{1,-1,i,-i}$ is the phase and $S$ is the symplectic representation of the Pauli operator relative to the standard generating set.

Note You can also represent the symplectic matrix in terms of a different generating set. This is to be discussed in another thread.

There are several ways to represent a Pauli operator and some of these are given here. Without loss of generality we use the standard normalized generating set for $\mathcal{P}_n$. In the following representations $\delta_j,\rho_j \in F_2$ for all $j$.

Format	Representation
XZ	$P = \phi * X^{\delta_1} Z^{\rho_1} \otimes ... \otimes X^{\delta_n} Z^{\rho_n}$
ZX	$P = \phi * Z^{\rho_1} X^{\delta_1} \otimes ... \otimes Z^{\rho_n} X^{\delta_n}$
XZY	$P = \phi * i^{\delta_1\rho_1} X^{\delta_1} Z^{\rho_1} \otimes ... \otimes i^{\delta_n\rho_n} X^{\delta_n} Z^{\rho_n}$
YZX	$P = \phi * (-i)^{\delta_1\rho_1} Z^{\rho_1} X^{\delta_1} \otimes ... \otimes (-i)^{\delta_n\rho_n} Z^{\rho_n} X^{\delta_n}$

The XZY and YZX representations can be simplified to a single representation

$P = \phi * P_1\otimes ... \otimes P_n$

where $P_j \in {I,X,Z,Y}$ and then the difference only occurs when expanding the Y operators into $iXY$ or $-iZX$. This happens internally since the $X$ and $Z$ components are stored.

Example: consider the Pauli operator $P=-iXZY = -i X\otimes Z \otimes Y$. Below is how $P$ could be represented in the different formats above:

Format	Mathematical Representation	String Representation
XZ	$\phantom{-i} X\otimes Z \otimes XZ$	$\phantom{-i}XIIZXZ$
ZX	$-\phantom{i} X\otimes Z\otimes ZX$	$-\phantom{i}IXZIZX$
XZY	$-i X\otimes Z\otimes iXZ = -i X\otimes Z\otimes Y $	$-i (XI)(IZ)(iXZ) = -iXZY$
YZX	$-i X\otimes Z\otimes -iZX = -i X\otimes Z\otimes Y$	$-i (IX)(ZI)(-iZX) = -iXZY$

Issue: The string format for the YZX format could cause confusion if the parenthesis as not used as the string representation for $P=-iXZY$ could be interpreted as either $-i X\otimes Z\otimes Y$ or $-iX\otimes Z - Z\otimes X$.

It is also sometimes useful to represent the phase $\phi$ is differently. The following are some examples:

Format	Mathematical Representation	String Representation
i. format	$i^r$ where $r \in F_4$	$r$
-i format	$(-i)^r$ where $r \in F_4$	$r$
is format	$i^r (-1)^s$ where $r,s \in F_2$	$(r,s)$
-is format	$(-i)^r (-1)^s$ where $r,s, \in F_2$	$(r,s)$

The order of the qubits is also important when representing the different formats in an extended symplectic form. Internally Qiskit reads Pauli operator strings from left to right. That is if $P=-iXZY$ and qubits are labeled $0,1,2$ then the $Y$ component is acting on qubit $0$, the $Z$ component is acting on qubit $1$ et cetera. You could also have the more natural ordering of right to left. Below gives the example below for these two options in symplectic representation - the $X$ and $Z$ components are show in $[X|Z]$ order:

Format	String Representation	Left-Right (Qiskit Internal)	Right-Left
XZ	$\phantom{-i}XIIZXZ$	$\phantom{-i} [1 0 1\vert 1 1 0]$	$\phantom{-i} [1 0 1\vert 0 1 1]$
ZX	$-\phantom{i}IXZIZX$	$-\phantom{i} [1 0 1\vert 1 1 0]$	$-\phantom{i} [1 0 1\vert 0 1 1]$
XZY	$-i 1XI1IZiXZ = -iXZY$	$-i [1 0 1\vert 1 1 0]$	$-i [1 0 1\vert 0 1 1]$
YZX	$-i 1IX1ZI{-iZX} = -iXZY$	$-i [1 0 1\vert 1 1 0]$	$-i [1 0 1\vert 0 1 1]$

Note that the symplectic representation (apart for qubit order differences) is the same throughout the different formats. This is also true when different phase formats are introduced.

A additional input parameter has been added to the Pauli class init method to allow users to input or output in different orders:

For example:

F=Pauli("XYXYXXXIIIX", input_qubit_order="left-to-right")

This parameter does not effect the internal right-to-left ordering, only how strings representations are output or input.

String Syntax

The are several possible syntaxes for Pauli's as strings. The standard syntax in Qiskit is the "product" syntax

$$'iXYXZ' = i X\otimes Y \otimes X \otimes Z$$

which works well for small numbers of qubits both in entering and reading. As the number of qubits gets larger, but usually the support of the Pauli remains small, this syntax becomes difficult and error prone in input and reading. For example consider:

$$'iIIIIIXIIIIIIIIIIIIIIIIIIIIIIIZ'= iX_6Z_{30} = i I^{\otimes 5}\otimes X\otimes I^{\otimes 23}\otimes Z$$

The more compact syntax of $M_i$ for the tensor with identity acting on all but the $i$-th qubit and $M$ acting on the $i$-th qubit is far better. Input of small weight/support Pauli's is much easier. This syntax is called indexed syntax. This syntax has now been added to the PauliRep class that the BasePauli, Pauli and PauliList classes inherit. It allows one to do the following:

Pauli("X1X4Y6")

This will produce a Pauli with Pauli('YIXIIXI'). The number of qubits is taken to be largest index+1. If you want say 10 qubits with only an X on the qubit 1 then you can do the following

Pauli("X1I9")

which will give you Pauli('IIIIIIIIXI'). This will also work when build PauliLists

PauliList(["X1X2X3X4", "Y9Y6X3X1"])

which will give you PauliList(['IIIIIXXXXI', 'YIIYIIXIXI']). That is the number of qubits is increased to hold all of the provide Pauli operators.

The indexed syntax is strings of the form $P_1n_1P_2n_2...P_kn_k$ where $P_i$ is one of $X,Z,Y$ or $I$ and $n_1,n_2,...,n_k$ are integers.

Implementation

The internal representation for BasePauli, Pauli and PauliList should be fixed and in some sense private - in that user programs should not be effected if we change the internal representation at a later date. Different representations are useful and so this should be provided but maintain a common internal representation.

A PauliRep class has been created to handle different input representations and conversions. The PauliRep class is then added as a base class for the BasePauli class. The current implementation can handle several different representations. Currently the following definitions are used:

Name	Meaning
phase format	How the phase is encoded (one of __PHASE_REP_FORMATS__ formats ['i','-i','is','-is'])
symplectic format	How the symplectic format is decoded (one of __SYMP_REP_FORMATS__ formats ['XZ','XZY', 'ZX', 'YZX'])
pauli format	What the combined phase and symplectic format is

Issue These name are not great. phase format is okay but symplectic format is not. When the $X$ and $Z$ parts of the symplectic representation are stored separately the symplectic representation is the same for all formats chosen. pauli format is okay. A better approach is therefore something like:

Proposed New Name	Meaning
phase format	How the phase is encoded (one of __PHASE_REP_FORMATS__ formats ['i','-i','is','-is'])
tensor format	How the Pauli operators are formatted (one of __SYMP_REP_FORMATS__ formats ['XZ','XZY', 'ZX', 'YZX'])
pauli format	What the combined phase and symplectic format is

TODO: Implement these changes for better naming

The different formats are setup as class variables in the PauliRep class. They are:

__INTERNAL_SYMP_REP_FORMAT__ = 'ZX'
    __INTERNAL_PHASE_REP_FORMAT__ = '-i'
    __INTERNAL_PAULI_REP_FORMAT__ = __INTERNAL_PHASE_REP_FORMAT__ \
        + __INTERNAL_SYMP_REP_FORMAT__
    
    __DEFAULT_EXTERNAL_SYMP_FORMAT__ = 'YZX'
    __DEFAULT_EXTERNAL_PHASE_REP_FORMAT__ = '-i'

That is the internal representation is -iZX. By default Pauli product strings representations are read in left-to-right ordering as mentioned above. The above variables cannot change this format, they are only there for reference. The default external format is -iYZX format which is what BasePauli and other started with.

The format used to read input strings and output strings is recorded in the following class variables

    __external_symp_rep_format__  = __DEFAULT_EXTERNAL_SYMP_FORMAT__
    __external_phase_rep_format__ = __DEFAULT_EXTERNAL_PHASE_REP_FORMAT__
    __external_pauli_rep_format__   = __external_phase_rep_format__ \
        + __external_symp_rep_format__

The possible formats/representations are stored in a few other class variables

    __PHASE_REP_FORMATS__ = ['i','-i','is','-is']
    __SYMP_REP_FORMATS__ = ['XZ','XZY', 'ZX', 'YZX']
    __PAULI_REP_FORMATS__ =['iXZ','iXZY','iZX','iYZX',
                               '-iXZ','-iXZY','-iZX','-iYZX',
                               'isXZ','isXZY','isZX','isYZX',
                               '-isXZ','-isXZY','-isZX','-isYZX']
    __PAULI_REP_FORMATS_SPLIT__ = {
        'iXZ': ('i','XZ'), 'iXZY':('i','XZY'), 'iZX':('i','ZX'), 'iYZX':('i','YZX'),
        '-iXZ': ('-i','XZ'), '-iXZY':('-i','XZY'), '-iZX':('-i','ZX'),
        '-iYZX':('-i','YZX'), 'isXZ': ('is','XZ'), 'isXZY':('is','XZY'),
        'isZX':('is','ZX'), 'isYZX':('is','YZX'), '-isXZ': ('-is','XZ'),
        '-isXZY':('-is','XZY'), '-isZX':('-is','ZX'), '-isYZX':('-is','YZX')
        }

An input Pauli string can be in either the product syntax or the indexed syntax. The syntax of a Pauli string can be determined by the PauliRep._syntax_type() method. Internally the __PRODUCT_SYNTAX__ and __INDEX_SYNTAX__ are integer class variables that help distinguish the different formats. That is PauliRep._syntax_type() will return one of __PRODUCT_SYNTAX__ or __INDEX_SYNTAX__ or raise an error.

Setting the Formats

The formats to use can be set with the set_formats method which calls the internal _set_formats method. This style of indirect access is followed to allow internal methods to change while maintaining a standard and consistent external API. As much as possible format checking etc should take place in the external call method.

The set_formats method has parameters phase_format and symp_format where phase_format (str) :is the phase a format string from __PHASE_REP_FORMATS__. with default set to -i. The symp_format (str) is a symplectic format string from __SYMP_REP_FORMATS__ with default set to YZX. Calling with no parameters will reset to the default external representations.

Examples: To set the external format to isXZ

PauliRep.set_formats(phase_format='is', symp_format='XZ')

To reset the external formats to the default external format of -iYZX

PauliRep.set_formats()

The external formats can also be set via the following methods:

set_external_pauli_format
set_external_phase_format
set_external_symp_format

Information on the current formats can be obtained via the following methods:

external_pauli_format(): | Display the external representation format for Pauli's
external_phase_format(): | 
external_symp_format() |
internal_phase_format()
internal_symp_format()
internal_pauli_format()
phase_formats()
symplectic_formats()
pauli_formats()

Translating between formats

The symplectic representation for all formats and syntaxes is the same where as the phase changes depending on which format is selected.

As seen from the description of the phase formats the actual phase is not stored but instead its phase exponent is stored which is either an element of $\mathbf{Z}_4$ or a tuple of $\mathbf{Z}_2$ elements.

There are various methods to convert between different formats:

convert_phase_exponent(phase, input_format=None, output_format=None)

converts between the different phase representations/encodings of the phase. This method handles vectors of exponents.

Example:

phase_exp = np.array([1,2,1,3,2])
convert_phase_exponent(phase_exp, input_format='i', output_format='is')

array([[1, 0],
            [0, 1],
            [1, 0],
            [1, 1],
            [0, 1]])

phase_exp = np.array([(0,1),(1,1),(1,0),(1,1)])
convert_phase_exponent(phase_exp, input_format='is', output_format='-i')
array([2, 1, 3, 1])

The conversions are done via precomputed matrices that describe how the various indices change when converting between different formats. Tuple formats are linearized to use single integer indices for lookup and are then expanded at the end if needed.

A representation is a combined phase and symplectic format. The following method allow one to change/translate between two different representations/formats:

change_representation(
            phase,
            y_count=0,
            *,
            input_format=None,
            output_format=None):

Here the parameter y_count is a count of the number of Y operators within the Pauli operator. This can be found using the method _count_y(array_1, array_2). As the symplectic representation does not change only the phase (exponent) is required together with the y_count of the symplectic array.

Example: Consider the Pauli P=Pauli(-YX) written in -iXZ format converted to isYZX format: In -iXZ $P=(-i)^1(XZ\otimes{}X)$ and in isYZX format $P=i^0(-1)^1(Y\otimes{}X)$.

change_representation(phase=[1], y_count=1, input_format='-iXZ', output_format='isYZX')
array([[0, 1]])

There are methods to convert between phase exponents and phases. These methods are:

exponent_to_phase(exponent, input_phase_format)
phase_to_exponent(phase, output_phase_format, roundit=True)

These methods handle vectors of exponents/phases.