def pauli_mult(pauli_1, pauli_2, wire_map=None):
"""Multiply two Pauli words together and return the product as a Pauli word.
Two Pauli operations can be multiplied together by taking the additive
OR of their binary symplectic representations.
Args:
pauli_1 (.Operation): A Pauli word.
pauli_2 (.Operation): A Pauli word to multiply with the first one.
wire_map (dict[Union[str, int], int]): dictionary containing all wire labels used in the Pauli
word as keys, and unique integer labels as their values. If no wire map is
provided, the map will be constructed from the set of wires acted on
by the input Pauli words.
Returns:
.Operation: The product of pauli_1 and pauli_2 as a Pauli word
(ignoring the global phase).
**Example**
This function enables multiplication of Pauli group elements at the level of
Pauli words, rather than matrices. For example,
>>> from pennylane.grouping import pauli_mult
>>> pauli_1 = qml.PauliX(0) @ qml.PauliZ(1)
>>> pauli_2 = qml.PauliY(0) @ qml.PauliZ(1)
>>> product = pauli_mult(pauli_1, pauli_2)
>>> print(product)
PauliZ(wires=[0])
"""
if wire_map is None:
wire_map = _wire_map_from_pauli_pair(pauli_1, pauli_2)
# Check if pauli_1 and pauli_2 are the same; if so, the result is the Identity
if are_identical_pauli_words(pauli_1, pauli_2):
first_wire = list(pauli_1.wires)[0]
return Identity(first_wire)
# Compute binary symplectic representations
pauli_1_binary = pauli_to_binary(pauli_1, wire_map=wire_map)
pauli_2_binary = pauli_to_binary(pauli_2, wire_map=wire_map)
bin_symp_1 = np.array([int(x) for x in pauli_1_binary])
bin_symp_2 = np.array([int(x) for x in pauli_2_binary])
# Shorthand for bitwise XOR of numpy arrays
pauli_product = bin_symp_1 ^ bin_symp_2
return binary_to_pauli(pauli_product, wire_map=wire_map)
def test_pauli_to_binary_with_wire_map(self, op, vec):
"""Test conversion of Pauli word from operator to binary vector representation if a
``wire_map`` is specified."""
wire_map = {"a": 0, "b": 1, "c": 2, 6: 3}
assert (pauli_to_binary(op, wire_map=wire_map) == vec).all()
def test_pauli_to_binary_with_wire_map(self, op, vec):
"""Test conversion of Pauli word from operator to binary vector representation if a
`wire_map` is specified."""
wire_map = {Wires("a"): 0, Wires("b"): 1, Wires("c"): 2, Wires(6): 3}
assert (pauli_to_binary(op, wire_map=wire_map) == vec).all()
def test_is_qwc(self):
"""Determining if two Pauli words are qubit-wise commuting."""
n_qubits = 3
wire_map = {0: 0, "a": 1, "b": 2}
p1_vec = pauli_to_binary(PauliX(0) @ PauliY("a"), wire_map=wire_map)
p2_vec = pauli_to_binary(PauliX(0) @ Identity("a") @ PauliX("b"),
wire_map=wire_map)
p3_vec = pauli_to_binary(PauliX(0) @ PauliZ("a") @ Identity("b"),
wire_map=wire_map)
identity = pauli_to_binary(Identity("a") @ Identity(0),
wire_map=wire_map)
assert is_qwc(p1_vec, p2_vec)
assert not is_qwc(p1_vec, p3_vec)
assert is_qwc(p2_vec, p3_vec)
assert (is_qwc(p1_vec, identity) == is_qwc(p2_vec, identity) == is_qwc(
p3_vec, identity) == is_qwc(identity, identity) == True)
def diagonalize_qwc_pauli_words(qwc_grouping):
"""Diagonalizes a list of mutually qubit-wise commutative Pauli words.
Args:
qwc_grouping (list[Observable]): a list of observables containing mutually
qubit-wise commutative Pauli words
Returns:
tuple:
* list[Operation]: an instance of the qwc_rotation template which
diagonalizes the qubit-wise commuting grouping
* list[Observable]: list of Pauli string observables diagonal in
the computational basis
Raises:
ValueError: if any 2 elements in the input QWC grouping are not qubit-wise commutative
**Example**
>>> qwc_group = [qml.PauliX(0) @ qml.PauliZ(1),
qml.PauliX(0) @ qml.PauliY(3),
qml.PauliZ(1) @ qml.PauliY(3)]
>>> diagonalize_qwc_pauli_words(qwc_group)
([RY(-1.5707963267948966, wires=[0]), RX(1.5707963267948966, wires=[3])],
[Tensor(PauliZ(wires=[0]), PauliZ(wires=[1])),
Tensor(PauliZ(wires=[0]), PauliZ(wires=[3])),
Tensor(PauliZ(wires=[1]), PauliZ(wires=[3]))])
"""
m_paulis = len(qwc_grouping)
all_wires = Wires.all_wires(
[pauli_word.wires for pauli_word in qwc_grouping])
wire_map = {label: ind for ind, label in enumerate(all_wires)}
for i in range(m_paulis):
for j in range(i + 1, m_paulis):
if not is_qwc(
pauli_to_binary(qwc_grouping[i], wire_map=wire_map),
pauli_to_binary(qwc_grouping[j], wire_map=wire_map),
):
raise ValueError(
"{} and {} are not qubit-wise commuting.".format(
qwc_grouping[i], qwc_grouping[j]))
pauli_operators = []
diag_terms = []
paulis_with_identity = (qml.PauliX, qml.PauliY, qml.PauliZ, qml.Identity)
for term in qwc_grouping:
diag_terms.append(diagonalize_pauli_word(term))
if isinstance(term, Tensor):
for sigma in term.obs:
if sigma.name != "Identity":
if not any([
are_identical_pauli_words(sigma, existing_pauli)
for existing_pauli in pauli_operators
]):
pauli_operators.append(sigma)
elif isinstance(term, paulis_with_identity):
sigma = term
if sigma.name != "Identity":
if not any([
are_identical_pauli_words(sigma, existing_pauli)
for existing_pauli in pauli_operators
]):
pauli_operators.append(sigma)
unitary = qwc_rotation(pauli_operators)
return unitary, diag_terms
def test_pauli_to_binary_no_wire_map(self, op, vec):
"""Test conversion of Pauli word from operator to binary vector representation when no
``wire_map`` is specified."""
assert (pauli_to_binary(op) == vec).all()