qml.devices.DefaultTensor¶

class DefaultTensor(wires=None, method='mps', c_dtype=<class 'numpy.complex128'>, **kwargs)[source]¶

Bases: pennylane.devices.device_api.Device

A PennyLane device to perform tensor network simulations of quantum circuits using quimb.

This device is designed to simulate large-scale quantum circuits using tensor networks. For small circuits, other devices like default.qubit may be more suitable.

The backend uses the quimb library to perform the tensor network operations, and different methods can be used to simulate the quantum circuit. The supported methods are Matrix Product State (MPS) and Tensor Network (TN).

This device does not currently support finite-shots or differentiation. At present, the supported measurement types are expectation values, variances and state measurements. Finally, UserWarnings from the cotengra package may appear when using this device.

Parameters

wires (int, Iterable[Number, str]) – Number of wires present on the device, or iterable that contains unique labels for the wires as numbers (e.g., [-1, 0, 2]) or strings (e.g., ['aux_wire', 'q1', 'q2']).
method (str) – Supported method. The supported methods are "mps" (Matrix Product State) and "tn" (Tensor Network).
c_dtype (type) – Complex data type for the tensor representation. Must be one of numpy.complex64 or numpy.complex128.
**kwargs – Keyword arguments for the device, passed to the quimb backend.

Keyword Arguments

max_bond_dim (int) – Maximum bond dimension for the MPS method. It corresponds to the maximum number of Schmidt coefficients (singular values) retained at the end of the SVD algorithm when applying gates. Default is None (i.e. unlimited).
cutoff (float) – Truncation threshold for the Schmidt coefficients in the MPS method. Default is None (which is equivalent to retaining all coefficients).
contract (str) – The contraction method for applying gates. The possible options depend on the method chosen. For the MPS method, the options are "auto-mps", "swap+split" and "nonlocal". For a description of these options, see the quimb’s CircuitMPS documentation. Default is "auto-mps". For the TN method, the options are "auto-split-gate", "split-gate", "reduce-split", "swap-split-gate", "split", True, and False. For details, see the quimb’s tensor_core documentation. Default is "auto-split-gate".
contraction_optimizer (str) – The contraction path optimizer to use for the computation of local expectation values. For more information on the optimizer options accepted by quimb, see the quimb’s tensor_contract documentation. Default is "auto-hq".
local_simplify (str) – The simplification sequence to apply to the tensor network for computing local expectation values. At present, this argument can only be provided when the TN method is used. For a complete list of available simplification options, see the quimb’s full_simplify documentation. Default is "ADCRS".

Example:

The following code shows how to create a simple short-depth quantum circuit with 100 qubits using the default.tensor device. Depending on the machine, the execution time for this circuit is around 0.3 seconds:

import pennylane as qml

num_qubits = 100

dev = qml.device("default.tensor", wires=num_qubits)

@qml.qnode(dev)
def circuit(num_qubits):
    for qubit in range(0, num_qubits - 1):
        qml.CZ(wires=[qubit, qubit + 1])
        qml.X(wires=[qubit])
        qml.Z(wires=[qubit + 1])
    return qml.expval(qml.Z(0))

>>> circuit(num_qubits)
tensor(-1., requires_grad=True)

We can provide additional keyword arguments to the device to customize the simulation. These are passed to the quimb backend.

Note

Be aware that quimb uses multi-threading with numba as well as for linear algebra operations with numpy.linalg. Proper setting of the corresponding environment variables (e.g. OMP_NUM_THREADS, OPENBLAS_NUM_THREADS, NUMBA_NUM_THREADS etc.) depending on your hardware is highly recommended and will have a strong impact on the device’s performance.

To avoid a slowdown in performance for circuits with more than 10 wires, we recommend setting the environment variable relevant for your BLAS library backend (e.g. OMP_NUM_THREADS=1, OPENBLAS_NUM_THREADS=1 or MKL_NUM_THREADS=1), depending on your NumPy package and associated libraries. Alternatively, you can use threadpoolctl to limit the threads within your executing script. For optimal performance you can adjust the number of threads to find the best fit for your workload.

Usage with MPS Method

In the following example, we consider a slightly more complex circuit. We use the default.tensor device with the MPS method, setting the maximum bond dimension to 100 and the cutoff to the machine epsilon.

We set "auto-mps" as the contraction technique to apply gates. With this option, quimb turns 3-qubit gates and 4-qubit gates into Matrix Product Operators (MPO) and applies them directly to the MPS. On the other hand, qubits involved in 2-qubit gates may be temporarily swapped to adjacent positions before applying the gate and then returned to their original positions.

import pennylane as qml
import numpy as np

theta = 0.5
phi = 0.1
num_qubits = 50
device_kwargs_mps = {
    "max_bond_dim": 100,
    "cutoff": np.finfo(np.complex128).eps,
    "contract": "auto-mps",
}

dev = qml.device("default.tensor", wires=num_qubits, method="mps", **device_kwargs_mps)

@qml.qnode(dev)
def circuit(theta, phi, num_qubits):
    for qubit in range(num_qubits - 4):
        qml.X(wires=qubit)
        qml.RX(theta, wires=qubit + 1)
        qml.CNOT(wires=[qubit, qubit + 1])
        qml.DoubleExcitation(phi, wires=[qubit, qubit + 1, qubit + 3, qubit + 4])
        qml.CSWAP(wires=[qubit + 1, qubit + 3, qubit + 4])
        qml.RY(theta, wires=qubit + 1)
        qml.Toffoli(wires=[qubit + 1, qubit + 3, qubit + 4])
    return [
        qml.expval(qml.Z(0)),
        qml.expval(qml.Hamiltonian([np.pi, np.e], [qml.Z(15) @ qml.Y(25), qml.Hadamard(40)])),
        qml.var(qml.Y(20)),
    ]

>>> circuit(theta, phi, num_qubits)
[-0.9953099539219951, 0.0036631029671767208, 0.9999999876072984]

After the first execution, the time to run this circuit for 50 qubits is around 0.5 seconds on a standard laptop. Increasing the number of qubits to 500 brings the execution time to approximately 15 seconds, and for 1000 qubits to around 50 seconds.

The time complexity and the accuracy of the results also depend on the chosen keyword arguments for the device, such as the maximum bond dimension. The specific structure of the circuit significantly affects how the time complexity and accuracy of the simulation scale with these parameters.

Usage with TN Method

We can also simulate quantum circuits using the Tensor Network (TN) method. This can be particularly useful for circuits that build up entanglement. The following example shows how to execute a quantum circuit with the TN method and configurable depth using default.tensor.

We set the contraction technique to "auto-split-gate". With this option, each gate is lazily added to the tensor network and nothing is initially contracted, but the gate is automatically split if this results in a rank reduction.

import pennylane as qml

phi = 0.1
depth = 10
num_qubits = 100

dev = qml.device("default.tensor", method="tn", contract="auto-split-gate")

@qml.qnode(dev)
def circuit(phi, depth, num_qubits):
    for qubit in range(num_qubits):
        qml.X(wires=qubit)
    for _ in range(depth):
        for qubit in range(num_qubits - 1):
            qml.CNOT(wires=[qubit, qubit + 1])
        for qubit in range(num_qubits):
            qml.RX(phi, wires=qubit)
    for qubit in range(num_qubits - 1):
        qml.CNOT(wires=[qubit, qubit + 1])
    return qml.expval(qml.Z(0))

>>> circuit(phi, depth, num_qubits)
-0.9511499466743283

The execution time for this circuit with the above parameters is around 0.8 seconds on a standard laptop.

The tensor network method can be faster than MPS and state vector methods in some cases. As a comparison, the time for the exact calculation (i.e., with max_bond_dim = None) of the same circuit using the MPS method of the default.tensor device is approximately three orders of magnitude slower. Similarly, using the default.qubit device results in a much slower simulation.

Attributes

`c_dtype`	Tensor complex data type.
`capabilities`	A `DeviceCapabilities` object describing the capabilities of the backend device.
`config_filepath`	A device can use a toml file to specify the capabilities of the backend device.
`method`	Method used by the device.
`name`	The name of the device.
`shots`	Default shots for execution workflows containing this device.
`tracker`	A `Tracker` that can store information about device executions, shots, batches, intermediate results, or any additional device dependent information.
`wires`	The device wires.

c_dtype¶: Tensor complex data type.

capabilities = None¶: A DeviceCapabilities object describing the capabilities of the backend device.

config_filepath = None¶: A device can use a toml file to specify the capabilities of the backend device. If this is provided, the file will be loaded into a DeviceCapabilities object assigned to the capabilities attribute.

method¶: Method used by the device.

name¶: The name of the device.

shots¶

Default shots for execution workflows containing this device.

Note that the device itself should always pull shots from the provided QuantumTape and its shots, not from this property. This property is used to provide a default at the start of a workflow.

tracker = <pennylane.tracker.Tracker object>¶

A Tracker that can store information about device executions, shots, batches, intermediate results, or any additional device dependent information.

A plugin developer can store information in the tracker by:

# querying if the tracker is active
if self.tracker.active:

    # store any keyword: value pairs of information
    self.tracker.update(executions=1, shots=self._shots, results=results)

    # Calling a user-provided callback function
    self.tracker.record()

wires¶

The device wires.

Note that wires are optional, and the default value of None means any wires can be used. If a device has wires defined, they will only be used for certain features. This includes:

Validation of tapes being executed on the device
Defining the wires used when evaluating a state() measurement

Methods

`compute_derivatives`(circuits[, execution_config])	Calculate the Jacobian of either a single or a batch of circuits on the device.
`compute_jvp`(circuits, tangents[, ...])	The jacobian vector product used in forward mode calculation of derivatives.
`compute_vjp`(circuits, cotangents[, ...])	The vector-Jacobian product used in reverse-mode differentiation.
`draw`([color])	Draw the current state (wavefunction) associated with the circuit using `quimb`'s functionality.
`eval_jaxpr`(jaxpr, consts, *args)	An experimental method for natively evaluating PLXPR.
`execute`(circuits[, execution_config])	Execute a circuit or a batch of circuits and turn it into results.
`execute_and_compute_derivatives`(circuits[, ...])	Compute the results and Jacobians of circuits at the same time.
`execute_and_compute_jvp`(circuits, tangents)	Execute a batch of circuits and compute their jacobian vector products.
`execute_and_compute_vjp`(circuits, cotangents)	Calculate both the results and the vector-Jacobian product used in reverse-mode differentiation.
`expval`(measurementprocess)	Expectation value of the supplied observable contained in the MeasurementProcess.
`measurement`(measurementprocess)	Measure the measurement required by the circuit.
`preprocess`([execution_config])	This function defines the device transform program to be applied and an updated device configuration.
`preprocess_transforms`([execution_config])	Returns the transform program to preprocess a circuit for execution.
`setup_execution_config`([config, circuit])	Sets up an `ExecutionConfig` that configures the execution behaviour.
`simulate`(circuit)	Simulate a single quantum script.
`state`(measurementprocess)	Returns the state vector.
`supports_derivatives`([execution_config, circuit])	Check whether or not derivatives are available for a given configuration and circuit.
`supports_jvp`([execution_config, circuit])	Whether or not a given device defines a custom jacobian vector product.
`supports_vjp`([execution_config, circuit])	Whether or not this device defines a custom vector-Jacobian product.
`var`(measurementprocess)	Variance of the supplied observable contained in the MeasurementProcess.

compute_derivatives(circuits, execution_config=ExecutionConfig(grad_on_execution=None, use_device_gradient=None, use_device_jacobian_product=None, gradient_method=None, gradient_keyword_arguments={}, device_options={}, interface=<Interface.NUMPY: 'numpy'>, derivative_order=1, mcm_config=MCMConfig(mcm_method=None, postselect_mode=None)))[source]¶

Calculate the Jacobian of either a single or a batch of circuits on the device.

Parameters

circuits (Union[QuantumTape, Sequence[QuantumTape]]) – the circuits to calculate derivatives for.
execution_config (ExecutionConfig) – a data structure with all additional information required for execution.

Returns

The Jacobian for each trainable parameter.

Return type

Tuple

compute_jvp(circuits, tangents, execution_config=ExecutionConfig(grad_on_execution=None, use_device_gradient=None, use_device_jacobian_product=None, gradient_method=None, gradient_keyword_arguments={}, device_options={}, interface=<Interface.NUMPY: 'numpy'>, derivative_order=1, mcm_config=MCMConfig(mcm_method=None, postselect_mode=None)))¶

The jacobian vector product used in forward mode calculation of derivatives.

Parameters

circuits (Union[QuantumTape, Sequence[QuantumTape]]) – the circuit or batch of circuits
tangents (tensor-like) – Gradient vector for input parameters.
execution_config (ExecutionConfig) – a datastructure with all additional information required for execution

Returns

A numeric result of computing the jacobian vector product

Return type

Tuple

Definition of jvp:

If we have a function with jacobian:

\[\vec{y} = f(\vec{x}) \qquad J_{i,j} = \frac{\partial y_i}{\partial x_j}\]

The Jacobian vector product is the inner product with the derivatives of \(x\), yielding only the derivatives of the output \(y\):

\[\text{d}y_i = \Sigma_{j} J_{i,j} \text{d}x_j\]

Shape of tangents:

The tangents tuple should be the same length as circuit.get_parameters() and have a single number per parameter. If a number is zero, then the gradient with respect to that parameter does not need to be computed.

compute_vjp(circuits, cotangents, execution_config=ExecutionConfig(grad_on_execution=None, use_device_gradient=None, use_device_jacobian_product=None, gradient_method=None, gradient_keyword_arguments={}, device_options={}, interface=<Interface.NUMPY: 'numpy'>, derivative_order=1, mcm_config=MCMConfig(mcm_method=None, postselect_mode=None)))[source]¶

The vector-Jacobian product used in reverse-mode differentiation.

Parameters

circuits (Union[QuantumTape, Sequence[QuantumTape]]) – the circuit or batch of circuits.
cotangents (Tuple[Number, Tuple[Number]]) – Gradient-output vector. Must have shape matching the output shape of the corresponding circuit. If the circuit has a single output, cotangents may be a single number, not an iterable of numbers.
execution_config (ExecutionConfig) – a data structure with all additional information required for execution.

Returns

A numeric result of computing the vector-Jacobian product.

Return type

tensor-like

draw(color='auto', **kwargs)[source]¶

Draw the current state (wavefunction) associated with the circuit using quimb’s functionality.

Internally, it uses quimb’s draw method.

Parameters

color (str) – The color of the tensor network diagram. Default is "auto".
**kwargs – Additional keyword arguments for the quimb’s draw function. For more information, see the quimb’s draw documentation.

Example

Here is a minimal example of how to draw the current state of the circuit:

import pennylane as qml

dev = qml.device("default.tensor", method="mps", wires=15)

dev.draw()

We can also customize the appearance of the tensor network diagram by passing additional keyword arguments:

dev = qml.device("default.tensor", method="tn", contract=False)

@qml.qnode(dev)
def circuit(num_qubits):
    for i in range(num_qubits):
        qml.Hadamard(wires=i)
    for _ in range(1, num_qubits - 1):
        for i in range(0, num_qubits, 2):
            qml.CNOT(wires=[i, i + 1])
        for i in range(10):
            qml.RZ(1.234, wires=i)
        for i in range(1, num_qubits - 1, 2):
            qml.CZ(wires=[i, i + 1])
        for i in range(num_qubits):
            qml.RX(1.234, wires=i)
    for i in range(num_qubits):
        qml.Hadamard(wires=i)
    return qml.expval(qml.Z(0))

num_qubits = 12

result = circuit(num_qubits)

dev.draw(color="auto", show_inds=True)

eval_jaxpr(jaxpr, consts, *args)¶

An experimental method for natively evaluating PLXPR. See the capture module for more details.

Parameters

jaxpr (jax.core.Jaxpr) – Pennylane variant jaxpr containing quantum operations and measurements
consts (list[TensorLike]) – the closure variables consts corresponding to the jaxpr
*args (TensorLike) – the variables to use with the jaxpr’.

Returns

the result of evaluating the jaxpr with the given parameters.

Return type

list[TensorLike]

execute(circuits, execution_config=ExecutionConfig(grad_on_execution=None, use_device_gradient=None, use_device_jacobian_product=None, gradient_method=None, gradient_keyword_arguments={}, device_options={}, interface=<Interface.NUMPY: 'numpy'>, derivative_order=1, mcm_config=MCMConfig(mcm_method=None, postselect_mode=None)))[source]¶

Execute a circuit or a batch of circuits and turn it into results.

Parameters

circuits (Union[QuantumTape, Sequence[QuantumTape]]) – the quantum circuits to be executed.
execution_config (ExecutionConfig) – a data structure with additional information required for execution.

Returns

A numeric result of the computation.

Return type

TensorLike, tuple[TensorLike], tuple[tuple[TensorLike]]

execute_and_compute_derivatives(circuits, execution_config=ExecutionConfig(grad_on_execution=None, use_device_gradient=None, use_device_jacobian_product=None, gradient_method=None, gradient_keyword_arguments={}, device_options={}, interface=<Interface.NUMPY: 'numpy'>, derivative_order=1, mcm_config=MCMConfig(mcm_method=None, postselect_mode=None)))[source]¶

Compute the results and Jacobians of circuits at the same time.

Parameters

circuits (Union[QuantumTape, Sequence[QuantumTape]]) – the circuits or batch of circuits.
execution_config (ExecutionConfig) – a data structure with all additional information required for execution.

Returns

A numeric result of the computation and the gradient.

Return type

tuple

execute_and_compute_jvp(circuits, tangents, execution_config=ExecutionConfig(grad_on_execution=None, use_device_gradient=None, use_device_jacobian_product=None, gradient_method=None, gradient_keyword_arguments={}, device_options={}, interface=<Interface.NUMPY: 'numpy'>, derivative_order=1, mcm_config=MCMConfig(mcm_method=None, postselect_mode=None)))¶

Execute a batch of circuits and compute their jacobian vector products.

Parameters

circuits (Union[QuantumTape, Sequence[QuantumTape]]) – circuit or batch of circuits
tangents (tensor-like) – Gradient vector for input parameters.
execution_config (ExecutionConfig) – a datastructure with all additional information required for execution

Returns

A numeric result of execution and of computing the jacobian vector product

Return type

Tuple, Tuple

Post processing function and derivatives

Derivatives and Jacobian products will be bound to the machine learning library before the postprocessing function is called on the results. Therefore, the machine learning library will be responsible for combining and post-processing derivatives returned from the device.

from pennylane.interfaces.jax import execute as jax_boundary

def f(x):
    circuit = qml.tape.QuantumScript([qml.Rot(*x, wires=0)], [qml.expval(qml.Z(0))])
    config = ExecutionConfig(gradient_method="adjoint")
    config = dev.setup_execution_config(config)
    program = dev.preprocess_transforms(config)
    circuit_batch, postprocessing = program((circuit, ))

    def execute_fn(tapes):
        return dev.execute_and_compute_derivatives(tapes, config)

    results = jax_boundary(circuit_batch, dev, execute_fn, None, {})
    return postprocessing(results)

x = jax.numpy.array([1.0, 2.0, 3.0])
jax.grad(f)(x)

In the above code, the quantum derivatives are registered with jax in the jax_boundary function. Only then is the classical postprocessing called on the result object.

setup_execution_config(config=None, circuit=None)¶

Sets up an ExecutionConfig that configures the execution behaviour.

The execution config stores information on how the device should perform the execution, as well as how PennyLane should interact with the device. See ExecutionConfig for all available options and what they mean.

An ExecutionConfig is constructed from arguments passed to the QNode, and this method allows the device to update the config object based on device-specific requirements or preferences. See Execution Config for more details.

Parameters

config (ExecutionConfig) – The initial ExecutionConfig object that describes the parameters needed to configure the execution behaviour.
circuit (QuantumScript) – The quantum circuit to customize the execution config for.

Returns

The updated ExecutionConfig object

Return type

ExecutionConfig

simulate(circuit)[source]¶

Simulate a single quantum script. This function assumes that all operations provide matrices.

Parameters: circuit (QuantumScript) – The single circuit to simulate.
Returns: The results of the simulation.
Return type: Tuple[TensorLike]

state(measurementprocess)[source]¶: Returns the state vector.

supports_derivatives(execution_config=None, circuit=None)[source]¶

Check whether or not derivatives are available for a given configuration and circuit.

Parameters

execution_config (ExecutionConfig) – The configuration of the desired derivative calculation.
circuit (QuantumTape) – An optional circuit to check derivatives support for.

Returns

Whether or not a derivative can be calculated provided the given information.

Return type

Bool

supports_jvp(execution_config=None, circuit=None)¶

Whether or not a given device defines a custom jacobian vector product.

Parameters

execution_config (ExecutionConfig) – A description of the hyperparameters for the desired computation.
circuit (None, QuantumTape) – A specific circuit to check differentation for.

Default behaviour assumes this to be True if compute_jvp() is overridden.

supports_vjp(execution_config=None, circuit=None)[source]¶

Whether or not this device defines a custom vector-Jacobian product.

Parameters

execution_config (ExecutionConfig) – The configuration of the desired derivative calculation.
circuit (QuantumTape) – An optional circuit to check derivatives support for.

Returns

Whether or not a derivative can be calculated provided the given information.

Return type

Bool

var(measurementprocess)[source]¶

Variance of the supplied observable contained in the MeasurementProcess.

Parameters: measurementprocess (StateMeasurement) – measurement to apply.
Returns: Variance of the observable.

code/api/pennylane.devices.DefaultTensor

Download Python script

Download Notebook

View on GitHub

qml.devices.DefaultTensor¶

Usage with MPS Method

Usage with TN Method

Attributes

Methods

Post processing function and derivatives

Contents

Downloads

qml.devices.DefaultTensor¶

Usage with MPS Method

Usage with TN Method

Attributes

Methods

Post processing function and derivatives

Contents

Downloads

Related