Class definition for applying n-qubit controlled unitary operations. More...

#include <ncu.hpp>

Collaboration diagram for QNLP::NCU< SimulatorType >:

Data Structures
struct	OptParamsCX
	For the 5+ controlled NCX decomposition routines defined within https://arxiv.org/pdf/quant-ph/9503016.pdf. More...

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

	NCU (SimulatorType &qSim)
	Construct a new NCU object. More...

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

void	initialiseMaps (SimulatorType &qSim, std::size_t num_ctrl_lines)
	Add the PauliX and the given unitary U to the maps. More...

void	addToMaps (SimulatorType &qSim, std::string U_label, const Mat2x2Type &U, std::size_t num_ctrl_lines)
	Add the given unitary matrix to the maps up to the required depth. More...

GateCache< SimulatorType > &	getGateCache ()
	Get the Map of cached gates. Keys are strings, and values are vectors of paired (gate, gate adjoint) types where the index give the value of (gate)^(1/2^i) More...

void	clearMaps ()
	Clears the maps of stored sqrt matrices. More...

void	applyNQubitControl (SimulatorType &qSim, const std::vector< std::size_t > ctrlIndices, const std::vector< std::size_t > auxIndices, const unsigned int qTarget, const std::string gateLabel, const Mat2x2Type &U, const std::size_t depth)
	Decompose n-qubit controlled op into 1 and 2 qubit gates. Control indices can be in any specified location. Ensure the gate cache has been populated with the appropriate gate type before running. This avoids O(n) checking of the container at each call for the associated gates. More...

std::size_t	get_op_calls (std::size_t num_ctrl_lines)
	Returns the number of 2-qubit operations a non optimised decomposition will make. Cache intermediate results. More...

std::size_t	get_ops_for_params (std::size_t l, std::size_t m)
	Helper method to get optimised number of 2-gate ops for given decomposition params. More...

OptParamsCX	find_optimal_params (std::size_t num_ctrl_lines)
	Returns the number of 2-qubit operations an optimised decomposition will make for nCX. Caches intermediate results. More...

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

Static Protected Attributes
static std::size_t	num_gate_ops

Private Attributes
std::unordered_set< std::string >	default_gates

std::unordered_map< std::size_t, std::size_t >	op_call_counts_CX

std::unordered_map< std::size_t, OptParamsCX >	opt_op_call_params_CX

GateCache< SimulatorType >	gate_cache

Detailed Description

template<class SimulatorType>
class QNLP::NCU< SimulatorType >

Class definition for applying n-qubit controlled unitary operations.

Template Parameters

SimulatorType Class Simulator Type

Definition at line 29 of file ncu.hpp.

Member Typedef Documentation

◆ Mat2x2Type

template<class SimulatorType >

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

protected

Definition at line 55 of file ncu.hpp.

Constructor & Destructor Documentation

◆ NCU() [1/2]

template<class SimulatorType >

QNLP::NCU< SimulatorType >::NCU ( )

inline

Construct a new NCU object.

Definition at line 64 of file ncu.hpp.

                   {
                 //Optimised building block routines for nCX
                 if(op_call_counts_CX.size() == 0){
                     op_call_counts_CX[3] = 13;
                     op_call_counts_CX[5] = 60;
                 }
             };

References QNLP::NCU< SimulatorType >::op_call_counts_CX.

◆ NCU() [2/2]

template<class SimulatorType >

QNLP::NCU< SimulatorType >::NCU ( SimulatorType & qSim )

inline

Construct a new NCU object.

Parameters

qSim	Instance of quantum simulator

Definition at line 77 of file ncu.hpp.

                                      : NCU(){
                 gate_cache = GateCache<SimulatorType>(qSim);
             }

References QNLP::NCU< SimulatorType >::gate_cache.

◆ ~NCU()

template<class SimulatorType >

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

inline

Destroy the NCU object.

Definition at line 85 of file ncu.hpp.

                   {
                 clearMaps();
                 gate_cache.clearCache();
             };

References QNLP::NCU< SimulatorType >::clearMaps(), and QNLP::NCU< SimulatorType >::gate_cache.

Here is the call graph for this function:

Member Function Documentation

◆ addToMaps()

template<class SimulatorType >

void QNLP::NCU< SimulatorType >::addToMaps	(	SimulatorType &	qSim,
		std::string	U_label,
		const Mat2x2Type &	U,
		std::size_t	num_ctrl_lines
	)

inline

Add the given unitary matrix to the maps up to the required depth.

Parameters

U

Definition at line 104 of file ncu.hpp.

                                                                                                                   {
                 gate_cache.addToCache(qSim, U_label, U, num_ctrl_lines);
             }

References QNLP::NCU< SimulatorType >::gate_cache.

◆ applyNQubitControl()

template<class SimulatorType >

void QNLP::NCU< SimulatorType >::applyNQubitControl	(	SimulatorType &	qSim,
		const std::vector< std::size_t >	ctrlIndices,
		const std::vector< std::size_t >	auxIndices,
		const unsigned int	qTarget,
		const std::string	gateLabel,
		const Mat2x2Type &	U,
		const std::size_t	depth
	)

inline

Decompose n-qubit controlled op into 1 and 2 qubit gates. Control indices can be in any specified location. Ensure the gate cache has been populated with the appropriate gate type before running. This avoids O(n) checking of the container at each call for the associated gates.

Template Parameters

Type	ComplexDP or ComplexSP

Parameters

qReg	Qubit register
ctrlIndices	Vector of indices for control lines
qTarget	Target qubit for the unitary matrix U
U	Unitary matrix, U
depth	Depth of recursion.

Definition at line 136 of file ncu.hpp.

              {
                 //No safety checks; be aware of what is physically possible (qTarget not in control_indices)
                 int local_depth = depth + 1;
 
                 //Determine the range over which the qubits exist; consider as a count of the control ops, hence +1 since extremeties included
                 std::size_t cOps = ctrlIndices.size();
 
                 //This can be generalised to find a more optimal set of splitting parameters. Using default example breakdown given in Barenco et al ('95) for now.
 /*                if( (cOps >= 6) && (auxIndices.size() >= 1) && (gateLabel == "X") && (depth == 0) ){
                     auto params = find_optimal_params( ctrlIndices.size() );
 
                     //Need at least 1 aux qubit to perform decomposition
                     assert( auxIndices.size() > 0);
                     
                     //Gate step 1 setup
                     assert( ctrlIndices.size() >= params.m );
                     std::vector<std::size_t> subMCtrlIndicesNCX(ctrlIndices.begin(), ctrlIndices.begin() + params.m);
                     std::vector<std::size_t> subMAuxIndicesNCX(ctrlIndices.begin() + params.m,ctrlIndices.end());
                     subMAuxIndicesNCX.push_back(qTarget);
 
                     //Gate step 2 setup
                     std::vector<std::size_t> subLCtrlIndicesNCX(ctrlIndices.begin() + params.m, ctrlIndices.end());
                     subLCtrlIndicesNCX.push_back(auxIndices[0]);
                     std::vector<std::size_t> subLAuxIndicesNCX(ctrlIndices.begin(), ctrlIndices.begin() + params.m);
 
                     applyNQubitControl(qSim, subMCtrlIndicesNCX, subMAuxIndicesNCX, auxIndices[0], "X", qSim.getGateX(), 0 );
                     applyNQubitControl(qSim, subLCtrlIndicesNCX, subLAuxIndicesNCX, qTarget, "X", qSim.getGateX(), 0 );
                     applyNQubitControl(qSim, subMCtrlIndicesNCX, subMAuxIndicesNCX, auxIndices[0], "X", qSim.getGateX(), 0 );
                     applyNQubitControl(qSim, subLCtrlIndicesNCX, subLAuxIndicesNCX, qTarget, "X", qSim.getGateX(), 0 );
 
                 }
 */
                 if( (cOps >= 5) && ( auxIndices.size() >= cOps-2 ) && (gateLabel == "X") && (depth == 0) ){ //161 -> 60 2-qubit gate calls
                     qSim.applyGateCCX( ctrlIndices.back(), *(auxIndices.begin() + ctrlIndices.size() - 3), qTarget);
 
                     for (std::size_t i = ctrlIndices.size()-2; i >= 2; i--){
                         qSim.applyGateCCX( *(ctrlIndices.begin()+i), *(auxIndices.begin() + (i-2)), *(auxIndices.begin() + (i-1)));
                     }
                     qSim.applyGateCCX( *(ctrlIndices.begin()), *(ctrlIndices.begin()+1), *(auxIndices.begin()) );
                     
                     for (std::size_t i = 2; i <= ctrlIndices.size()-2; i++){
                         qSim.applyGateCCX( *(ctrlIndices.begin()+i), *(auxIndices.begin()+(i-2)), *(auxIndices.begin()+(i-1)));
                     }
                     qSim.applyGateCCX( ctrlIndices.back(), *(auxIndices.begin() + ctrlIndices.size() - 3), qTarget);
 
                     for (std::size_t i = ctrlIndices.size()-2; i >= 2; i--){
                         qSim.applyGateCCX( *(ctrlIndices.begin()+i), *(auxIndices.begin() + (i-2)), *(auxIndices.begin() + (i-1)));
                     }
                     qSim.applyGateCCX( *(ctrlIndices.begin()), *(ctrlIndices.begin()+1), *(auxIndices.begin()) );
                     for (std::size_t i = 2; i <= ctrlIndices.size()-2; i++){
                         qSim.applyGateCCX( *(ctrlIndices.begin()+i), *(auxIndices.begin()+(i-2)), *(auxIndices.begin()+(i-1)));
                     }
                 }
 
                 else if(cOps == 3){ //Optimisation for replacing 17 with 13 2-qubit gate calls
                     //Apply the 13 2-qubit gate calls
                     qSim.applyGateCU( gate_cache.gateCacheMap[gateLabel][local_depth+1].first, ctrlIndices[0], qTarget, gateLabel );
                     qSim.applyGateCX( ctrlIndices[0], ctrlIndices[1]);
 
                     qSim.applyGateCU( gate_cache.gateCacheMap[gateLabel][local_depth+1].second, ctrlIndices[1], qTarget, gateLabel );
                     qSim.applyGateCX( ctrlIndices[0], ctrlIndices[1]);
 
                     qSim.applyGateCU( gate_cache.gateCacheMap[gateLabel][local_depth+1].first, ctrlIndices[1], qTarget, gateLabel );
                     qSim.applyGateCX( ctrlIndices[1], ctrlIndices[2]);
 
                     qSim.applyGateCU( gate_cache.gateCacheMap[gateLabel][local_depth+1].second, ctrlIndices[2], qTarget, gateLabel );
                     qSim.applyGateCX( ctrlIndices[0], ctrlIndices[2]);
 
                     qSim.applyGateCU( gate_cache.gateCacheMap[gateLabel][local_depth+1].first, ctrlIndices[2], qTarget, gateLabel );
                     qSim.applyGateCX( ctrlIndices[1], ctrlIndices[2]);
 
                     qSim.applyGateCU( gate_cache.gateCacheMap[gateLabel][local_depth+1].second, ctrlIndices[2], qTarget, gateLabel );
                     qSim.applyGateCX( ctrlIndices[0], ctrlIndices[2]);
 
                     qSim.applyGateCU( gate_cache.gateCacheMap[gateLabel][local_depth+1].first, ctrlIndices[2], qTarget, gateLabel );
                 }
 
                 else if (cOps >= 2 && cOps !=3){
                     std::vector<std::size_t> subCtrlIndices(ctrlIndices.begin(), ctrlIndices.end()-1);
 
                     qSim.applyGateCU( gate_cache.gateCacheMap[gateLabel][local_depth].first, ctrlIndices.back(), qTarget, gateLabel );
 
                     applyNQubitControl(qSim, subCtrlIndices, auxIndices, ctrlIndices.back(), "X", qSim.getGateX(), 0 );
 
                     qSim.applyGateCU( gate_cache.gateCacheMap[gateLabel][local_depth].second, ctrlIndices.back(), qTarget, gateLabel );
 
                     applyNQubitControl(qSim, subCtrlIndices, auxIndices, ctrlIndices.back(), "X", qSim.getGateX(), 0 );
 
                     applyNQubitControl(qSim, subCtrlIndices, auxIndices, qTarget, gateLabel, gate_cache.gateCacheMap[gateLabel][local_depth+1].first, local_depth );
                 }
 
                 //If the number of control qubits is less than 2, assume we have decomposed sufficiently
                 else{
                     qSim.applyGateCU(gate_cache.gateCacheMap[gateLabel][depth].first, ctrlIndices[0], qTarget, gateLabel); //The first decomposed matrix value is used here
                 }
             }

References QNLP::NCU< SimulatorType >::gate_cache.

◆ clearMaps()

template<class SimulatorType >

void QNLP::NCU< SimulatorType >::clearMaps ( )

inline

Clears the maps of stored sqrt matrices.

Definition at line 121 of file ncu.hpp.

                             {
                 gate_cache.clearCache();
             }

References QNLP::NCU< SimulatorType >::gate_cache.

Referenced by QNLP::NCU< SimulatorType >::~NCU().

Here is the caller graph for this function:

◆ find_optimal_params()

template<class SimulatorType >

OptParamsCX QNLP::NCU< SimulatorType >::find_optimal_params ( std::size_t num_ctrl_lines )

inline

Returns the number of 2-qubit operations an optimised decomposition will make for nCX. Caches intermediate results.

Parameters

num_ctrl_lines The number of control lines in the nCX call

Returns: std::size_t The number of 2-qubit gate calls

Definition at line 286 of file ncu.hpp.

                                                                  {
 
             //If entry exists, return it
             auto it = opt_op_call_params_CX.find(num_ctrl_lines);
             if ( it != opt_op_call_params_CX.end() ){
                 std::cout << "FOUND OPTIMAL PARAMS SEARCH FOR CTRL=" << num_ctrl_lines << "  M=" << it->second.m << " L=" << it->second.l << " OPS=" << it->second.num_ops << std::endl;
 
                 return it->second;
             }
             
             //Determine number of comparisons to make.
             std::size_t num_comp = static_cast<std::size_t>(std::floor((float)(num_ctrl_lines)/2.0)) +1;
 
             OptParamsCX optimal_params;
             std::size_t tmp_num_ops;
             
             for(std::size_t _m = 2; _m <= num_comp; ++_m){
                 std::size_t _l = (num_ctrl_lines - _m + 1);
                 tmp_num_ops = get_ops_for_params(_l, _m);
                 if (_m == 2){
                     optimal_params = OptParamsCX{num_ctrl_lines, _m, _l, tmp_num_ops};
                 }
                 else if ( tmp_num_ops < optimal_params.num_ops){
                     optimal_params = OptParamsCX{num_ctrl_lines, _m, _l, tmp_num_ops};
                 }
                 std::cout << "OPTIMAL PARAMS SEARCH FOR CTRL=" << num_ctrl_lines << "  M=" << _m << " L=" << _l << " OPS=" << tmp_num_ops << std::endl;
             }
             opt_op_call_params_CX[num_ctrl_lines] = optimal_params;
             op_call_counts_CX[num_ctrl_lines] = optimal_params.num_ops;
             std::cout << "OPTIMAL PARAMS FOR CTRL=" << num_ctrl_lines << "  M=" << optimal_params.m << " L=" << optimal_params.l << " OPS=" << optimal_params.num_ops << std::endl;
             return optimal_params;
         }

References QNLP::NCU< SimulatorType >::get_ops_for_params(), QNLP::NCU< SimulatorType >::OptParamsCX::l, QNLP::NCU< SimulatorType >::OptParamsCX::m, QNLP::NCU< SimulatorType >::OptParamsCX::num_ops, QNLP::NCU< SimulatorType >::op_call_counts_CX, and QNLP::NCU< SimulatorType >::opt_op_call_params_CX.

Here is the call graph for this function:

◆ get_op_calls()

template<class SimulatorType >

std::size_t QNLP::NCU< SimulatorType >::get_op_calls ( std::size_t num_ctrl_lines )

inline

Returns the number of 2-qubit operations a non optimised decomposition will make. Cache intermediate results.

Parameters

num_ctrl_lines The number of control lines in the NCU call

Returns: std::size_t The number of 2-qubit gate calls

Definition at line 247 of file ncu.hpp.

                                                         {
             std::size_t num_ops = 0;
             auto it = op_call_counts_CX.find(num_ctrl_lines);
             if ( it != op_call_counts_CX.end() ){
                 std::cout << "get_op_calls CTRL=" << num_ctrl_lines << "  OPS=" << it->second << std::endl;
 
                 return it->second;
             }
             else if (num_ctrl_lines >= 2){
                 num_ops += (2 + 3*get_op_calls(num_ctrl_lines-1));
             }
             else{
                 num_ops += 1;
             }
             op_call_counts_CX[num_ctrl_lines] = num_ops;
             std::cout << "get_op_calls CTRL=" << num_ctrl_lines << "  OPS=" << num_ops << std::endl;
 
             return num_ops;
         }

References QNLP::NCU< SimulatorType >::op_call_counts_CX.

Referenced by QNLP::NCU< SimulatorType >::get_ops_for_params().

Here is the caller graph for this function:

◆ get_ops_for_params()

template<class SimulatorType >

std::size_t QNLP::NCU< SimulatorType >::get_ops_for_params	(	std::size_t	l,
		std::size_t	m
	)

inline

Helper method to get optimised number of 2-gate ops for given decomposition params.

Parameters

l	multi-control gate partition 2, l = n-m-1
m	multi-control gate partition 1, m \in {2,...,n-3}

Returns: const std::size_t

Definition at line 275 of file ncu.hpp.

                                                                      {
             return 2*(get_op_calls(m) + get_op_calls(l));
         }

References QNLP::NCU< SimulatorType >::get_op_calls().

Referenced by QNLP::NCU< SimulatorType >::find_optimal_params().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getGateCache()

template<class SimulatorType >

GateCache<SimulatorType>& QNLP::NCU< SimulatorType >::getGateCache ( )

inline

Get the Map of cached gates. Keys are strings, and values are vectors of paired (gate, gate adjoint) types where the index give the value of (gate)^(1/2^i)

Returns: GateCache<SimulatorType> type

Definition at line 113 of file ncu.hpp.

                                                     {
                 return gate_cache;
             }

References QNLP::NCU< SimulatorType >::gate_cache.

◆ initialiseMaps()

template<class SimulatorType >

void QNLP::NCU< SimulatorType >::initialiseMaps	(	SimulatorType &	qSim,
		std::size_t	num_ctrl_lines
	)

inline

Add the PauliX and the given unitary U to the maps.

Parameters

U

Definition at line 95 of file ncu.hpp.

                                                                                 {
                 gate_cache.initCache(qSim, num_ctrl_lines);
             }

References QNLP::NCU< SimulatorType >::gate_cache.

Field Documentation

◆ default_gates

template<class SimulatorType >

std::unordered_set<std::string> QNLP::NCU< SimulatorType >::default_gates

private

Definition at line 31 of file ncu.hpp.

◆ gate_cache

template<class SimulatorType >

GateCache<SimulatorType> QNLP::NCU< SimulatorType >::gate_cache

private

Definition at line 51 of file ncu.hpp.

Referenced by QNLP::NCU< SimulatorType >::addToMaps(), QNLP::NCU< SimulatorType >::applyNQubitControl(), QNLP::NCU< SimulatorType >::clearMaps(), QNLP::NCU< SimulatorType >::getGateCache(), QNLP::NCU< SimulatorType >::initialiseMaps(), QNLP::NCU< SimulatorType >::NCU(), and QNLP::NCU< SimulatorType >::~NCU().

◆ num_gate_ops

template<class SimulatorType >

std::size_t QNLP::NCU< SimulatorType >::num_gate_ops

staticprotected

Definition at line 57 of file ncu.hpp.

◆ op_call_counts_CX

template<class SimulatorType >

std::unordered_map<std::size_t, std::size_t> QNLP::NCU< SimulatorType >::op_call_counts_CX

private

Definition at line 47 of file ncu.hpp.

Referenced by QNLP::NCU< SimulatorType >::find_optimal_params(), QNLP::NCU< SimulatorType >::get_op_calls(), and QNLP::NCU< SimulatorType >::NCU().

◆ opt_op_call_params_CX

template<class SimulatorType >

std::unordered_map<std::size_t, OptParamsCX> QNLP::NCU< SimulatorType >::opt_op_call_params_CX

private

Definition at line 48 of file ncu.hpp.

Referenced by QNLP::NCU< SimulatorType >::find_optimal_params().

The documentation for this class was generated from the following file:

/Users/mlxd/Desktop/intel-qnlp-rc2/modules/gate_ops/ncu/ncu.hpp

Data Structures

Public Member Functions

Protected Types

Static Protected Attributes

Private Attributes

Detailed Description

template<class SimulatorType> class QNLP::NCU< SimulatorType >

Member Typedef Documentation

◆ Mat2x2Type

Constructor & Destructor Documentation

◆ NCU() [1/2]

◆ NCU() [2/2]

◆ ~NCU()

Member Function Documentation

◆ addToMaps()

◆ applyNQubitControl()

◆ clearMaps()

◆ find_optimal_params()

◆ get_op_calls()

◆ get_ops_for_params()

◆ getGateCache()

◆ initialiseMaps()

Field Documentation

◆ default_gates

◆ gate_cache

◆ num_gate_ops

◆ op_call_counts_CX

◆ opt_op_call_params_CX

template<class SimulatorType>
class QNLP::NCU< SimulatorType >