Using PennyLane

Release news

Development

API

Internals

  1. Docs
  2. qml.labs
  3. qml.labs.resource_estimation
  4. qml.labs.resource_estimation.ResourceQROM

qml.labs.resource_estimation.ResourceQROM

class ResourceQROM(num_bitstrings, size_bitstring, num_bit_flips=None, clean=True, select_swap_depth=None, wires=None)[source]

Bases: ResourceOperator

Resource class for the QROM template.

Parameters:

  • num_bitstrings (int) – the number of bitstrings that are to be encoded

  • size_bitstring (int) – the length of each bitstring

  • num_bit_flips (int, optional) – The total number of \(1\)’s in the dataset. Defaults to (num_bitstrings * size_bitstring) // 2, which is half the dataset.

  • clean (bool, optional) – Determine if allocated qubits should be reset after the computation (at the cost of higher gate counts). Defaults to :code`True`.

  • select_swap_depth (Union[int, None], optional) – A parameter \(\lambda\) that determines if data will be loaded in parallel by adding more rows following Figure 1.C of Low et al. (2024). Can be None, 1 or a positive integer power of two. Defaults to None, which internally determines the optimal depth.

  • wires (Sequence[int], optional) – The wires the operation acts on (control and target). Excluding any additional qubits allocated during the decomposition (e.g select-swap wires).

Resources:

The resources for QROM are taken from the following two papers: Low et al. (2024) (Figure 1.C) for clean = False and Berry et al. (2019) (Figure 4) for clean = True.

See also

QROM

Example

The resources for this operation are computed using:

>>> qrom = plre.ResourceQROM(
...     num_bitstrings=10,
...     size_bitstring=4,
... )
>>> print(plre.estimate(qrom))
--- Resources: ---
Total qubits: 11
Total gates : 178
Qubit breakdown:
 clean qubits: 3, dirty qubits: 0, algorithmic qubits: 8
Gate breakdown:
 {'Hadamard': 56, 'X': 34, 'CNOT': 72, 'Toffoli': 16}

num_wires

resource_keys

resource_params

Returns a dictionary containing the minimal information needed to compute the resources.
num_wires = 1
resource_keys = {'clean', 'num_bit_flips', 'num_bitstrings', 'select_swap_depth', 'size_bitstring'}
resource_params

Returns a dictionary containing the minimal information needed to compute the resources.

Returns:

A dictionary containing the resource parameters:

  • num_bitstrings (int): the number of bitstrings that are to be encoded

  • size_bitstring (int): the length of each bitstring

  • num_bit_flips (int, optional): The total number of \(1\)’s in the dataset. Defaults to (num_bitstrings * size_bitstring) // 2, which is half the dataset.

  • clean (bool, optional): Determine if allocated qubits should be reset after the computation (at the cost of higher gate counts). Defaults to :code`True`.

  • select_swap_depth (Union[int, None], optional): A parameter \(\lambda\) that determines if data will be loaded in parallel by adding more rows following Figure 1.C of Low et al. (2024). Can be None, 1 or a positive integer power of two. Defaults to None, which internally determines the optimal depth.

Return type:

dict

adjoint_resource_decomp(*args, **kwargs)

Returns a list representing the resources for the adjoint of the operator.

controlled_resource_decomp(...[, ...])

Returns a list representing the resources for a controlled version of the operator.

dequeue(op_to_remove[, context])

Remove the given resource operator(s) from the Operator queue.

pow_resource_decomp(pow_z, *args, **kwargs)

Returns a list representing the resources for an operator raised to a power.

queue([context])

Append the operator to the Operator queue.

resource_decomp(num_bitstrings, ...[, ...])

Returns a list of GateCount objects representing the operator's resources.

resource_rep(num_bitstrings, size_bitstring)

Returns a compressed representation containing only the parameters of the Operator that are needed to compute a resource estimation.

resource_rep_from_op()

Returns a compressed representation directly from the operator

single_controlled_res_decomp(num_bitstrings, ...)

The resource decomposition for QROM controlled on a single wire.

tracking_name(*args, **kwargs)

Returns a name used to track the operator during resource estimation.

tracking_name_from_op()

Returns the tracking name built with the operator's parameters.
classmethod adjoint_resource_decomp(*args, **kwargs)

Returns a list representing the resources for the adjoint of the operator.

classmethod controlled_resource_decomp(ctrl_num_ctrl_wires, ctrl_num_ctrl_values, num_bitstrings, size_bitstring, num_bit_flips=None, select_swap_depth=None, clean=True, **kwargs)[source]

Returns a list representing the resources for a controlled version of the operator.

Parameters:

  • ctrl_num_ctrl_wires (int) – the number of qubits the operation is controlled on

  • ctrl_num_ctrl_values (int) – the number of control qubits, that are controlled when in the \(|0\rangle\) state

  • num_bitstrings (int) – the number of bitstrings that are to be encoded

  • size_bitstring (int) – the length of each bitstring

  • num_bit_flips (int, optional) – The total number of \(1\)’s in the dataset. Defaults to (num_bitstrings * size_bitstring) // 2, which is half the dataset.

  • clean (bool, optional) – Determine if allocated qubits should be reset after the computation (at the cost of higher gate counts). Defaults to :code`True`.

  • select_swap_depth (Union[int, None], optional) –

    A parameter \(\lambda\) that determines if data will be loaded in parallel by adding more rows following Figure 1.C of Low et al. (2024). Can be None, 1 or a positive integer power of two. Defaults to None, which internally determines the optimal depth.

Resources:

The resources for QROM are taken from the following two papers: Low et al. (2024) (Figure 1.C) for clean = False and Berry et al. (2019) (Figure 4) for clean = True.

Note: we use the single-controlled unary iterator trick to implement the Select. This implementation assumes we have access to \(n - 1\) additional work qubits, where \(n = \ceil{log_{2}(N)}\) and \(N\) is the number of batches of unitaries to select.

Returns:

A list of GateCount objects, where each object represents a specific quantum gate and the number of times it appears in the decomposition.

Return type:

list[GateCount]

static dequeue(op_to_remove, context=<class 'pennylane.queuing.QueuingManager'>)

Remove the given resource operator(s) from the Operator queue.

classmethod pow_resource_decomp(pow_z, *args, **kwargs)

Returns a list representing the resources for an operator raised to a power.

Parameters:

pow_z (int) – exponent that the operator is being raised to

queue(context=<class 'pennylane.queuing.QueuingManager'>)

Append the operator to the Operator queue.

classmethod resource_decomp(num_bitstrings, size_bitstring, num_bit_flips, select_swap_depth=None, clean=True, **kwargs)[source]

Returns a list of GateCount objects representing the operator’s resources.

Parameters:

  • num_bitstrings (int) – the number of bitstrings that are to be encoded

  • size_bitstring (int) – the length of each bitstring

  • num_bit_flips (int, optional) – The total number of \(1\)’s in the dataset. Defaults to (num_bitstrings * size_bitstring) // 2, which is half the dataset.

  • clean (bool, optional) – Determine if allocated qubits should be reset after the computation (at the cost of higher gate counts). Defaults to :code`True`.

  • select_swap_depth (Union[int, None], optional) –

    A parameter \(\lambda\) that determines if data will be loaded in parallel by adding more rows following Figure 1.C of Low et al. (2024). Can be None, 1 or a positive integer power of two. Defaults to None, which internally determines the optimal depth.

  • wires (Sequence[int], optional) – the wires the operation acts on

Resources:

The resources for QROM are taken from the following two papers: Low et al. (2024) (Figure 1.C) for clean = False and Berry et al. (2019) (Figure 4) for clean = True.

Note: we use the unary iterator trick to implement the Select. This implementation assumes we have access to \(n - 1\) additional work qubits, where \(n = \left\lceil log_{2}(N) \right\rceil\) and \(N\) is the number of batches of unitaries to select.

classmethod resource_rep(num_bitstrings, size_bitstring, num_bit_flips=None, clean=True, select_swap_depth=None)[source]

Returns a compressed representation containing only the parameters of the Operator that are needed to compute a resource estimation.

Parameters:

  • num_bitstrings (int) – the number of bitstrings that are to be encoded

  • size_bitstring (int) – the length of each bitstring

  • num_bit_flips (int, optional) – The total number of \(1\)’s in the dataset. Defaults to (num_bitstrings * size_bitstring) // 2, which is half the dataset.

  • clean (bool, optional) – Determine if allocated qubits should be reset after the computation (at the cost of higher gate counts). Defaults to :code`True`.

  • select_swap_depth (Union[int, None], optional) –

    A parameter \(\lambda\) that determines if data will be loaded in parallel by adding more rows following Figure 1.C of Low et al. (2024). Can be None, 1 or a positive integer power of two. Defaults to None, which internally determines the optimal depth.

Returns:

the operator in a compressed representation

Return type:

CompressedResourceOp

resource_rep_from_op()

Returns a compressed representation directly from the operator

classmethod single_controlled_res_decomp(num_bitstrings, size_bitstring, num_bit_flips, select_swap_depth, clean)[source]

The resource decomposition for QROM controlled on a single wire.

classmethod tracking_name(*args, **kwargs)

Returns a name used to track the operator during resource estimation.

tracking_name_from_op()

Returns the tracking name built with the operator’s parameters.

Previous
Next