Pauli Class

[dsvandet]

These notes are related to the Pauli class representing a Pauli Operators from the quantum_info modulo of qiskit-terra

These notes are in regards to satisfying the following requirement:

• Requirement: An class that represents a Pauli operator

Location of Code

Currently these changes are staged at dsvandet/qiskit-terra/tree/paulilist_representations.

Modifications and additions to Pauli class

• Moved _from_label, _split_pauli_label, _phase_from_complex functions to the PauliRep class with some functions being updated to be more general etc. See PauliRep Class notes. PauliRep is now a base class of BasePauli

• Removed _VALID_LABEL_PATTERN as no longer need here. A more general method can be found in PauliRep class. See PauliRep Class notes.

• Added input variable to __init__ method: input_qubit_order with default value of "right-to-left". This flag controls the order in which input string representations are indexed for qubits. The internal order is not changed. The option "right-to-left" reads a Pauli strings right to left. For example: the Pauli string "XZY" would have Y on qubit 0, Z on qubit 1 and X and qubit 2. Where as the value "left-to-right" option reads Pauli strings left to right. For example: the Pauli string "XZY" would have X on qubit 0, Z on qubit 1 and Y on qubit 2. The flag only has an effect on product string representations and not index representations.

• Added a new ability to use QubitMaps to access elements of a Pauli via labels defined in those Maps. For example if P=Pauli("iXYZ") then normally P[0] will return the Pauli attached to qubit 0 - so Z in this example. If a QubitMap is registered with the Pauli (instance or class) and is assigned/activated then a different indexing can be used based on that Map. For example: Consider the QubitMap that has (0,0)->0, (0,1)->1, (1,0)->2 and (1,1)->3. Then for the Pauli P=Pauli("XYZI") we would have P[(0,1)]=Z etc. See TranslationMap section below for more details

TranslationMaps

For details on TranslationMap classes see Translation Classes

The Pauli and PauliLIst class labels the quibts/Paulis as 0,1,2,... up to num_qubits-1/num_paulis-1. The the __getitem__ method is set so that subelements are accessed via this index. For example if P=Pauli("XZY") then P[0]=Y and if L=PauliList("ZYXI", "XXYZ") then P[0] = Pauli("ZYXI").

It is often useful to be able to label and access these quits using different labels. This is done with the aid of QubitMap instance. A QubitMap is a specific TranslationMap that maps labels into non-negative integers. To use a QubitMap with a Pauli or PauliList instance a map needs to be registered and then activated/assigned to the __getitem__ and/or __call__ methods.

A QubitMap may be registered with either the instance or the class. If a map is registered with an instance then only that instance can use that map. If the map is registered with the class (say Pauli class for example) then any instance of that class (here Pauli instances) may use that map. A map can be registered with none, either or both class and instance. Registration is done using either of the following the registration methods:

register(self, mapper, identifier=None, class_register=True, instance_register=False, override=True)
_register_class_map(self, *,mapper, identifier, override)
_register_instance_map(self,*,mapper, identifier, override)

At the moment the individual registration methods are semi-private but this is easily changed. The override switch allows one to overwrite a map with the same identifier. If no identifier is provided then one will be automatically generated. To use a registered map the map needs to be activated or assigned. This is done with the following methods:

use_class_map(self, identifier)
use_instance_map(self, identifier)

If no maps are to be used then the use_no_map() method can be used. You can check to see if a map is registered, with a given identifier, using one of the following methods:

map_is_registered(self, identifier)
map_is_registered_in_class(self, identifier)
map_is_registered_in_instance(self, identifier)

Examples:

B=Pauli("X1Z2Y4")
my_map = QubitMap(data={0:4,1:3,2:2,3:1,4:0})
B.register(my_map, identifier=1, class_register=True, instance_register=False, override=True)
B.use_class_map(1)

C=Pauli("X1Z2Y4")
his_map = QubitMap(data={(0,0):0,(0,1):1,(1,0):2,(1,1):3,(2,2):4})
C.register(his_map, identifier=1, class_register=False, instance_register=True, override=True)
C.use_instance_map(1)

See the TranslationMap Classes discussion for more examples and details TranslationMaps

The registered maps are stored in a dictionaries. These dictionaries can be accessed via the class_map_dict() and instance_map_dict() methods.

The use of QubitMaps is done by changing the __getitem__and __call__ methods. The __getitem__ method returns the __instance_getitem__ method which is either set to return the __getitem_map__ method or the __getitem_nomap__ method. The
__instance_getitem__ method uses the QubitMap to translate the map labels or indices to the internal labels/indices. These translated labels are pass to the __getitem_nomap__ method. If no QubitMap is being used then the __instance_getitem__ method simply returns the __getitem_nomap__ method.

The __call__ method will use to function method within the QubitMap if one is present. The __getitem__ method on the other hand will use what ever method is configured within the QubitMap.

TODO: Currently the registration methods etc are coded into the Pauli class. We also need this for the PauliList Class and a map may need to be useable in both Pauli and PauliList classes. Therefore we should move this capability to the BasePauli Class or some other class that can be used my other classes.