qml.devices.default_qubit.DefaultQubit¶

class DefaultQubit(wires, *, shots=None, cache=0, analytic=None)[source]¶

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 (None, int) – How many times the circuit should be evaluated (or sampled) to estimate the expectation values. Defaults to None if not specified, which means that the device returns analytical results.
cache (int) – Number of device executions to store in a cache to speed up subsequent executions. A value of 0 indicates that no caching will take place. Once filled, older elements of the cache are removed and replaced with the most recent device executions to keep the cache up to date.

Attributes

`analytic`	Whether shots is None or not.
`author`
`cache`	Number of device executions to store in a cache to speed up subsequent executions.
`circuit_hash`	The hash of the circuit upon the last execution.
`name`
`num_executions`	Number of times this device is executed by the evaluation of QNodes running on this device
`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`
`shot_vector`	Returns the shot vector, a sparse representation of the shot sequence used by the device when evaluating QNodes.
`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

analytic¶: Whether shots is None or not. Kept for backwards compatability.

author = 'Xanadu Inc.'¶

cache¶

Number of device executions to store in a cache to speed up subsequent executions. If set to zero, no caching occurs.

Type: int

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'¶

num_executions¶

Number of times this device is executed by the evaluation of QNodes running on this device

Returns: number of executions
Return type: int

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', 'Hamiltonian', 'Hermitian', 'Identity', 'PauliX', 'PauliY', 'PauliZ', 'Projector', 'SparseHamiltonian'}¶

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', 'CPhase', 'CRX', 'CRY', 'CRZ', 'CRot', 'CSWAP', 'CY', 'CZ', 'ControlledPhaseShift', 'ControlledQubitUnitary', 'DiagonalQubitUnitary', 'DoubleExcitation', 'DoubleExcitationMinus', 'DoubleExcitationPlus', 'Hadamard', 'ISWAP', 'IsingXX', 'IsingYY', 'IsingZZ', 'MultiControlledX', 'MultiRZ', 'PauliX', 'PauliY', 'PauliZ', 'PhaseShift', 'QubitCarry', 'QubitStateVector', 'QubitSum', 'QubitUnitary', 'RX', 'RY', 'RZ', 'Rot', 'S', 'SISWAP', 'SQISW', 'SWAP', 'SX', 'SingleExcitation', 'SingleExcitationMinus', 'SingleExcitationPlus', '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.18.0'¶

short_name = 'default.qubit'¶

shot_vector¶

Returns the shot vector, a sparse representation of the shot sequence used by the device when evaluating QNodes.

Example

>>> dev = qml.device("default.qubit", wires=2, shots=[3, 1, 2, 2, 2, 2, 6, 1, 1, 5, 12, 10, 10])
>>> dev.shots
57
>>> dev.shot_vector
[ShotTuple(shots=3, copies=1),
 ShotTuple(shots=1, copies=1),
 ShotTuple(shots=2, copies=4),
 ShotTuple(shots=6, copies=1),
 ShotTuple(shots=1, copies=2),
 ShotTuple(shots=5, copies=1),
 ShotTuple(shots=12, copies=1),
 ShotTuple(shots=10, copies=2)]

The sparse representation of the shot sequence is returned, where tuples indicate the number of times a shot integer is repeated.

Type: list[ShotTuple[int, int]]

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

state¶

version = '0.18.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

`access_state`([wires])	Check that the device has access to an internal state and return it if available.
`active_wires`(operators)	Returns the wires acted on by a set of operators.
`adjoint_jacobian`(tape[, starting_state, …])	Implements the adjoint method outlined in Jones and Gacon to differentiate an input tape.
`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.
`batch_execute`(circuits)	Execute a batch of quantum circuits on the device.
`capabilities`()	Get the capabilities of this device class.
`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.
`density_matrix`(wires)	Returns the reduced density matrix of a given set of wires.
`estimate_probability`([wires, shot_range, …])	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.
`execute_and_gradients`(circuits[, method])	Execute a batch of quantum circuits on the device, and return both the results and the gradients.
`execution_context`()	The device execution context used during calls to `execute()`.
`expval`(observable[, shot_range, bin_size])	Returns the expectation value of a Hamiltonian observable. When the observable is a
`generate_basis_states`(num_wires[, dtype])	Generates basis states in binary representation according to the number of wires specified.
`generate_samples`()	Returns the computational basis samples generated for all wires.
`gradients`(circuits[, method])	Return the gradients of a batch of quantum circuits on the device.
`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, shot_range, bin_size])	Return either the analytic probability or estimated probability of each computational basis state.
`reset`()	Reset the device
`sample`(observable[, shot_range, bin_size])	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[, dtype])	Convert basis states from base 10 to binary representation.
`statistics`(observables[, shot_range, bin_size])	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[, shot_range, bin_size])	Returns the variance of observable on specified wires.

access_state(wires=None)¶

Check that the device has access to an internal state and return it if available.

Parameters: wires (Wires) – wires of the reduced system
Raises: QuantumFunctionError – if the device is not capable of returning the state
Returns: the state or the density matrix of the device
Return type: array or tensor

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

adjoint_jacobian(tape, starting_state=None, use_device_state=False)¶

Implements the adjoint method outlined in Jones and Gacon to differentiate an input tape.

After a forward pass, the circuit is reversed by iteratively applying inverse (adjoint) gates to scan backwards through the circuit. This method is similar to the reversible method, but has a lower time overhead and a similar memory overhead.

Note

The adjoint differentiation method has the following restrictions:

As it requires knowledge of the statevector, only statevector simulator devices can be used.
Only expectation values are supported as measurements.
Does not work for Hamiltonian observables.

Parameters

tape (QuantumTape) – circuit that the function takes the gradient of

Keyword Arguments

starting_state (tensor_like) – post-forward pass state to start execution with. It should be complex-valued. Takes precedence over use_device_state.
use_device_state (bool) – use current device state to initialize. A forward pass of the same circuit should be the last thing the device has executed. If a starting_state is provided, that takes precedence.

Returns

the derivative of the tape with respect to trainable parameters. Dimensions are (len(observables), len(trainable_params)).

Return type

array

Raises

QuantumFunctionError – if the input tape has measurements that are not expectation values or contains a multi-parameter operation aside from Rot

analytic_probability(wires=None)[source]¶

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: array[float]

apply(operations, rotations=None, **kwargs)[source]¶

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

batch_execute(circuits)¶

Execute a batch of quantum circuits on the device.

The circuits are represented by tapes, and they are executed one-by-one using the device’s execute method. The results are collected in a list.

For plugin developers: This function should be overwritten if the device can efficiently run multiple circuits on a backend, for example using parallel and/or asynchronous executions.

Parameters: circuits (list[tapes.QuantumTape]) – circuits to execute on the device
Returns: list of measured value(s)
Return type: list[array[float]]

classmethod capabilities()[source]¶

Get the capabilities of this device class.

Inheriting classes that change or add capabilities must override this method, for example via

@classmethod
def capabilities(cls):
    capabilities = super().capabilities().copy()
    capabilities.update(
        supports_inverse_operations=False,
        supports_a_new_capability=True,
    )
    return capabilities

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)[source]¶

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]>)])

density_matrix(wires)[source]¶

Returns the reduced density matrix of a given set of wires.

Parameters: wires (Wires) – wires of the reduced system.
Returns: complex tensor of shape (2 ** len(wires), 2 ** len(wires)) representing the reduced density matrix.
Return type: array[complex]

estimate_probability(wires=None, shot_range=None, bin_size=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.
shot_range (tuple[int]) – 2-tuple of integers specifying the range of samples to use. If not specified, all samples are used.
bin_size (int) – Divides the shot range into bins of size bin_size, and returns the measurement statistic separately over each bin. If not provided, the entire shot range is treated as a single bin.

Returns

list of the probabilities

Return type

array[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]

execute_and_gradients(circuits, method='jacobian', **kwargs)¶

Execute a batch of quantum circuits on the device, and return both the results and the gradients.

The circuits are represented by tapes, and they are executed one-by-one using the device’s execute method. The results and the corresponding Jacobians are collected in a list.

For plugin developers: This method should be overwritten if the device can efficiently run multiple circuits on a backend, for example using parallel and/or asynchronous executions, and return both the results and the Jacobians.

Parameters

circuits (list[tape.QuantumTape]) – circuits to execute on the device
method (str) – the device method to call to compute the Jacobian of a single circuit
**kwargs – keyword argument to pass when calling method

Returns

Tuple containing list of measured value(s) and list of Jacobians. Returned Jacobians should be of shape (output_shape, num_params).

Return type

tuple[list[array[float]], list[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, shot_range=None, bin_size=None)[source]¶

Returns the expectation value of a Hamiltonian observable. When the observable is a: SparseHamiltonian object, the expectation value is computed directly for the full Hamiltonian, which leads to faster execution.

Parameters

observable (Observable) – a PennyLane observable
shot_range (tuple[int]) – 2-tuple of integers specifying the range of samples to use. If not specified, all samples are used.
bin_size (int) – Divides the shot range into bins of size bin_size, and returns the measurement statistic separately over each bin. If not provided, the entire shot range is treated as a single bin.

Returns

returns the expectation value of the observable

Return type

float

static generate_basis_states(num_wires, dtype=<class 'numpy.uint32'>)¶

Generates basis states in binary representation according to the number of wires specified.

The states_to_binary method creates basis states faster (for larger systems at times over x25 times faster) than the approach using itertools.product, at the expense of using slightly more memory.

Due to the large size of the integer arrays for more than 32 bits, memory allocation errors may arise in the states_to_binary method. Hence we constraint the dtype of the array to represent unsigned integers on 32 bits. Due to this constraint, an overflow occurs for 32 or more wires, therefore this approach is used only for fewer wires.

For smaller number of wires speed is comparable to the next approach (using itertools.product), hence we resort to that one for testing purposes.

Parameters

num_wires (int) – the number wires
dtype=np.uint32 (type) – the data type of the arrays to use

Returns

the sampled basis states

Return type

array[int]

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]

gradients(circuits, method='jacobian', **kwargs)¶

Return the gradients of a batch of quantum circuits on the device.

The gradient method method is called sequentially for each circuit, and the corresponding Jacobians are collected in a list.

For plugin developers: This method should be overwritten if the device can efficiently compute the gradient of multiple circuits on a backend, for example using parallel and/or asynchronous executions.

Parameters

circuits (list[tape.QuantumTape]) – circuits to execute on the device
method (str) – the device method to call to compute the Jacobian of a single circuit
**kwargs – keyword argument to pass when calling method

Returns

List of Jacobians. Returned Jacobians should be of shape (output_shape, num_params).

Return type

list[array[float]]

map_wires(wires)[source]¶

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, shot_range=None, bin_size=None)¶

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

Devices that require a finite number of shots always 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: array[float]

reset()[source]¶: Reset the device

sample(observable, shot_range=None, bin_size=None)¶

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
state_probability (array[float]) – the computational basis probability vector

Returns

the sampled basis states

Return type

array[int]

static states_to_binary(samples, num_wires, dtype=<class 'numpy.int64'>)¶

Convert basis states from base 10 to binary representation.

This is an auxiliary method to the generate_samples method.

Parameters

samples (array[int]) – samples of basis states in base 10 representation
num_wires (int) – the number of qubits
dtype (type) – Type of the internal integer array to be used. Can be important to specify for large systems for memory allocation purposes.

Returns

basis states in binary representation

Return type

array[int]

statistics(observables, shot_range=None, bin_size=None)¶

Process measurement results from circuit execution and return statistics.

This includes returning expectation values, variance, samples, probabilities, states, and density matrices.

Parameters

observables (List[Observable]) – the observables to be measured
shot_range (tuple[int]) – 2-tuple of integers specifying the range of samples to use. If not specified, all samples are used.
bin_size (int) – Divides the shot range into bins of size bin_size, and returns the measurement statistic separately over each bin. If not provided, the entire shot range is treated as a single bin.

Raises

QuantumFunctionError – if the value of return_type is not supported

Returns

the corresponding statistics

Return type

Union[float, List[float]]

Usage Details

The shot_range and bin_size arguments allow for the statistics to be performed on only a subset of device samples. This finer level of control is accessible from the main UI by instantiating a device with a batch of shots.

For example, consider the following device:

>>> dev = qml.device("my_device", shots=[5, (10, 3), 100])

This device will execute QNodes using 135 shots, however measurement statistics will be course grained across these 135 shots:

All measurement statistics will first be computed using the first 5 shots — that is, shots_range=[0, 5], bin_size=5.
Next, the tuple (10, 3) indicates 10 shots, repeated 3 times. We will want to use shot_range=[5, 35], performing the expectation value in bins of size 10 (bin_size=10).
Finally, we repeat the measurement statistics for the final 100 shots, shot_range=[35, 135], bin_size=100.

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, shot_range=None, bin_size=None)¶

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

qml.devices.default_qubit.DefaultQubit¶

Attributes

Methods

Usage Details

Contents

Downloads