BraketAwsQubitDevice¶
- class BraketAwsQubitDevice(wires: int | Iterable, device_arn: str, s3_destination_folder: S3DestinationFolder | None = None, *, shots: int | None | Shots = Shots.DEFAULT, poll_timeout_seconds: float = 432000, poll_interval_seconds: float = 1, aws_session: AwsSession | None = None, parallel: bool = False, max_parallel: int | None = None, max_connections: int = 100, max_retries: int = 3, **run_kwargs)[source]¶
Bases:
BraketQubitDevice
Amazon Braket AwsDevice qubit device for PennyLane.
- Parameters:
wires (int or 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']
).device_arn (str) – The ARN identifying the
AwsDevice
to be used to run circuits; The corresponding AwsDevice must support quantum circuits via OpenQASM. You can get device ARNs usingAwsDevice.get_devices
, from the Amazon Braket console or from the Amazon Braket Developer Guide.s3_destination_folder (AwsSession.S3DestinationFolder) – Name of the S3 bucket and folder, specified as a tuple.
poll_timeout_seconds (float) – Total time in seconds to wait for results before timing out.
poll_interval_seconds (float) – The polling interval for results in seconds.
shots (int, None or Shots.DEFAULT) – Number of circuit evaluations or random samples included, to estimate expectation values of observables. If set to Shots.DEFAULT, uses the default number of shots specified by the remote device. If
shots
is set to0
orNone
, the device runs in analytic mode (calculations will be exact). Analytic mode is not available on QPU and hence an error will be raised. Default: Shots.DEFAULTaws_session (Optional[AwsSession]) – An AwsSession object created to manage interactions with AWS services, to be supplied if extra control is desired. Default: None Default: False
max_parallel (int, optional) – Maximum number of tasks to run on AWS in parallel. Batch creation will fail if this value is greater than the maximum allowed concurrent tasks on the device. If unspecified, uses defaults defined in
AwsDevice
. Ignored ifparallel=False
.max_connections (int) – The maximum number of connections in the Boto3 connection pool. Also the maximum number of thread pool workers for the batch. Ignored if
parallel=False
.max_retries (int) – The maximum number of retries to use for batch execution. When executing tasks in parallel, failed tasks will be retried up to
max_retries
times. Ignored ifparallel=False
.verbatim (bool) – Whether to verbatim mode for the device. Note that verbatim mode only supports the native gate set of the device. Default False.
**run_kwargs – Variable length keyword arguments for
braket.devices.Device.run()
.
Attributes
Whether shots is None or not.
The last circuit run on this device.
The hash of the circuit upon the last execution.
Mapping used to override the logic of measurement processes.
Number of times this device is executed by the evaluation of QNodes running on this device
The observables to be measured and returned.
set() -> new empty set object set(iterable) -> new set object
The operation queue to be applied.
The set of names of PennyLane operations that the device supports.
Mapping from free parameter index to the list of
Operations
in the device queue that depend on it.Dictionary of constants set by the hardware (qubit resonant frequencies, inter-qubit connection graph, wires and anharmonicities).
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 state vector of the circuit prior to measurement.
Returns the stopping condition for the device.
The task corresponding to the last run circuit.
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 = 'Amazon Web Services'¶
- circuit¶
The last circuit run on this device.
- Type:
Circuit
- circuit_hash¶
The hash of the circuit upon the last execution.
This can be used by devices in
apply()
for parametric compilation.
- measurement_map = {}¶
Mapping used to override the logic of measurement processes. The dictionary maps a measurement class to a string containing the name of a device’s method that overrides the measurement process. The method defined by the device should have the following arguments:
measurement (MeasurementProcess): measurement to override
- 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.
- bin_size (int): Divides the shot range into bins of size
Note
When overriding the logic of a
MeasurementTransform
, the method defined by the device should only have a single argument:tape: quantum tape to transform
Example:
Let’s create a device that inherits from
DefaultQubitLegacy
and overrides the logic of the qml.sample measurement. To do so we will need to update themeasurement_map
dictionary:class NewDevice(DefaultQubitLegacy): def __init__(self, wires, shots): super().__init__(wires=wires, shots=shots) self.measurement_map[SampleMP] = "sample_measurement" def sample_measurement(self, measurement, shot_range=None, bin_size=None): return 2
>>> dev = NewDevice(wires=2, shots=1000) >>> @qml.qnode(dev) ... def circuit(): ... return qml.sample() >>> circuit() tensor(2, requires_grad=True)
- name = 'Braket AwsDevice for PennyLane'¶
- 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¶
- 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¶
The set of names of PennyLane operations that the device supports.
- Type:
frozenset[str]
- parallel¶
- 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.30.0'¶
- pulse_settings¶
Dictionary of constants set by the hardware (qubit resonant frequencies, inter-qubit connection graph, wires and anharmonicities).
Used to enable initializing hardware-consistent Hamiltonians by returning values that would need to be passed, i.e.:
>>> dev_remote = qml.device('braket.aws.qubit', >>> wires=8, >>> arn='arn:aws:braket:eu-west-2::device/qpu/oqc/Lucy') >>> pulse_settings = dev_remote.pulse_settings >>> H_int = qml.pulse.transmon_interaction(**pulse_settings, coupling=0.02)
By passing the
pulse_settings
from the remote device totransmon_interaction
, anH_int
Hamiltonian term is created using the constants specific to the hardware. This is relevant for simulating the hardware in PennyLane on thedefault.qubit
device.Note that the user must supply coupling coefficients, as these are not available from the hardware backend.
- short_name = 'braket.aws.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.legacy", 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
- 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.
- 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
- task¶
The task corresponding to the last run circuit.
- Type:
QuantumTask
- use_grouping¶
- version = '1.23.1.dev0'¶
- 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, ...])Instantiate Braket Circuit object.
batch_execute
(circuits, **run_kwargs)Execute a batch of quantum circuits on the device.
batch_transform
(circuit)Apply a differentiable batch transform for preprocessing a circuit prior to execution.
Add support for AG on sv1
check_validity
(queue, observables)Check validity of pulse operations before running the standard check_validity function
classical_shadow
(obs, circuit)Returns the measured bits and recipes in the classical shadow protocol.
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.
density_matrix
(wires)Returns the reduced density matrix over the given wires.
estimate_probability
([wires, shot_range, ...])Return the estimated probability of each computational basis state using the generated samples.
execute
(circuit[, compute_gradient])It executes a queue of quantum operations on the device and then measure the given observables.
execute_and_gradients
(circuits, **kwargs)Execute a list of circuits and calculate their gradients.
The device execution context used during calls to
execute()
.expand_fn
(circuit[, max_expansion])Method for expanding or decomposing an input circuit.
expval
(observable[, shot_range, bin_size])Returns the expectation value of observable on specified wires.
generate_basis_states
(num_wires[, dtype])Generates basis states in binary representation according to the number of wires specified.
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.
mutual_info
(wires0, wires1, log_base)Returns the mutual information prior to measurement:
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, shot_range, bin_size])Return either the analytic probability or estimated probability of each computational basis state.
reset
()Reset the backend state.
sample
(observable[, shot_range, bin_size, ...])Return samples of an observable.
sample_basis_states
(number_of_states, ...)Sample from the computational basis states based on the state probability.
shadow_expval
(obs, circuit)Compute expectation values using classical shadows in a differentiable manner.
shot_vec_statistics
(circuit)Process measurement results from circuit execution using a device with a shot vector and return statistics.
states_to_binary
(samples, num_wires[, dtype])Convert basis states from base 10 to binary representation.
statistics
(braket_result, observables)Processes measurement results from a Braket task result and returns 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.
vn_entropy
(wires, log_base)Returns the Von Neumann entropy prior to measurement.
- 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: QuantumTape, 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 adjoint gates to scan backwards through the circuit.
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 parametrized observables like
Hamiltonian
orHermitian
.
- 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 or tuple[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)¶
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: Sequence[Operation], rotations: Sequence[Operation] | None = None, use_unique_params: bool = False, *, trainable_indices: frozenset[int] | None = None, **run_kwargs) Circuit ¶
Instantiate Braket Circuit object.
- batch_execute(circuits, **run_kwargs)[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[QuantumTape]) – circuits to execute on the device
- Returns:
list of measured value(s)
- Return type:
list[array[float]]
- batch_transform(circuit: QuantumTape)¶
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]
- check_validity(queue, observables)[source]¶
Check validity of pulse operations before running the standard check_validity function
Checks whether the operations and observables in queue are all supported by the device. Runs the standard check_validity function for a PennyLane device, and an additional check to validate any pulse-operations in the form of a ParametrizedEvolution operation.
- 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
RuntimeError – if there are ParametrizedEvolution operations in the queue that are not supported because of invalid pulse parameters
- classical_shadow(obs, circuit)¶
Returns the measured bits and recipes in the classical shadow protocol.
The protocol is described in detail in the classical shadows paper. This measurement process returns the randomized Pauli measurements (the
recipes
) that are performed for each qubit and snapshot as an integer:0 for Pauli X,
1 for Pauli Y, and
2 for Pauli Z.
It also returns the measurement results (the
bits
); 0 if the 1 eigenvalue is sampled, and 1 if the -1 eigenvalue is sampled.The device shots are used to specify the number of snapshots. If
T
is the number of shots andn
is the number of qubits, then both the measured bits and the Pauli measurements have shape(T, n)
.This implementation is device-agnostic and works by executing single-shot tapes containing randomized Pauli observables. Devices should override this if they can offer cleaner or faster implementations.
See also
classical_shadow()
- Parameters:
obs (ClassicalShadowMP) – The classical shadow measurement process
circuit (QuantumTape) – The quantum tape that is being executed
- Returns:
A tensor with shape
(2, T, n)
, where the first row represents the measured bits and the second represents the recipes used.- Return type:
tensor_like[int]
- custom_expand(fn)¶
Register a custom expansion function for the device.
Example
dev = qml.device("default.qubit.legacy", wires=2) @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]>)])
- density_matrix(wires)¶
Returns the reduced density matrix over the given wires.
- Parameters:
wires (Wires) – wires of the reduced system
- Returns:
complex array of shape
(2 ** len(wires), 2 ** len(wires))
representing the reduced density matrix of the state prior to measurement.- 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: QuantumTape, compute_gradient=False, **run_kwargs) ndarray ¶
It executes 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
Additional keyword arguments may be passed to this method that can be utilised by
apply()
. An example would be passing theQNode
hash that can be used later for parametric compilation.- Parameters:
circuit (QuantumTape) – 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, **kwargs)[source]¶
Execute a list of circuits and calculate their gradients. Returns a list of circuit results and a list of gradients/jacobians, one of each for each circuit in circuits.
The gradient is returned as a list of floats, 1 float for every instance of a trainable parameter in a gate in the circuit. Functions like qml.grad or qml.jacobian then use that format to generate a per-parameter format.
- 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_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, shot_range=None, bin_size=None)¶
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
- 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)¶
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 passedwires=[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]
- mutual_info(wires0, wires1, log_base)¶
Returns the mutual information prior to measurement:
\[I(A, B) = S(\rho^A) + S(\rho^B) - S(\rho^{AB})\]where \(S\) is the von Neumann entropy.
- Parameters:
wires0 (Wires) – wires of the first subsystem
wires1 (Wires) – wires of the second subsystem
log_base (float) – base to use in the logarithm
- Returns:
the mutual information
- Return type:
float
- 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.
- Parameters:
subset_wires (Wires) – The subset of device wires (in any order).
- Raises:
ValueError – Could not find some or all subset wires subset_wires in device wires device_wires.
- Returns:
a new Wires object containing the re-ordered wires set
- Return type:
ordered_wires (Wires)
- 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()¶
Reset the backend state.
After the reset, the backend should be as if it was just constructed. Most importantly the quantum state is reset to its initial value.
- sample(observable, shot_range=None, bin_size=None, counts=False)¶
Return samples of an observable.
- Parameters:
observable (Observable) – the observable to sample
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.counts (bool) – whether counts (
True
) or raw samples (False
) should be returned
- Raises:
EigvalsUndefinedError – if no information is available about the eigenvalues of the observable
- Returns:
samples in an array of dimension
(shots,)
or counts- Return type:
Union[array[float], dict, list[dict]]
- 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]
- shadow_expval(obs, circuit)¶
Compute expectation values using classical shadows in a differentiable manner.
Please refer to
shadow_expval()
for detailed documentation.- Parameters:
obs (ClassicalShadowMP) – The classical shadow expectation value measurement process
circuit (QuantumTape) – The quantum tape that is being executed
- Returns:
expectation value estimate.
- Return type:
float
- shot_vec_statistics(circuit: QuantumTape)¶
Process measurement results from circuit execution using a device with a shot vector and return statistics.
This is an auxiliary method of execute and uses statistics.
When using shot vectors, measurement results for each item of the shot vector are contained in a tuple.
- Parameters:
circuit (QuantumTape) – circuit to execute on the device
- Raises:
QuantumFunctionError – if the value of
return_type
is not supported- Returns:
stastics for each shot item from the shot vector
- Return type:
tuple
- 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(braket_result: GateModelQuantumTaskResult, observables: Sequence[Observable]) list[float] ¶
Processes measurement results from a Braket task result and returns statistics.
- Parameters:
braket_result (GateModelQuantumTaskResult) – the Braket task result
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:
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
if 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
- vn_entropy(wires, log_base)¶
Returns the Von Neumann entropy prior to measurement.
\[S( \rho ) = -\text{Tr}( \rho \log ( \rho ))\]- Parameters:
wires (Wires) – Wires of the considered subsystem.
log_base (float) – Base for the logarithm, default is None the natural logarithm is used in this case.
- Returns:
returns the Von Neumann entropy
- Return type:
float