qml.grouping¶
This subpackage defines functions and classes for generating and manipulating elements of the Pauli group. It also contains Pauliword partitioning functionality used in measurement optimization.
Pauli group¶
The singlequbit Pauli group consists of the four singlequbit Pauli operations
Identity
, PauliX
,
PauliY
, and PauliZ
. The \(n\)qubit
Pauli group is constructed by taking all possible \(N\)fold tensor products
of these elements. Elements of the \(n\)qubit Pauli group are often known
as Pauli words, and have the form \(P_J = \otimes_{i=1}^{n}\sigma_i^{(J)}\),
where \(\sigma_i^{(J)}\) is one of the Pauli operators
(PauliX
, PauliY
,
PauliZ
) or identity (Identity
) acting on
the \(i^{th}\) qubit. The full \(n\)qubit Pauli group has size
\(4^n\) (neglecting the four possible global phases that may arise from
multiplication of its elements).
The Pauli group can be constructed using the pauli_group()
function. To construct the group, it is recommended to provide a wire map in
order to indicate the names and indices of the wires. (If none is provided, a
default mapping of integers will be used.)
>>> from pennylane.grouping import pauli_group
>>> pg_3 = list(pauli_group(3))
Multiplication of Pauli group elements can be performed using
pauli_mult()
or
pauli_mult_with_phase()
:
>>> from pennylane.grouping import pauli_mult
>>> wire_map = {'a' : 0, 'b' : 1, 'c' : 2}
>>> pg = list(pauli_group(3, wire_map=wire_map))
>>> pg[3]
PauliZ(wires=['b']) @ PauliZ(wires=['c'])
>>> pg[55]
PauliY(wires=['a']) @ PauliY(wires=['b']) @ PauliZ(wires=['c'])
>>> pauli_mult(pg[3], pg[55], wire_map=wire_map)
PauliY(wires=['a']) @ PauliX(wires=['b'])
Pauli observables can be converted to strings (and vice versa):
>>> from pennylane.grouping import pauli_word_to_string, string_to_pauli_word
>>> pauli_word_to_string(pg[55], wire_map=wire_map)
'YYZ'
>>> string_to_pauli_word('ZXY', wire_map=wire_map)
PauliZ(wires=['a']) @ PauliX(wires=['b']) @ PauliY(wires=['c'])
The matrix representation for arbitrary Paulis and wire maps can also be performed.
>>> pennylane.grouping import pauli_word_to_matrix
>>> wire_map = {'a' : 0, 'b' : 1}
>>> pauli_word = qml.PauliZ('b') # corresponds to Pauli 'IZ'
>>> pauli_word_to_matrix(pauli_word, wire_map=wire_map)
array([[ 1., 0., 0., 0.],
[ 0., 1., 0., 0.],
[ 0., 0., 1., 0.],
[ 0., 0., 0., 1.]])
Grouping observables¶
Pauli words can be used for expressing a qubit Hamiltonian
.
A qubit Hamiltonian has the form \(H_{q} = \sum_{J} C_J P_J\) where
\(C_{J}\) are numerical coefficients, and \(P_J\) are Pauli words.
A list of Pauli words can be partitioned according to certain grouping
strategies. As an example, the group_observables()
function partitions
a list of observables (Pauli operations and tensor products thereof) into
groupings according to a binary relation (e.g., qubitwise commuting):
>>> observables = [qml.PauliY(0), qml.PauliX(0) @ qml.PauliX(1), qml.PauliZ(1)]
>>> obs_groupings = group_observables(observables)
>>> obs_groupings
[[Tensor(PauliX(wires=[0]), PauliX(wires=[1]))],
[PauliY(wires=[0]), PauliZ(wires=[1])]]
The \(C_{J}\) coefficients for each \(P_J\) Pauli word making up a Hamiltonian can also be specified along with further options, such as the Pauliword grouping method (e.g., qubitwise commuting) and the underlying graphcolouring algorithm (e.g., recursive largest first) used for creating the groups of observables:
>>> obs = [qml.PauliY(0), qml.PauliX(0) @ qml.PauliX(1), qml.PauliZ(1)]
>>> coeffs = [1.43, 4.21, 0.97]
>>> obs_groupings, coeffs_groupings = group_observables(obs, coeffs, 'qwc', 'rlf')
>>> obs_groupings
[[Tensor(PauliX(wires=[0]), PauliX(wires=[1]))],
[PauliY(wires=[0]), PauliZ(wires=[1])]]
>>> coeffs_groupings
[[4.21], [1.43, 0.97]]
pennylane.grouping Package¶
This subpackage defines functions and classes for Pauliword partitioning functionality used in measurement optimization.
Functions¶

Performs a check if two Pauli words have the same 

Converts a binary vector of even dimension to an Observable instance. 

Transforms the Pauli word to diagonal form in the computational basis. 

Diagonalizes a list of qubitwise commutative groupings of Pauli strings. 

Diagonalizes a list of mutually qubitwise commutative Pauli words. 

Partitions a list of observables (Pauli operations and tensor products thereof) into groupings according to a binary relation (qubitwise commuting, fullycommuting, or anticommuting). 

Checks if two Pauli words commute. 

Checks if an observable instance is a Pauli word. 

Checks if two Pauli words in the binary vector representation are qubitwise commutative. 

Converts a list of Pauli words to the binary vector representation and yields a row matrix of the binary vectors. 

Partitions then diagonalizes a list of Pauli words, facilitating simultaneous measurement of all observables within a partition. 

Generate the \(n\)qubit Pauli group. 

Multiply two Pauli words together and return the product as a Pauli word. 

Multiply two Pauli words together, and return both their product as a Pauli word and the global phase. 

Converts a Pauli word to the binary vector representation. 

Convert a Pauli word from a tensor to its matrix representation. 

Convert a Pauli word from a tensor to a string. 

Obtains the adjacency matrix for the complementary graph of the qubitwise commutativity graph for a given set of observables in the binary representation. 

Performs circuit implementation of diagonalizing unitary for a Pauli word. 

Convert a string in terms of 
Classes¶

Class for partitioning a list of Pauli words according to some binary symmetric relation. 
pennylane.grouping.graph_colouring Module¶
A module for heuristic algorithms for colouring Pauli graphs.
A Pauli graph is a graph where vertices represent Pauli words and edges denote if a specified symmetric binary relation (e.g., commutation) is satisfied for the corresponding Pauli words. The graphcolouring problem is to assign a colour to each vertex such that no vertices of the same colour are connected, using the fewest number of colours (lowest “chromatic number”) as possible.
Functions¶

Performs graphcolouring using the Largest Degree First heuristic. 

Performs graphcolouring using the Recursive Largest Degree First heuristic. 
Contents
Downloads