qml.devices.default_qubit.DefaultQubit

class DefaultQubit(wires, *, shots=1000, analytic=True)

Bases: pennylane._qubit_device.QubitDevice

Default qubit device for PennyLane.

Parameters

• wires (int, Iterable[Number, str]) – Number of subsystems represented by the device, or iterable that contains unique labels for the subsystems as numbers (i.e., [-1, 0, 2]) or strings (['ancilla', 'q1', 'q2']). Default 1 if not specified.

• shots (int) – How many times the circuit should be evaluated (or sampled) to estimate the expectation values. Defaults to 1000 if not specified. If analytic == True, then the number of shots is ignored in the calculation of expectation values and variances, and only controls the number of samples returned by sample.

• analytic (bool) – indicates if the device should calculate expectations and variances analytically

Attributes

author
circuit_hash	The hash of the circuit upon the last execution.
name
obs_queue	The observables to be measured and returned.
observables
op_queue	The operation queue to be applied.
operations
parameters	Mapping from free parameter index to the list of Operations in the device queue that depend on it.
pennylane_requires
short_name
shots	Number of circuit evaluations/random samples used to estimate expectation values of observables
state	Returns the state vector of the circuit prior to measurement.
version
wire_map	Ordered dictionary that defines the map from user-provided wire labels to the wire labels used on this device
wires	All wires that can be addressed on this device

author = 'Xanadu Inc.'

circuit_hash

The hash of the circuit upon the last execution.

This can be used by devices in apply() for parametric compilation.

name = 'Default qubit PennyLane plugin'

obs_queue

The observables to be measured and returned.

Note that this property can only be accessed within the execution context of execute().

Raises

ValueError – if outside of the execution context

Returns

list[~.operation.Observable]

observables = {'Hadamard', 'Hermitian', 'Identity', 'PauliX', 'PauliY', 'PauliZ'}

op_queue

The operation queue to be applied.

Note that this property can only be accessed within the execution context of execute().

Raises

ValueError – if outside of the execution context

Returns

list[~.operation.Operation]

operations = {'BasisState', 'CNOT', 'CRX', 'CRY', 'CRZ', 'CRot', 'CSWAP', 'CZ', 'DiagonalQubitUnitary', 'Hadamard', 'MultiRZ', 'PauliX', 'PauliY', 'PauliZ', 'PhaseShift', 'QubitStateVector', 'QubitUnitary', 'RX', 'RY', 'RZ', 'Rot', 'S', 'SWAP', 'T', 'Toffoli'}

parameters

Mapping from free parameter index to the list of Operations in the device queue that depend on it.

Note that this property can only be accessed within the execution context of execute().

Raises

ValueError – if outside of the execution context

Returns

the mapping

Return type

dict[int->list[ParameterDependency]]

pennylane_requires = '0.11'

short_name = 'default.qubit'

shots

Number of circuit evaluations/random samples used to estimate expectation values of observables

state

Returns the state vector of the circuit prior to measurement.

Note

Only state vector simulators support this property. Please see the plugin documentation for more details.

version = '0.11.0'

wire_map

Ordered dictionary that defines the map from user-provided wire labels to the wire labels used on this device

wires

All wires that can be addressed on this device

Methods

active_wires(operators)	Returns the wires acted on by a set of operators.
analytic_probability([wires])	Return the (marginal) probability of each computational basis state from the last run of the device.
apply(operations[, rotations])	Apply quantum operations, rotate the circuit into the measurement basis, and compile and execute the quantum circuit.
capabilities()	Get the capabilities of the plugin.
check_validity(queue, observables)	Checks whether the operations and observables in queue are all supported by the device.
define_wire_map(wires)	Create the map from user-provided wire labels to the wire labels used by the device.
estimate_probability([wires])	Return the estimated probability of each computational basis state using the generated samples.
execute(circuit, **kwargs)	Execute a queue of quantum operations on the device and then measure the given observables.
execution_context()	The device execution context used during calls to execute().
expval(observable)	Returns the expectation value of observable on specified wires.
generate_samples()	Returns the computational basis samples generated for all wires.
map_wires(wires)	Map the wire labels of wires using this device’s wire map.
marginal_prob(prob[, wires])	Return the marginal probability of the computational basis states by summing the probabiliites on the non-specified wires.
post_apply()	Called during execute() after the individual operations have been executed.
post_measure()	Called during execute() after the individual observables have been measured.
pre_apply()	Called during execute() before the individual operations are executed.
pre_measure()	Called during execute() before the individual observables are measured.
probability([wires])	Return either the analytic probability or estimated probability of each computational basis state.
reset()	Reset the device
sample(observable)	Return a sample of an observable.
sample_basis_states(number_of_states, …)	Sample from the computational basis states based on the state probability.
states_to_binary(samples, num_wires)	Convert basis states from base 10 to binary representation.
statistics(observables)	Process measurement results from circuit execution and return statistics.
supports_observable(observable)	Checks if an observable is supported by this device. Raises a ValueError,
supports_operation(operation)	Checks if an operation is supported by this device.
var(observable)	Returns the variance of observable on specified wires.

static active_wires(operators)

Returns the wires acted on by a set of operators.

Parameters

operators (list[Operation]) – operators for which we are gathering the active wires

Returns

wires activated by the specified operators

Return type

Wires

analytic_probability(wires=None)

Return the (marginal) probability of each computational basis state from the last run of the device.

PennyLane uses the convention \(|q_0,q_1,\dots,q_{N-1}\rangle\) where \(q_0\) is the most significant bit.

If no wires are specified, then all the basis states representable by the device are considered and no marginalization takes place.

Note

marginal_prob() may be used as a utility method to calculate the marginal probability distribution.

Parameters

wires (Iterable[Number, str], Number, str, Wires) – wires to return marginal probabilities for. Wires not provided are traced out of the system.

Returns

list of the probabilities

Return type

List[float]

apply(operations, rotations=None, **kwargs)

Apply quantum operations, rotate the circuit into the measurement basis, and compile and execute the quantum circuit.

This method receives a list of quantum operations queued by the QNode, and should be responsible for:

• Constructing the quantum program

• (Optional) Rotating the quantum circuit using the rotation operations provided. This diagonalizes the circuit so that arbitrary observables can be measured in the computational basis.

• Compile the circuit

• Execute the quantum circuit

Both arguments are provided as lists of PennyLane Operation instances. Useful properties include name, wires, and parameters, and inverse:

>>> op = qml.RX(0.2, wires=[0])
>>> op.name # returns the operation name
"RX"
>>> op.wires # returns a Wires object representing the wires that the operation acts on
<Wires = [0]>
>>> op.parameters # returns a list of parameters
[0.2]
>>> op.inverse # check if the operation should be inverted
False
>>> op = qml.RX(0.2, wires=[0]).inv
>>> op.inverse
True

Parameters

operations (list[Operation]) – operations to apply to the device

Keyword Arguments

• rotations (list[Operation]) – operations that rotate the circuit pre-measurement into the eigenbasis of the observables.

• hash (int) – the hash value of the circuit constructed by CircuitGraph.hash

classmethod capabilities()

Get the capabilities of the plugin.

Capabilities include:

• "model" (str): either "qubit" or "CV".

• "inverse_operations" (bool): True if the device supports applying the inverse of operations. Operations which should be inverted have operation.inverse == True.

• "tensor_observables" (*bool*): ``True if the device supports expectation values/variance/samples of Tensor observables.

The qubit device class has built-in support for tensor observables. As a result, devices that inherit from this class automatically have the following items in their capabilities dictionary:

• "model": "qubit"

• "tensor_observables": True

Returns

results

Return type

dict[str->*]

check_validity(queue, observables)

Checks whether the operations and observables in queue are all supported by the device. Includes checks for inverse operations.

Parameters

• queue (Iterable[Operation]) – quantum operation objects which are intended to be applied on the device

• observables (Iterable[Observable]) – observables which are intended to be evaluated on the device

Raises

DeviceError – if there are operations in the queue or observables that the device does not support

define_wire_map(wires)

Create the map from user-provided wire labels to the wire labels used by the device.

The default wire map maps the user wire labels to wire labels that are consecutive integers.

However, by overwriting this function, devices can specify their preferred, non-consecutive and/or non-integer wire labels.

Parameters

wires (Wires) – user-provided wires for this device

Returns

dictionary specifying the wire map

Return type

OrderedDict

Example

>>> dev = device('my.device', wires=['b', 'a'])
>>> dev.wire_map()
OrderedDict( [(<Wires = ['a']>, <Wires = [0]>), (<Wires = ['b']>, <Wires = [1]>)])

estimate_probability(wires=None)

Return the estimated probability of each computational basis state using the generated samples.

Parameters

wires (Iterable[Number, str], Number, str, Wires) – wires to calculate marginal probabilities for. Wires not provided are traced out of the system.

Returns

list of the probabilities

Return type

List[float]

execute(circuit, **kwargs)

Execute a queue of quantum operations on the device and then measure the given observables.

For plugin developers: instead of overwriting this, consider implementing a suitable subset of

• apply()

• generate_samples()

• probability()

Additional keyword arguments may be passed to the this method that can be utilised by apply(). An example would be passing the QNode hash that can be used later for parametric compilation.

Parameters

circuit (CircuitGraph) – circuit to execute on the device

Raises

QuantumFunctionError – if the value of return_type is not supported

Returns

measured value(s)

Return type

array[float]

execution_context()

The device execution context used during calls to execute().

You can overwrite this function to return a context manager in case your quantum library requires that; all operations and method calls (including apply() and expval()) are then evaluated within the context of this context manager (see the source of Device.execute() for more details).

expval(observable)

Returns the expectation value of observable on specified wires.

Note: all arguments accept _lists_, which indicate a tensor product of observables.

Parameters

• observable (str or list[str]) – name of the observable(s)

• wires (Wires) – wires the observable(s) are to be measured on

• par (tuple or list[tuple]]) – parameters for the observable(s)

Returns

expectation value \(\expect{A} = \bra{\psi}A\ket{\psi}\)

Return type

float

generate_samples()

Returns the computational basis samples generated for all wires.

Note that PennyLane uses the convention \(|q_0,q_1,\dots,q_{N-1}\rangle\) where \(q_0\) is the most significant bit.

Warning

This method should be overwritten on devices that generate their own computational basis samples, with the resulting computational basis samples stored as self._samples.

Returns

array of samples in the shape (dev.shots, dev.num_wires)

Return type

array[complex]

map_wires(wires)

Map the wire labels of wires using this device’s wire map.

Parameters

wires (Wires) – wires whose labels we want to map to the device’s internal labelling scheme

Returns

wires with new labels

Return type

Wires

marginal_prob(prob, wires=None)

Return the marginal probability of the computational basis states by summing the probabiliites on the non-specified wires.

If no wires are specified, then all the basis states representable by the device are considered and no marginalization takes place.

Note

If the provided wires are not in the order as they appear on the device, the returned marginal probabilities take this permutation into account.

For example, if the addressable wires on this device are Wires([0, 1, 2]) and this function gets passed wires=[2, 0], then the returned marginal probability vector will take this ‘reversal’ of the two wires into account:

\[\mathbb{P}^{(2, 0)} = \left[ |00\rangle, |10\rangle, |01\rangle, |11\rangle \right]\]

Parameters

• prob – The probabilities to return the marginal probabilities for

• wires (Iterable[Number, str], Number, str, Wires) – wires to return marginal probabilities for. Wires not provided are traced out of the system.

Returns

array of the resulting marginal probabilities.

Return type

array[float]

post_apply()

Called during execute() after the individual operations have been executed.

post_measure()

Called during execute() after the individual observables have been measured.

pre_apply()

Called during execute() before the individual operations are executed.

pre_measure()

Called during execute() before the individual observables are measured.

probability(wires=None)

Return either the analytic probability or estimated probability of each computational basis state.

If no analytic attributes exists for the device, then return the estimated probability.

Parameters

wires (Iterable[Number, str], Number, str, Wires) – wires to return marginal probabilities for. Wires not provided are traced out of the system.

Returns

list of the probabilities

Return type

List[float]

reset()

Reset the device

sample(observable)

Return a sample of an observable.

The number of samples is determined by the value of Device.shots, which can be directly modified.

Note: all arguments support _lists_, which indicate a tensor product of observables.

Parameters

• observable (str or list[str]) – name of the observable(s)

• wires (Wires) – wires the observable(s) is to be measured on

• par (tuple or list[tuple]]) – parameters for the observable(s)

Raises

NotImplementedError – if the device does not support sampling

Returns

samples in an array of dimension (shots,)

Return type

array[float]

sample_basis_states(number_of_states, state_probability)

Sample from the computational basis states based on the state probability.

This is an auxiliary method to the generate_samples method.

Parameters

number_of_states (int) – the number of basis states to sample from

Returns

the sampled basis states

Return type

List[int]

static states_to_binary(samples, num_wires)

Convert basis states from base 10 to binary representation.

This is an auxiliary method to the generate_samples method.

Parameters

• samples (List[int]) – samples of basis states in base 10 representation

• number_of_states (int) – the number of basis states to sample from

Returns

basis states in binary representation

Return type

List[int]

statistics(observables)

Process measurement results from circuit execution and return statistics.

This includes returning expectation values, variance, samples and probabilities.

Parameters

observables (List[Observable]) – the observables to be measured

Raises

QuantumFunctionError – if the value of return_type is not supported

Returns

the corresponding statistics

Return type

Union[float, List[float]]

supports_observable(observable)

Checks if an observable is supported by this device. Raises a ValueError,

if not a subclass or string of an Observable was passed.

Parameters

observable (type or str) – observable to be checked

Raises

ValueError – if observable is not a Observable class or string

Returns

True iff supplied observable is supported

Return type

bool

supports_operation(operation)

Checks if an operation is supported by this device.

Parameters

operation (type or str) – operation to be checked

Raises

ValueError – if operation is not a Operation class or string

Returns

True iff supplied operation is supported

Return type

bool

var(observable)

Returns the variance of observable on specified wires.

Note: all arguments support _lists_, which indicate a tensor product of observables.

Parameters

• observable (str or list[str]) – name of the observable(s)

• wires (Wires) – wires the observable(s) is to be measured on

• par (tuple or list[tuple]]) – parameters for the observable(s)

Raises

NotImplementedError – if the device does not support variance computation

Returns

variance \(\mathrm{var}(A) = \bra{\psi}A^2\ket{\psi} - \bra{\psi}A\ket{\psi}^2\)

Return type

float