Class definition for defining and applying an Oracle. More...

#include <oracle.hpp>

Collaboration diagram for QNLP::Oracle< SimulatorType >:

Public Member Functions
	Oracle ()
	Construct a new Oracle object. More...

	~Oracle ()
	Destroy the Oracle object. More...

Static Public Member Functions
static void	bitStringNCU (SimulatorType &s, std::size_t bitstring, const std::vector< std::size_t > &ctrl_indices, const std::size_t target, const Mat2x2Type &U, std::string gateLabel)
	Takes bitstring as the binary pattern and indices as the qubits to operate upon. Applies the appropriate PauliX gates to the control lines to call the NCU with the given matrix. More...

static void	bitStringNCU (SimulatorType &s, std::size_t bitstring, const std::vector< std::size_t > &ctrl_indices, const std::vector< std::size_t > &aux_indices, const std::size_t target, const Mat2x2Type &U, std::string gateLabel)
	Takes bitstring as the binary pattern and indices as the qubits to operate upon. Applies the appropriate PauliX gates to the control lines to call the NCU with the given matrix. Optimised variant using auxiliary qubits to reduce circuit depth. More...

static void	bitStringPhaseOracle (SimulatorType &s, std::size_t bitstring, const std::vector< std::size_t > &ctrlIndices, std::size_t target)
	Takes bitstring as the binary pattern and indices as the qubits to operate upon. Applies the appropriate PauliX gates to the control lines to call the NCU with the given matrix. More...

Private Types
using	Mat2x2Type = decltype(std::declval< SimulatorType >().getGateX())

Detailed Description

template<class SimulatorType>
class QNLP::Oracle< SimulatorType >

Class definition for defining and applying an Oracle.

Template Parameters

SimulatorType Class Simulator type

Definition at line 26 of file oracle.hpp.

Member Typedef Documentation

◆ Mat2x2Type

template<class SimulatorType>

using QNLP::Oracle< SimulatorType >::Mat2x2Type = decltype(std::declval<SimulatorType>().getGateX())

private

Definition at line 29 of file oracle.hpp.

Constructor & Destructor Documentation

◆ Oracle()

template<class SimulatorType>

QNLP::Oracle< SimulatorType >::Oracle ( )

inline

Construct a new Oracle object.

Definition at line 36 of file oracle.hpp.

36 {};

◆ ~Oracle()

template<class SimulatorType>

QNLP::Oracle< SimulatorType >::~Oracle ( )

inline

Destroy the Oracle object.

Definition at line 42 of file oracle.hpp.

42 {};

Member Function Documentation

◆ bitStringNCU() [1/2]

template<class SimulatorType>

static void QNLP::Oracle< SimulatorType >::bitStringNCU	(	SimulatorType &	s,
		std::size_t	bitstring,
		const std::vector< std::size_t > &	ctrl_indices,
		const std::size_t	target,
		const Mat2x2Type &	U,
		std::string	gateLabel
	)

inlinestatic

Takes bitstring as the binary pattern and indices as the qubits to operate upon. Applies the appropriate PauliX gates to the control lines to call the NCU with the given matrix.

Parameters

s	Instance of quantum simulator
bitstring	Binary pattern represented by a std::size_t bitstring
ctrl_indices	Indices of the control qubits in the register
target	Qubit acting as target
U	Unitary matrix to apply
gateLabel	Label to assign operation for U

Definition at line 54 of file oracle.hpp.

                                                                                                                                                                                    {
             std::size_t bitmask = 0b1;
             std::vector<std::size_t> reverse_pattern;
             for(std::size_t i = 0; i < ctrl_indices.size() + 1; ++i){
                 //If the bitstring contains a 1 at desired index, will be true;
                 //We wish to apply X to any state that is false, then undo
                 if( ! (bitstring & (bitmask<<i) ) ){
                     reverse_pattern.push_back(i);
                     if( i < ctrl_indices.size())
                         s.applyGateX(ctrl_indices[i]);
                     else
                         s.applyGateX(target);
                 }
             }
             s.applyGateNCU(U, ctrl_indices, target, gateLabel);
             //Undo PauliX ops
             for(auto& revIdx : reverse_pattern){
                 if( revIdx < ctrl_indices.size()){
                     s.applyGateX(ctrl_indices[revIdx]);
                 }
                 else{
                     s.applyGateX(target);
                 }
             }
         }

References ncu_opt_tester::target.

Referenced by QNLP::SimulatorGeneral< IntelSimulator >::applyOracleU(), QNLP::Oracle< SimulatorType >::bitStringPhaseOracle(), and TEST_CASE().

Here is the caller graph for this function:

◆ bitStringNCU() [2/2]

template<class SimulatorType>

static void QNLP::Oracle< SimulatorType >::bitStringNCU	(	SimulatorType &	s,
		std::size_t	bitstring,
		const std::vector< std::size_t > &	ctrl_indices,
		const std::vector< std::size_t > &	aux_indices,
		const std::size_t	target,
		const Mat2x2Type &	U,
		std::string	gateLabel
	)

inlinestatic

Takes bitstring as the binary pattern and indices as the qubits to operate upon. Applies the appropriate PauliX gates to the control lines to call the NCU with the given matrix. Optimised variant using auxiliary qubits to reduce circuit depth.

Parameters

s	Instance of quantum simulator
bitstring	Binary pattern represented by a std::size_t bitstring
ctrl_indices	Indices of the control qubits in the register
aux_indices	Indices of the auxiliary qubits in the register to reduce depth. State will be returned to pre-method call values.
target	Qubit acting as target
U	Unitary matrix to apply
gateLabel	Label to assign operation for U

Definition at line 92 of file oracle.hpp.

                                                                                                                                                                                                                             {
             std::size_t bitmask = 0b1;
             std::vector<std::size_t> reverse_pattern;
             for(std::size_t i = 0; i < ctrl_indices.size() + 1; ++i){
                 //If the bitstring contains a 1 at desired index, will be true;
                 //We wish to apply X to any state that is false, then undo
                 if( ! (bitstring & (bitmask<<i) ) ){
                     reverse_pattern.push_back(i);
                     if( i < ctrl_indices.size())
                         s.applyGateX(ctrl_indices[i]);
                     else
                         s.applyGateX(target);
                 }
             }
             s.applyGateNCU(U, ctrl_indices, aux_indices, target, gateLabel);
             //Undo PauliX ops
             for(auto& revIdx : reverse_pattern){
                 if( revIdx < ctrl_indices.size()){
                     s.applyGateX(ctrl_indices[revIdx]);
                 }
                 else{
                     s.applyGateX(target);
                 }
             }
         }

References ncu_opt_tester::target.

◆ bitStringPhaseOracle()

template<class SimulatorType>

static void QNLP::Oracle< SimulatorType >::bitStringPhaseOracle	(	SimulatorType &	s,
		std::size_t	bitstring,
		const std::vector< std::size_t > &	ctrlIndices,
		std::size_t	target
	)

inlinestatic

Takes bitstring as the binary pattern and indices as the qubits to operate upon. Applies the appropriate PauliX gates to the control lines to call the NCU with the given matrix.

Parameters

s	Simulator object
bitstring	Binary pattern represented by a std::size_t bitstring
ctrlIndices	Indices of the control qubits in the register
target	Qubit acting as target

Definition at line 126 of file oracle.hpp.

                                                                                                                                           {
             std::size_t num_qubits = s.getNumQubits();
             assert ( (1<<num_qubits) < bitstring );
             bitStringNCU(s, bitstring, ctrlIndices, target, s.getGateZ(), "Z");
         }