qml.measurements.ShadowExpvalMP

class ShadowExpvalMP(H, seed=None, k=1, id=None)

Bases: MeasurementTransform

Measures the expectation value of an operator using the classical shadow measurement process.

Please refer to shadow_expval() for detailed documentation.

Parameters:

• H (Operator, Sequence[Operator]) – Operator or list of Operators to compute the expectation value over.

• seed (Union[int, None]) – The seed used to generate the random measurements

• k (int) – Number of equal parts to split the shadow’s measurements to compute the median of means. k=1 corresponds to simply taking the mean over all measurements.

• id (str) – custom label given to a measurement instance, can be useful for some applications where the instance has to be identified

Attributes

has_decomposition	Whether or not the MeasurementProcess returns a defined decomposition when calling expand.
hash	returns an integer hash uniquely representing the measurement process
numeric_type	The Python numeric type of the measurement result.
raw_wires	The wires the measurement process acts on.
samples_computational_basis	Whether or not the MeasurementProcess measures in the computational basis.
wires	The wires the measurement process acts on.

has_decomposition

Whether or not the MeasurementProcess returns a defined decomposition when calling expand.

Type:

Bool

hash

returns an integer hash uniquely representing the measurement process

Type:

int

numeric_type

raw_wires

The wires the measurement process acts on.

For measurements involving more than one set of wires (such as mutual information), this is a list of the Wires objects. Otherwise, this is the same as wires()

samples_computational_basis

wires

The wires the measurement process acts on.

This is the union of all the Wires objects of the measurement.

Methods

diagonalizing_gates()	Returns the gates that diagonalize the measured wires such that they are in the eigenbasis of the circuit observables.
eigvals()	Eigenvalues associated with the measurement process.
expand()	Expand the measurement of an observable to a unitary rotation and a measurement in the computational basis.
map_wires(wire_map)	Returns a copy of the current measurement process with its wires changed according to the given wire map.
process(tape, device)	Process the given quantum tape.
process_density_matrix_with_shots(state, ...)	Process the given quantum state with the given number of shots
process_state_with_shots(state, wire_order, ...)	Process the given quantum state with the given number of shots
queue([context])	Append the measurement process to an annotated queue, making sure the observable is not queued
shape([shots, num_device_wires])	Calculate the shape of the result object tensor.
simplify()	Reduce the depth of the observable to the minimum.

diagonalizing_gates()

Returns the gates that diagonalize the measured wires such that they are in the eigenbasis of the circuit observables.

Returns:

the operations that diagonalize the observables

Return type:

List[.Operation]

eigvals()

Eigenvalues associated with the measurement process.

If the measurement process has an associated observable, the eigenvalues will correspond to this observable. Otherwise, they will be the eigenvalues provided when the measurement process was instantiated.

Note that the eigenvalues are not guaranteed to be in any particular order.

Example:

>>> m = MeasurementProcess(Expectation, obs=qml.X(1))
>>> m.eigvals()
array([1, -1])

Returns:

eigvals representation

Return type:

array

expand()

Expand the measurement of an observable to a unitary rotation and a measurement in the computational basis.

Returns:

a quantum tape containing the operations required to diagonalize the observable

Return type:

.QuantumTape

Example:

Consider a measurement process consisting of the expectation value of an Hermitian observable:

>>> H = np.array([[1, 2], [2, 4]])
>>> obs = qml.Hermitian(H, wires=['a'])
>>> m = MeasurementProcess(Expectation, obs=obs)

Expanding this out:

>>> tape = m.expand()

We can see that the resulting tape has the qubit unitary applied, and a measurement process with no observable, but the eigenvalues specified:

>>> print(tape.operations)
[QubitUnitary(array([[-0.89442719,  0.4472136 ],
      [ 0.4472136 ,  0.89442719]]), wires=['a'])]
>>> print(tape.measurements[0].eigvals())
[0. 5.]
>>> print(tape.measurements[0].obs)
None

map_wires(wire_map)

Returns a copy of the current measurement process with its wires changed according to the given wire map.

Parameters:

wire_map (dict) – dictionary containing the old wires as keys and the new wires as values

Returns:

new measurement process

Return type:

.MeasurementProcess

process(tape, device)

Process the given quantum tape.

Parameters:

• tape (QuantumTape) – quantum tape to transform

• device (pennylane.devices.LegacyDevice) – device used to transform the quantum tape

process_density_matrix_with_shots(state, wire_order, shots, rng=None)

Process the given quantum state with the given number of shots

Parameters:

• state (Sequence[complex]) – quantum state

• wire_order (Wires) – wires determining the subspace that state acts on; a matrix of dimension \(2^n\) acts on a subspace of \(n\) wires

• shots (int) – The number of shots

• rng (Union[None, int, array_like[int], SeedSequence, BitGenerator, Generator]) – A seed-like parameter matching that of seed for numpy.random.default_rng. If no value is provided, a default RNG will be used.

Returns:

The estimate of the expectation value.

Return type:

float

process_state_with_shots(state, wire_order, shots, rng=None)

Process the given quantum state with the given number of shots

Parameters:

• state (Sequence[complex]) – quantum state

• wire_order (Wires) – wires determining the subspace that state acts on; a matrix of dimension \(2^n\) acts on a subspace of \(n\) wires

• shots (int) – The number of shots

• rng (Union[None, int, array_like[int], SeedSequence, BitGenerator, Generator]) – A seed-like parameter matching that of seed for numpy.random.default_rng. If no value is provided, a default RNG will be used.

Returns:

The estimate of the expectation value.

Return type:

float

queue(context=<class 'pennylane.queuing.QueuingManager'>)

Append the measurement process to an annotated queue, making sure the observable is not queued

shape(shots=None, num_device_wires=0)

Calculate the shape of the result object tensor.

Parameters:

• shots (Optional[int]) – the number of shots used execute the circuit. None indicates an analytic simulation. Shot vectors are handled by calling this method multiple times.

• num_device_wires (int) – The number of wires that will be used if the measurement is broadcasted across all available wires (len(mp.wires) == 0). If the device itself doesn’t provide a number of wires, the number of tape wires will be provided here instead:

Returns:

An arbitrary length tuple of ints. May be an empty tuple.

Return type:

tuple[int,…]

>>> qml.probs(wires=(0,1)).shape()
(4,)
>>> qml.sample(wires=(0,1)).shape(shots=50)
(50, 2)
>>> qml.state().shape(num_device_wires=4)
(16,)
>>> qml.expval(qml.Z(0)).shape()
()

simplify()

Reduce the depth of the observable to the minimum.

Returns:

A measurement process with a simplified observable.

Return type:

.MeasurementProcess

code/api/pennylane.measurements.ShadowExpvalMP

 

Download Python script

 

Download Notebook

 

View on GitHub