Measurements¶

PennyLane can extract different types of measurement results from quantum devices: the expectation of an observable, its variance, samples of a single measurement, or computational basis state probabilities.

For example, the following circuit returns the expectation value of the PauliZ observable on wire 1:

def my_quantum_function(x, y):
    qml.RZ(x, wires=0)
    qml.CNOT(wires=[0, 1])
    qml.RY(y, wires=1)
    return qml.expval(qml.PauliZ(1))

The available measurement functions are

`expval`(op)	Expectation value of the supplied observable.
`sample`([op, wires, counts])	Sample from the supplied observable, with the number of shots determined from the `dev.shots` attribute of the corresponding device, returning raw samples (counts=False) or the number of counts for each sample (counts=True).
`var`(op)	Variance of the supplied observable.
`probs`([wires, op])	Probability of each computational basis state.
`state`()	Quantum state in the computational basis.
`density_matrix`(wires)	Quantum density matrix in the computational basis.
`vn_entropy`(wires[, log_base])	Von Neumann entropy of the system prior to measurement.
`mutual_info`(wires0, wires1[, log_base])	Mutual information between the subsystems prior to measurement:

Note

All measurement functions support analytic differentiation, with the exception of sample(), as it returns stochastic results.

Combined measurements¶

Quantum functions can also return combined measurements of multiple observables, as long as each wire is not measured more than once:

def my_quantum_function(x, y):
    qml.RZ(x, wires=0)
    qml.CNOT(wires=[0, 1])
    qml.RY(y, wires=1)
    return qml.expval(qml.PauliZ(1)), qml.var(qml.PauliX(0))

You can also use list comprehensions, and other common Python patterns:

def my_quantum_function(x, y):
    qml.RZ(x, wires=0)
    qml.CNOT(wires=[0, 1])
    qml.RY(y, wires=1)
    return [qml.expval(qml.PauliZ(i)) for i in range(2)]

As a full example of combined measurements, let us look at a Bell state \((|00\rangle + |11\rangle)/\sqrt{2}\), prepared by a Hadamard and CNOT gate.

import pennylane as qml
from pennylane import numpy as np

dev = qml.device("default.qubit", wires=2, shots=1000)

@qml.qnode(dev)
def circuit():
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    return qml.sample(qml.PauliZ(0)), qml.sample(qml.PauliZ(1))

The combined PauliZ-measurement of the first and second qubit returns a list of two lists, each containing the measurement results of the respective qubit. As a default, sample() returns 1000 samples per observable.

>>> result = circuit()
>>> result.shape
(2, 1000)

Since the two qubits are maximally entangled, the measurement results always coincide, and the lists are therefore equal:

>>> np.all(result[0] == result[1])
True

Tensor observables¶

PennyLane supports measuring the tensor product of observables, by using the @ notation. For example, to measure the expectation value of \(Z\otimes I \otimes X\):

def my_quantum_function(x, y):
    qml.RZ(x, wires=0)
    qml.CNOT(wires=[0, 1])
    qml.RY(y, wires=1)
    qml.CNOT(wires=[0, 2])
    return qml.expval(qml.PauliZ(0) @ qml.PauliX(2))

Note that we don’t need to declare the identity observable on wire 1; this is implicitly assumed.

The tensor observable notation can be used inside all measurement functions that accept observables as arguments, including expval(), var(), and sample().

Counts¶

To avoid dealing with long arrays for the larger numbers of shots, one can pass an argument counts=True to sample(). In this case, the result will be a dictionary containing the number of occurrences for each unique sample. The previous example will be modified as follows:

dev = qml.device("default.qubit", wires=2, shots=1000)

@qml.qnode(dev)
def circuit():
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    # passing the counts flag
    return qml.sample(qml.PauliZ(0), counts=True), qml.sample(qml.PauliZ(1), counts=True)

After executing the circuit, we can directly see how many times each measurement outcome occurred:

>>> result = circuit()
>>> print(result)
[{-1: 526, 1: 474} {-1: 526, 1: 474}]

Similarly, if the observable is not provided, the count of each computational basis state is returned.

dev = qml.device("default.qubit", wires=2, shots=1000)

@qml.qnode(dev)
def circuit():
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    # passing the counts flag
    return qml.sample(counts=True)

And the result is:

>>> result = circuit()
>>> print(result)
{'00': 495, '11': 505}

If counts are obtained along with a measurement function other than sample(), a tensor of tensors is returned to provide differentiability for the outputs of QNodes.

@qml.qnode(dev)
def circuit():
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0,1])
    qml.PauliX(wires=2)
    return qml.expval(qml.PauliZ(0)),qml.expval(qml.PauliZ(1)), qml.sample(counts=True)

>>> result = circuit()
>>> print(result)
[tensor(0.026, requires_grad=True) tensor(0.026, requires_grad=True)
 tensor({'001': 513, '111': 487}, dtype=object, requires_grad=True)]

Probability¶

You can also train QNodes on computational basis probabilities, by using the probs() measurement function. The function can accept either specified wires or an observable that rotates the computational basis.

def my_quantum_function(x, y):
    qml.RZ(x, wires=0)
    qml.CNOT(wires=[0, 1])
    qml.RY(y, wires=1)
    qml.CNOT(wires=[0, 2])
    return qml.probs(wires=[0, 1])

For example:

>>> dev = qml.device("default.qubit", wires=3)
>>> qnode = qml.QNode(my_quantum_function, dev)
>>> qnode(0.56, 0.1)
array([0.99750208, 0.00249792, 0.        , 0.        ])

The returned probability array uses lexicographical ordering, so corresponds to a \(99.75\%\) probability of measuring state \(|00\rangle\), and a \(0.25\%\) probability of measuring state \(|01\rangle\).

Mid-circuit measurements and conditional operations¶

PennyLane allows specifying measurements in the middle of the circuit. Quantum functions such as operations can then be conditioned on the measurement outcome of such mid-circuit measurements:

def my_quantum_function(x, y):
    qml.RY(x, wires=0)
    qml.CNOT(wires=[0, 1])
    m_0 = qml.measure(1)

    qml.cond(m_0, qml.RY)(y, wires=0)
    return qml.probs(wires=[0])

A quantum function with mid-circuit measurements (defined using measure()) and conditional operations (defined using cond()) can be executed by applying the deferred measurement principle. In the example above, we apply the RY rotation if the mid-circuit measurement on qubit 1 yielded 1 as an outcome, otherwise doing nothing for the 0 measurement outcome.

PennyLane implements the deferred measurement principle to transform conditional operations with the defer_measurements() quantum function transform.

transformed_qfunc = qml.transforms.defer_measurements(my_quantum_function)
transformed_qnode = qml.QNode(transformed_qfunc, dev)
pars = np.array([0.643, 0.246], requires_grad=True)

>>> transformed_qnode(*pars)
tensor([0.90165331, 0.09834669], requires_grad=True)

The decorator syntax applies equally well:

@qml.qnode(dev)
@qml.defer_measurements
def qnode(x, y):
    (...)

Note that we can also specify an outcome when defining a conditional operation:

@qml.qnode(dev)
@qml.defer_measurements
def qnode_conditional_op_on_zero(x, y):
    qml.RY(x, wires=0)
    qml.CNOT(wires=[0, 1])
    m_0 = qml.measure(1)

    qml.cond(m_0 == 0, qml.RY)(y, wires=0)
    return qml.probs(wires=[0])

pars = np.array([0.643, 0.246], requires_grad=True)

>>> qnode_conditional_op_on_zero(*pars)
tensor([0.88660045, 0.11339955], requires_grad=True)

The deferred measurement principle provides a natural method to simulate the application of mid-circuit measurements and conditional operations in a differentiable and device-independent way. Performing true mid-circuit measurements and conditional operations is dependent on the quantum hardware and PennyLane device capabilities.

For more examples on applying quantum functions conditionally, refer to the cond() transform.

Changing the number of shots¶

For hardware devices where the number of shots determines the accuracy of the expectation value and variance, as well as the number of samples returned, it can sometimes be convenient to execute the same QNode with differing number of shots.

For simulators like default.qubit, finite shots will be simulated if we set shots to a positive integer.

The shot number can be changed on the device itself, or temporarily altered by the shots keyword argument when executing the QNode:

dev = qml.device("default.qubit", wires=1, shots=10)

@qml.qnode(dev)
def circuit(x, y):
    qml.RX(x, wires=0)
    qml.RY(y, wires=0)
    return qml.expval(qml.PauliZ(0))

# execute the QNode using 10 shots
result = circuit(0.54, 0.1)

# execute the QNode again, now using 1 shot
result = circuit(0.54, 0.1, shots=1)

With an increasing number of shots, the average over measurement samples converges to the exact expectation of an observable. Consider the following circuit:

# fix seed to make results reproducable
np.random.seed(1)

dev = qml.device("default.qubit", wires=1)

@qml.qnode(dev)
def circuit():
    qml.Hadamard(wires=0)
    return qml.expval(qml.PauliZ(0))

Running the simulator with shots=None returns the exact expectation.

>>> circuit(shots=None)
0.0

Now we set the device to return stochastic results, and increase the number of shots starting from 10.

>>> circuit(shots=10)
0.2

>>> circuit(shots=1000)
-0.062

>>> circuit(shots=100000)
0.00056