qml.devices.default_gaussian.DefaultGaussian¶
- class DefaultGaussian(wires, *, shots=None, hbar=2, analytic=None)[source]¶
Bases:
Device
Default Gaussian 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. If
None
, the results are analytically computed and hence deterministic.hbar (float) – (default 2) the value of \(\hbar\) in the commutation relation \([\x,\p]=i\hbar\)
Attributes
Whether shots is None or not.
Number of times this device is executed by the evaluation of QNodes running on this device
The observables to be measured and returned.
Get the supported set of observables.
The operation queue to be applied.
Get the supported set of operations.
Mapping from free parameter index to the list of
Operations
in the device queue that depend on it.Returns the shot vector, a sparse representation of the shot sequence used by the device when evaluating QNodes.
Number of circuit evaluations/random samples used to estimate expectation values of observables
Returns the stopping condition for the device.
Ordered dictionary that defines the map from user-provided wire labels to the wire labels used on this device
All wires that can be addressed on this device
- analytic¶
Whether shots is None or not. Kept for backwards compatability.
- author = 'Xanadu Inc.'¶
- name = 'Default Gaussian 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.Operator]
- observables¶
- 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¶
- 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.42.2'¶
- short_name = 'default.gaussian'¶
- 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.mixed", wires=2, shots=[3, 1, 2, 2, 2, 2, 6, 1, 1, 5, 12, 10, 10]) >>> dev.shots 57 >>> dev.shot_vector [ShotCopies(3 shots x 1), ShotCopies(1 shots x 1), ShotCopies(2 shots x 4), ShotCopies(6 shots x 1), ShotCopies(1 shots x 2), ShotCopies(5 shots x 1), ShotCopies(12 shots x 1), ShotCopies(10 shots x 2)]
The sparse representation of the shot sequence is returned, where tuples indicate the number of times a shot integer is repeated.
- Type:
list[ShotCopies]
- shots¶
Number of circuit evaluations/random samples used to estimate expectation values of observables
- stopping_condition¶
Returns the stopping condition for the device. The returned function accepts a queuable object (including a PennyLane operation and observable) and returns
True
if supported by the device.- Type:
.BooleanFn
- version = '0.42.2'¶
- 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
apply
(operation, wires, par)Apply a quantum operation.
batch_execute
(circuits)Execute a batch of quantum circuits on the device.
batch_transform
(circuit)Apply a differentiable batch transform for preprocessing a circuit prior to execution.
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.
custom_expand
(fn)Register a custom expansion function for the device.
default_expand_fn
(circuit[, max_expansion])Method for expanding or decomposing an input circuit.
define_wire_map
(wires)Create the map from user-provided wire labels to the wire labels used by the device.
execute
(operations, observables)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.
The device execution context used during calls to
execute()
.expand
(S, wires)Expands a Symplectic matrix S to act on the entire subsystem.
expand_fn
(circuit[, max_expansion])Method for expanding or decomposing an input circuit.
expval
(observable, wires, par)Returns the expectation value of observable on specified 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.
order_wires
(subset_wires)Given some subset of device wires return a Wires object with the same wires; sorted according to the device wire map.
Called during
execute()
after the individual operations have been executed.Called during
execute()
after the individual observables have been measured.Called during
execute()
before the individual operations are executed.Called during
execute()
before the individual observables are measured.probability
([wires])Return the (marginal) probability of each computational basis state from the last run of the device.
reduced_state
(wires)Returns the covariance matrix and the vector of means of the specified wires.
reset
()Reset the device
sample
(observable, wires, par)Return a sample of an observable.
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, wires, par)Returns the variance of observable on specified wires.
- apply(operation, wires, par)[source]¶
Apply a quantum operation.
For plugin developers: this function should apply the operation on the device.
- Parameters:
operation (str) – name of the operation
wires (Wires) – wires that the operation is applied to
par (tuple) – parameters for the operation
- batch_execute(circuits)[source]¶
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[.tape.QuantumTape]) – circuits to execute on the device
- Returns:
list of measured value(s)
- Return type:
list[array[float]]
- batch_transform(circuit)¶
Apply a differentiable batch transform for preprocessing a circuit prior to execution. This method is called directly by the QNode, and should be overwritten if the device requires a transform that generates multiple circuits prior to execution.
By default, this method contains logic for generating multiple circuits, one per term, of a circuit that terminates in
expval(H)
, if the underlying device does not support Hamiltonian expectation values, or if the device requires finite shots.Warning
This method will be tracked by autodifferentiation libraries, such as Autograd, JAX, TensorFlow, and Torch. Please make sure to use
qml.math
for autodiff-agnostic tensor processing if required.- Parameters:
circuit (.QuantumTape) – the circuit to preprocess
- Returns:
Returns a tuple containing the sequence of circuits to be executed, and a post-processing function to be applied to the list of evaluated circuit results.
- Return type:
tuple[Sequence[.QuantumTape], callable]
- 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_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.
- Parameters:
queue (Iterable[Operation]) – quantum operation objects which are intended to be applied on the device
observables (Iterable[Operator]) – 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
- custom_expand(fn)¶
Register a custom expansion function for the device.
Example
@dev.custom_expand def my_expansion_function(self, tape, max_expansion=10): ... # can optionally call the default device expansion tape = self.default_expand_fn(tape, max_expansion=max_expansion) return tape
The custom device expansion function must have arguments
self
(the device object),tape
(the input circuit to transform and execute), andmax_expansion
(the number of times the circuit should be expanded).The default
default_expand_fn()
method of the original device may be called. It is highly recommended to call this before returning, to ensure that the expanded circuit is supported on the device.
- default_expand_fn(circuit, max_expansion=10)¶
Method for expanding or decomposing an input circuit. This method should be overwritten if custom expansion logic is required.
By default, this method expands the tape if:
state preparation operations are called mid-circuit,
nested tapes are present,
any operations are not supported on the device, or
multiple observables are measured on the same wire.
- Parameters:
circuit (.QuantumTape) – the circuit to expand.
max_expansion (int) – The number of times the circuit should be expanded. Expansion occurs when an operation or measurement is not supported, and results in a gate decomposition. If any operations in the decomposition remain unsupported by the device, another expansion occurs.
- Returns:
The expanded/decomposed circuit, such that the device will natively support all operations.
- Return type:
.QuantumTape
- 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]))])
- execute(operations, observables)[source]¶
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
pre_apply()
,apply()
,post_apply()
,pre_measure()
,expval()
,var()
,sample()
,post_measure()
, andexecution_context()
.- Parameters:
queue (Iterable[Operation]) – operations to execute on the device
observables (Iterable[Operator]) – observables to measure and return
parameters (dict[int, list[ParameterDependency]]) – Mapping from free parameter index to the list of
Operations
(in the queue) that depend on it.
- Keyword Arguments:
return_native_type (bool) – If True, return the result in whatever type the device uses internally, otherwise convert it into array[float]. Default: False.
- Raises:
QuantumFunctionError – if the observable 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()
andexpval()
) are then evaluated within the context of this context manager (see the source ofexecute()
for more details).
- expand(S, wires)[source]¶
Expands a Symplectic matrix S to act on the entire subsystem.
- Parameters:
S (array) – a \(2M\times 2M\) Symplectic matrix
wires (Wires) – wires of the modes that S acts on
- Returns:
the resulting \(2N\times 2N\) Symplectic matrix
- Return type:
array
- expand_fn(circuit, max_expansion=10)¶
Method for expanding or decomposing an input circuit. Can be the default or a custom expansion method, see
Device.default_expand_fn()
andDevice.custom_expand()
for more details.- Parameters:
circuit (.QuantumTape) – the circuit to expand.
max_expansion (int) – The number of times the circuit should be expanded. Expansion occurs when an operation or measurement is not supported, and results in a gate decomposition. If any operations in the decomposition remain unsupported by the device, another expansion occurs.
- Returns:
The expanded/decomposed circuit, such that the device will natively support all operations.
- Return type:
.QuantumTape
- expval(observable, wires, par)[source]¶
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
- 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)¶
Map the wire labels of wires using this device’s wire map.
- order_wires(subset_wires)¶
Given some subset of device wires return a Wires object with the same wires; sorted according to the device wire map.
- probability(wires=None)¶
Return the (marginal) probability of each computational basis state from the last run of the device.
- Parameters:
wires (Sequence[int]) – Sequence of wires to return marginal probabilities for. Wires not provided are traced out of the system.
- Returns:
Dictionary mapping a tuple representing the state to the resulting probability. The dictionary should be sorted such that the state tuples are in lexicographical order.
- Return type:
OrderedDict[tuple, float]
- reduced_state(wires)[source]¶
Returns the covariance matrix and the vector of means of the specified wires.
- Parameters:
wires (Wires) – requested wires
- Returns:
cov is a square array containing the covariance matrix, and means is an array containing the vector of means
- Return type:
tuple (cov, means)
- sample(observable, wires, par)[source]¶
Return a sample of an observable.
Note
The
default.gaussian
plugin only supports sampling fromX
,P
, andQuadOperator
observables.- Parameters:
observable (str) – name of the observable
wires (Wires) – wires the observable is to be measured on
par (tuple) – parameters for the observable
- Returns:
samples in an array of dimension
(n, num_wires)
- Return type:
array[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
Operator
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
if supplied operation is supported- Return type:
bool
- var(observable, wires, par)[source]¶
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