qp.labs.estimator_beta.templates.RegisterEquality

class RegisterEquality(register_size=None, wires=None)

Bases: ResourceOperator

Resource class for testing the equality of two quantum registers.

Compares two n-bit quantum registers \(|i\rangle\) and \(|j\rangle\), storing the result (\(i == j\)) in a dedicated output qubit.

The circuit computes the bitwise XOR of the two registers using CNOTs, then uses a TemporaryAND cascade to flag whether all XOR results are zero (i.e., the registers are equal).

Parameters:

• register_size (int) – Number of qubits n in each register.

• wires (WiresLike | None) – The wires the operation acts on.

Resources:

The circuit computes the bitwise XOR of the two registers using CNOTs, then checks whether all results are zero via a Toffoli cascade. The circuit is represented as:

0: ─╭●──────────┤
1: ─│──╭●───────┤
2: ─│──│──╭●────┤
3: ─╰X─│──│──╭○─┤
4: ────╰X─│──├○─┤
5: ───────╰X─├○─┤
6: ──────────╰X─┤  <Z>

Note that the state of the second register is not preserved after this operation and it needs to be uncomputed if it is needed later in the circuit.

Example

The resources for this operation are computed using:

>>> import pennylane.labs.estimator_beta as qre
>>> comparator = qre.RegisterEquality(register_size=3)
>>> print(qre.estimate(comparator))
--- Resources: ---
 Total wires: 8
   algorithmic wires: 7
   allocated wires: 1
     zero state: 1
     any state: 0
 Total gates : 12
   'Toffoli': 2,
   'CNOT': 4,
   'X': 3,
   'Hadamard': 3

Attributes

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

num_wires = None

resource_keys = {'register_size'}

resource_params

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

Returns:

A dictionary containing the resource parameters:

• register_size (int): size of the registers for basis state

Return type:

dict

Methods

add_parallel(other)	Adds a ResourceOperator or Resources in parallel.
add_series(other)	Adds a ResourceOperator or Resources in series.
adjoint_resource_decomp([target_resource_params])	Returns a list representing the resources for the adjoint of the operator.
controlled_resource_decomp(num_ctrl_wires, ...)	Returns a list representing the resources for a controlled version of the operator.
pow_resource_decomp(pow_z[, ...])	Returns a list representing the resources for an operator raised to a power.
queue([context])	Append the operator to the Operator queue.
resource_decomp(register_size)	Returns a list representing the resources of the operator.
resource_rep(register_size)	Returns a compressed representation containing only the parameters of the Operator that are needed to compute the resources.
resource_rep_from_op()	Returns a compressed representation directly from the operator
tracking_name(*args, **kwargs)	Returns a name used to track the operator during resource estimation.

add_parallel(other)

Adds a ResourceOperator or Resources in parallel.

Parameters:

other (ResourceOperator) – The other object to combine with, it can be another ResourceOperator or a Resources object.

Returns:

added Resources

Return type:

Resources

add_series(other)

Adds a ResourceOperator or Resources in series.

Parameters:

other (ResourceOperator) – The other object to combine with, it can be another ResourceOperator or a Resources object.

Returns:

added Resources

Return type:

Resources

classmethod adjoint_resource_decomp(target_resource_params=None)

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

For a ResourceOperator that doesn’t define an adjoint_resource_decomp method, this will be the default adjoint_resource_decomp method.

Resources:

The resources for the adjoint of an operator are obtained by tracking the adjoint of each gate in the resource decomposition of the operator.

Parameters:

target_resource_params (dict | None) – A dictionary containing the resource parameters of the target operator.

classmethod controlled_resource_decomp(num_ctrl_wires, num_zero_ctrl, target_resource_params=None)

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

For a ResourceOperator that doesn’t define a controlled_resource_decomp method, this will be the default controlled_resource_decomp method.

Resources:

The resources for the controlled operator are obtained by controlling (with the same number of control wires and zero controlled values) each gate in the base operator’s resource decomposition.

Parameters:

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

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

• target_resource_params (dict | None) – A dictionary containing the resource parameters of the target operator.

classmethod pow_resource_decomp(pow_z, target_resource_params=None)

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

For a ResourceOperator that doesn’t define a pow_resource_decomp method, this will be its pow_resource_decomp method.

Resources:

The resources for an operator raised to some power are obtained by taking the base resource decomposition of the operator and tracking each gate raised to the given power. For a power of zero, the identity operator is returned. For a power of one, the base operator is returned.

Parameters:

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

• target_resource_params (dict | None) – A dictionary containing the resource parameters of the target operator.

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

Append the operator to the Operator queue.

classmethod resource_decomp(register_size)

Returns a list representing the resources of the operator. Each object in the list represents a gate and the number of times it occurs in the circuit.

Parameters:

register_size (int) – Number of qubits n in each register.

Resources:

The circuit computes the bitwise XOR of the two registers using CNOTs, then checks whether all results are zero via a Toffoli cascade. The circuit is represented as:

0: ─╭●──────────┤
1: ─│──╭●───────┤
2: ─│──│──╭●────┤
3: ─╰X─│──│──╭○─┤
4: ────╰X─│──├○─┤
5: ───────╰X─├○─┤
6: ──────────╰X─┤  <Z>

Note that the state of the second register is not preserved after this operation and it needs to be uncomputed if it is needed later in the circuit.

Returns:

A list of gate counts representing the resources of the operator.

Return type:

list[GateCount]

classmethod resource_rep(register_size)

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

Parameters:

register_size (int) – Number of qubits n in each register.

Returns:

the operator in a compressed representation

Return type:

CompressedResourceOp

resource_rep_from_op()

Returns a compressed representation directly from the operator

classmethod tracking_name(*args, **kwargs)

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

code/api/api/pennylane.labs.estimator_beta.templates.RegisterEquality

 

Download Python script

 

Download Notebook

 

View on GitHub