QNLP::IntelSimulator Class Reference

Class definition for IntelSimulator. The purpose of this class is to map the functionality of the underlying quantum simulator to this class so that it can be used as the template for the CRTP templated SimulatorGeneral class. More...

Inheritance diagram for QNLP::IntelSimulator:

Collaboration diagram for QNLP::IntelSimulator:

Public Types
using	TMDP = qhipster::TinyMatrix< ComplexDP, 2, 2, 32 >
using	QRDP = QubitRegister< ComplexDP >
using	CST = const std::size_t

Public Member Functions
	IntelSimulator (int numQubits, bool useFusion=false)
	Construct a new Intel Simulator object. The constructor also sets up and initialises the MPI environemnt if MPI is enabled in the build process. More...
	~IntelSimulator ()
	Destroy the Intel Simulator object. More...
void	applyGateU (const TMDP &U, CST qubitIndex, std::string label="U")
	Apply arbitrary user-defined unitary gate to qubit at qubit_idx. More...
void	applyGateI (std::size_t qubitIndex)
	Apply the Identity gate to the given qubit. More...
void	applyGatePhaseShift (std::size_t qubit_idx, double angle)
	Apply phase shift to given Qubit; [[1 0] [0 exp(i*angle)]]. More...
void	applyGateSqrtSwap (std::size_t qubit_idx0, std::size_t qubit_idx1)
	Performs Sqrt SWAP gate between two given qubits (half way SWAP) More...
void	applyGateCCX (std::size_t ctrl_qubit0, std::size_t ctrl_qubit1, std::size_t target_qubit)
	Controlled controlled NOT (CCNOT, CCX) gate. More...
void	applyGateCSwap (std::size_t ctrl_qubit, std::size_t qubit_swap0, std::size_t qubit_swap1)
void	applyGateX (CST qubitIndex)
	Apply the Pauli X gate to the given qubit. More...
void	applyGateY (CST qubitIndex)
	Apply the Pauli Y gate to the given qubit. More...
void	applyGateZ (CST qubitIndex)
	Apply the Pauli Z gate to the given qubit. More...
void	applyGateH (CST qubitIndex)
	Apply the Hadamard gate to the given qubit. More...
void	applyGateSqrtX (CST qubitIndex)
	Apply the Sqrt{Pauli X} gate to the given qubit. More...
void	applyGateRotX (CST qubitIndex, double angle)
	Apply the given Rotation about X-axis to the given qubit. More...
void	applyGateRotY (CST qubitIndex, double angle)
	Apply the given Rotation about Y-axis to the given qubit. More...
void	applyGateRotZ (CST qubitIndex, double angle)
	Apply the given Rotation about Z-axis to the given qubit. More...
TMDP	getGateX ()
	Get the Pauli-X gate. More...
TMDP	getGateY ()
	Get the Pauli-Y gate. More...
TMDP	getGateZ ()
	Get the Pauli-Z gate. More...
TMDP	getGateI ()
	Get the Identity. More...
TMDP	getGateH ()
	Get the Hadamard gate. More...
void	applyGateCU (const TMDP &U, CST control, CST target, std::string label="U")
	Apply the given controlled unitary gate on target qubit. More...
void	applyGateCX (CST control, CST target)
	Apply Controlled Pauli-X (CNOT) on target qubit. More...
void	applyGateCY (CST control, CST target)
	Apply Controlled Pauli-Y on target qubit. More...
void	applyGateCZ (CST control, CST target)
	Apply Controlled Pauli-Z on target qubit. More...
void	applyGateCH (CST control, CST target)
	Apply Controlled Hadamard on target qubit. More...
void	applyGateCPhaseShift (double angle, unsigned int control, unsigned int target)
	Perform controlled phase shift gate. More...
void	applyGateCRotX (CST control, CST target, const double theta)
	Apply the given Controlled Rotation about X-axis to the given qubit. More...
void	applyGateCRotY (CST control, CST target, double theta)
	Apply the given Controlled Rotation about Y-axis to the given qubit. More...
void	applyGateCRotZ (CST control, CST target, const double theta)
	Apply the given Controlled Rotation about Z-axis to the given qubit. More...
void	applyGateSwap (CST qubit_idx0, CST qubit_idx1)
	Swap the qubits at the given indices. More...
QubitRegister< ComplexDP > &	getQubitRegister ()
	Get the Qubit Register object. More...
const QubitRegister< ComplexDP > &	getQubitRegister () const
	Get the Qubit Register object. More...
std::size_t	getNumQubits ()
	Get the number of Qubits. More...
void	initRegister ()
	(Re)Initialise the underlying register of the encapsulated simulator to well-defined state (|0....0>) More...
void	applyAmplitudeNorm ()
	Apply normalization to the amplitudes of each state. This is required after a qubit in a state is collapsed. More...
bool	applyMeasurement (CST target, bool normalize=true)
	Apply measurement to a target qubit, randomly collapsing the qubit proportional to the amplitude and returns the collapsed value. If built with MPI enabled, this member function collpases the corresponding qubit in each state across all processes. More...
void	collapseToBasisZ (CST target, bool collapseValue)
	Apply measurement to a target qubit with respect to the Z-basis, collapsing to a specified value (0 or 1). Amplitudes are r-normalized afterwards. More...
void	PrintStates (std::string x, std::vector< std::size_t > qubits={})
	Prints the string x and then for each state of the specified qubits in the superposition, prints each its amplitude, followed by state and then by the probability of that state. Note that this state observation method is not a permitted quantum operation, however it is provided for convenience and debugging/testing. More...
std::pair< std::size_t, std::size_t >	getGateCounts ()
	Print 1 and 2 qubit gate call counts. More...
complex< double >	overlap (IntelSimulator &sim)
	Compute overlap between different simulators. Number of qubits must be the same. More...
void	applyGateX (std::size_t qubit_idx)
	Apply the Pauli X gate to the given qubit. More...
void	applyGateY (std::size_t qubit_idx)
	Apply the Pauli Y gate to the given qubit. More...
void	applyGateZ (std::size_t qubit_idx)
	Apply the Pauli Z gate to the given qubit. More...
void	applyGateH (std::size_t qubit_idx)
	Apply the Hadamard gate to the given qubit. More...
void	applyGateSqrtX (std::size_t qubit_idx)
	Apply the Sqrt{Pauli X} gate to the given qubit. More...
void	applyGateRotX (std::size_t qubit_idx, double angle_rad)
	Apply the given Rotation about X-axis to the given qubit. More...
void	applyGateRotY (std::size_t qubit_idx, double angle_rad)
	Apply the given Rotation about Y-axis to the given qubit. More...
void	applyGateRotZ (std::size_t qubit_idx, double angle_rad)
	Apply the given Rotation about Z-axis to the given qubit. More...
void	applyGateU (const Mat2x2Type &U, std::size_t qubit_idx)
	Apply arbitrary user-defined unitary gate to qubit at qubit_idx. More...
void	applyGateCU (const Mat2x2Type &U, const std::size_t control, const std::size_t target, std::string label="CU")
	Apply the given controlled unitary gate on target qubit. More...
void	applyGateCX (const std::size_t control, const std::size_t target)
	Apply Controlled Pauli-X (CNOT) on target qubit. More...
void	applyGateCY (const std::size_t control, const std::size_t target)
	Apply Controlled Pauli-Y on target qubit. More...
void	applyGateCZ (const std::size_t control, const std::size_t target)
	Apply Controlled Pauli-Z on target qubit. More...
void	applyGateCH (const std::size_t control, const std::size_t target)
	Apply Controlled Hadamard on target qubit. More...
void	applyGateSwap (std::size_t qubit_idx0, std::size_t qubit_idx1)
	Swap the qubits at the given indices. More...
void	applyGatePhaseShift (double angle, std::size_t qubit_idx)
	Apply phase shift to given Qubit; [[1 0] [0 exp(i*angle)]]. More...
void	applyGateCPhaseShift (double angle, std::size_t control, std::size_t target)
	Perform controlled phase shift gate. More...
void	applyGateCRotX (std::size_t ctrl_qubit, std::size_t qubit_idx, double angle_rad)
	Apply the given Controlled Rotation about X-axis to the given qubit. More...
void	applyGateCRotY (std::size_t ctrl_qubit, std::size_t qubit_idx, double angle_rad)
	Apply the given Controlled Rotation about Y-axis to the given qubit. More...
void	applyGateCRotZ (std::size_t ctrl_qubit, std::size_t qubit_idx, double angle_rad)
	Apply the given Controlled Rotation about Z-axis to the given qubit. More...
void	applyQFT (std::size_t minIdx, std::size_t maxIdx)
	Apply the forward Quantum Fourier transform (QFT) to the given register index range. More...
void	applyIQFT (std::size_t minIdx, std::size_t maxIdx)
	Apply the inverse Quantum Fourier transform (IQFT) to the given register index range. More...
void	sumReg (std::size_t r0_minIdx, std::size_t r0_maxIdx, std::size_t r1_minIdx, std::size_t r1_maxIdx)
	Applies |r1>|r2> -> |r1>|r1+r2> More...
void	subReg (std::size_t r0_minIdx, std::size_t r0_maxIdx, std::size_t r1_minIdx, std::size_t r1_maxIdx)
	Applies |r1>|r2> -> |r1>|r1-r2> More...
void	applyGateNCU (const Mat2x2Type &U, const std::vector< std::size_t > &ctrlIndices, std::size_t target, std::string label)
	Apply n-control unitary gate to the given qubit target. More...
void	applyGateNCU (const Mat2x2Type &U, const std::vector< std::size_t > &ctrlIndices, const std::vector< std::size_t > &auxIndices, std::size_t target, std::string label)
	Apply n-control sigma_x gate to the given qubit target, using auxiliary qubits for 5CX optimisation. More...
void	applyOracleU (std::size_t bit_pattern, const std::vector< std::size_t > &ctrlIndices, std::size_t target, const Mat2x2Type &U, std::string gateLabel)
	Apply oracle to match given binary index with non adjacent controls. More...
void	applyOracleU (std::size_t bit_pattern, const std::vector< std::size_t > &ctrlIndices, const std::vector< std::size_t > &auxIndices, std::size_t target, const Mat2x2Type &U, std::string gateLabel)
	Apply oracle to match given binary index with non adjacent controls. More...
void	applyOraclePhase (std::size_t bit_pattern, const std::vector< std::size_t > &ctrlIndices, std::size_t target)
	Apply oracle to match given binary index with linearly adjacent controls. More...
void	applyDiffusion (const std::vector< std::size_t > &ctrlIndices, std::size_t target)
	Apply diffusion operator on marked state. More...
void	encodeToRegister (std::size_t target_pattern, const std::vector< std::size_t > target_register, std::size_t len_bin_pattern)
	Encodes a defined binary pattern into a defined target register (initially in state |00...0>) of all quantum states in the superposition. More...
void	encodeBinToSuperpos_unique (const std::vector< std::size_t > &reg_memory, const std::vector< std::size_t > &reg_auxiliary, const std::vector< std::size_t > &bin_patterns, const std::size_t len_bin_pattern)
	Encode inputted binary strings to the memory register specified as a superposition of states. Note that this implementation does not allow for multiple instances of the same input pattern but allows for 0 to be encoded. More...
void	applyHammingDistanceRotY (std::size_t test_pattern, const std::vector< std::size_t > reg_mem, const std::vector< std::size_t > reg_auxiliary, std::size_t len_bin_pattern)
	Computes the relative Hamming distance between the test pattern and the pattern stored in each state of the superposition, storing the result in the amplitude of the corresponding state. More...
void	applyHammingDistanceOverwrite (std::size_t test_pattern, const std::vector< std::size_t > reg_mem, const std::vector< std::size_t > reg_auxiliary, std::size_t len_bin_pattern)
	Computes the relative Hamming distance between the test pattern and the pattern stored in each state of the superposition, overwriting the aux register pattern with the resulting bit differences. More...
bool	applyMeasurement (std::size_t target, bool normalize=true)
	Apply measurement to a target qubit, randomly collapsing the qubit proportional to the amplitude and returns the collapsed value. More...
std::size_t	applyMeasurementToRegister (std::vector< std::size_t > target_qubits, bool normalize=true)
	Apply measurement to a set of target qubits, randomly collapsing the qubits proportional to the amplitude and returns the bit string of the qubits in the order they are represented in the vector of indexes, in the form of an unsigned integer. More...
void	groupQubits (const std::vector< std::size_t > reg_auxiliary, bool lsb=true)
	Group all set qubits to MSB in register (ie |010100> -> |000011>) More...
void	collapseToBasisZ (std::size_t target, bool collapseValue)
	Apply measurement to a target qubit with respect to the Z-basis, collapsing to a specified value (0 or 1). Amplitudes are r-normalized afterwards. More...
void	initCaches ()
	Initialise caches used in NCU operation. More...
void	addUToCache (std::string gateLabel, const Mat2x2Type &U)
	Adds a matrix to the cache, assigning it to a defined label. This is used in the caching for the NCU operation. More...
Mat2x2Type	matrixSqrt (const Mat2x2Type &U)
	Calculates the unitary matrix square root (U == VV, where V is returned) More...
void	InvertRegister (const unsigned int minIdx, const unsigned int maxIdx)
	Invert the register about the given indides: 0,1,2...n-1,n -> n,n-1,...,1,0. More...

Static Public Member Functions
static Mat2x2Type	adjointMatrix (const Mat2x2Type &U)
	Function to calculate the adjoint of an input matrix. More...

Protected Attributes
std::any	sim_ncu

Private Member Functions
void	collapseQubit (CST target, bool collapseValue)
	Collapses specified qubit in register to the collapseValue without applying normalization. More...
double	getStateProbability (CST target)
	Get the probability of the specified qubit being in the state |1> More...

Private Attributes
const std::size_t	uid
std::size_t	numQubits
QRDP	qubitRegister
std::vector< TMDP >	gates
std::size_t	gate_count_1qubit
std::size_t	gate_count_2qubit
std::random_device	rd
std::mt19937	mt
std::uniform_real_distribution< double >	dist

Detailed Description

Class definition for IntelSimulator. The purpose of this class is to map the functionality of the underlying quantum simulator to this class so that it can be used as the template for the CRTP templated SimulatorGeneral class.

Definition at line 35 of file IntelSimulator.cpp.

Member Typedef Documentation

CST

using QNLP::IntelSimulator::CST = const std::size_t

Definition at line 39 of file IntelSimulator.cpp.

QRDP

using QNLP::IntelSimulator::QRDP = QubitRegister<ComplexDP>

Definition at line 38 of file IntelSimulator.cpp.

TMDP

using QNLP::IntelSimulator::TMDP = qhipster::TinyMatrix<ComplexDP, 2, 2, 32>

Definition at line 37 of file IntelSimulator.cpp.

Constructor & Destructor Documentation

IntelSimulator()

QNLP::IntelSimulator::IntelSimulator ( int  numQubits, bool  useFusion = false  )

inline

Construct a new Intel Simulator object. The constructor also sets up and initialises the MPI environemnt if MPI is enabled in the build process.

Parameters

numQubits	Number of qubits in quantum register
useFusion	Implement gate fusion (default is False)

Definition at line 47 of file IntelSimulator.cpp.

                                                        : SimulatorGeneral<IntelSimulator>(), 
                                    numQubits(numQubits), 
                                    qubitRegister(QubitRegister<ComplexDP> (numQubits, "base", 0)),
                                    gates(5), uid( reinterpret_cast<std::size_t>(this) ){

        //Define Pauli X
        gates[0](0,0) = ComplexDP(0.,0.);       gates[0](0,1) = ComplexDP(1.,0.);
        gates[0](1,0) = ComplexDP(1.,0.);       gates[0](1,1) = ComplexDP(0.,0.);

        //Define Pauli Y
        gates[1](0,0) = ComplexDP(0.,0.);       gates[1](0,1) = -ComplexDP(0.,1.);
        gates[1](1,0) = ComplexDP(0.,1.);       gates[1](1,1) = ComplexDP(0.,0.);

        //Define Pauli Z
        gates[2](0,0) = ComplexDP(1.,0.);       gates[2](0,1) = ComplexDP(0.,0.);
        gates[2](1,0) = ComplexDP(0.,0.);       gates[2](1,1) = ComplexDP(-1.,0.);

        //Define I
        gates[3](0,0) = ComplexDP(1.,0.);       gates[3](0,1) = ComplexDP(0.,0.);
        gates[3](1,0) = ComplexDP(0.,0.);       gates[3](1,1) = ComplexDP(1.,0.);

        //Define Pauli H
        double coeff = (1./sqrt(2.));
        gates[4](0,0) = coeff*ComplexDP(1.,0.);   gates[4](0,1) = coeff*ComplexDP(1.,0.);
        gates[4](1,0) = coeff*ComplexDP(1.,0.);   gates[4](1,1) = -coeff*ComplexDP(1.,0.);

        //Ensure the cache maps are populated before use.
        this->initCaches();

        #ifdef ENABLE_MPI //If for some strange reason the MPI environement is not enable through the Base CRTP class, enable using Intel-QS
            int mpi_is_init;
            MPI_Initialized(&mpi_is_init);
            if (! mpi_is_init){ // Attempt init using Intel-QS MPI env
                int argc_tmp = 0;
                char** argv_tmp = new char*[argc_tmp];

                qhipster::mpi::Environment env(argc_tmp, argv_tmp); //we do not expect to pass any params here
                delete argv_tmp;
            }
            MPI_Comm_rank(MPI_COMM_WORLD, &rank);
        #endif

        /* Set up random number generator for randomly collapsing qubit to 0 or 1
         *
         * Note: a random number will be generated on rank 0 and then broadcasted
         * to all ranks so that each rank collapses the respective qubit to the
         * same value.
         */
        std::mt19937 mt_(rd()); 
        std::uniform_real_distribution<double> dist_(0.0,1.0);
        mt = mt_;
        dist = dist_;
        if(useFusion == true){
            qubitRegister.TurnOnFusion();
            std::cerr << "Warning: enabling fusion may cause inconsistent results." << std::endl;
        }
        gate_count_1qubit = 0;
        gate_count_2qubit = 0;
    }

References dist, gate_count_1qubit, gate_count_2qubit, gates, QNLP::SimulatorGeneral< IntelSimulator >::initCaches(), mt, qubitRegister, ncu_opt_tester::rank, and rd.

Here is the call graph for this function:

~IntelSimulator()

QNLP::IntelSimulator::~IntelSimulator ( )

inline

Destroy the Intel Simulator object.

Definition at line 111 of file IntelSimulator.cpp.

{ }

Member Function Documentation

addUToCache()

void QNLP::SimulatorGeneral< IntelSimulator >::addUToCache ( std::string  gateLabel, const Mat2x2Type &  U  )

inlineinherited

Adds a matrix to the cache, assigning it to a defined label. This is used in the caching for the NCU operation.

Template Parameters

Mat2x2Type

Matrix type to be cached

Parameters

gateLabel	Label assigned to the matrix being cached
U	Matrix to be cached

Definition at line 703 of file Simulator.hpp.

                                                                  {
            #if defined(__INTEL_COMPILER) || defined(__INTEL_LLVM_COMPILER)
            std::experimental::any_cast<NCU<DerivedType>&>(sim_ncu).getGateCache().addToCache(static_cast<DerivedType&>(*this), gateLabel, U, 16);
            #else
            std::any_cast<NCU<DerivedType>&>(sim_ncu).getGateCache().addToCache(static_cast<DerivedType&>(*this), gateLabel, U, 16);
            #endif
        }

adjointMatrix()

static Mat2x2Type QNLP::SimulatorGeneral< IntelSimulator >::adjointMatrix ( const Mat2x2Type &  U )

inlinestaticinherited

Function to calculate the adjoint of an input matrix.

Template Parameters

Mat2x2Type

Matrix type

Parameters

U	Unitary matrix to be adjointed

Returns

openqu::TinyMatrix<Type, 2, 2, 32> U^{\dagger}

Definition at line 757 of file Simulator.hpp.

                                                            {
            Mat2x2Type Uadjoint(U);
            std::complex<double> tmp;
            tmp = Uadjoint(0,1);
            Uadjoint(0,1) = Uadjoint(1,0);
            Uadjoint(1,0) = tmp;
            Uadjoint(0,0) = std::conj(Uadjoint(0,0));
            Uadjoint(0,1) = std::conj(Uadjoint(0,1));
            Uadjoint(1,0) = std::conj(Uadjoint(1,0));
            Uadjoint(1,1) = std::conj(Uadjoint(1,1));
            return Uadjoint;
        }

applyAmplitudeNorm()

void QNLP::IntelSimulator::applyAmplitudeNorm ( )

inline

Apply normalization to the amplitudes of each state. This is required after a qubit in a state is collapsed.

Definition at line 642 of file IntelSimulator.cpp.

                                    {
        this->qubitRegister.Normalize();
    }

References qubitRegister.

Referenced by applyMeasurement(), and collapseToBasisZ().

Here is the caller graph for this function:

applyDiffusion()

void QNLP::SimulatorGeneral< IntelSimulator >::applyDiffusion ( const std::vector< std::size_t > &  ctrlIndices, std::size_t  target  )

inlineinherited

Apply diffusion operator on marked state.

Parameters

ctrlIndices	Vector of control line indices
target	Target qubit index to apply Ctrl-Z upon.

Definition at line 536 of file Simulator.hpp.

                                                                                      {
            Diffusion<DerivedType> diffusion;
            diffusion.applyOpDiffusion(static_cast<DerivedType&>(*this), ctrlIndices, target);
        }

applyGateCCX()

void QNLP::IntelSimulator::applyGateCCX ( std::size_t  ctrl_qubit0, std::size_t  ctrl_qubit1, std::size_t  target_qubit  )

inline

Controlled controlled NOT (CCNOT, CCX) gate.

Parameters

ctrl_qubit0	Control qubit 0
ctrl_qubit1	Control qubit 1
target_qubit	Target qubit

Definition at line 193 of file IntelSimulator.cpp.

                                                                                                  {
        this->applyGateNCU(this->getGateX(), std::vector<std::size_t> {ctrl_qubit0, ctrl_qubit1}, target_qubit, "X");
    }

References QNLP::SimulatorGeneral< IntelSimulator >::applyGateNCU(), and getGateX().

Here is the call graph for this function:

applyGateCH() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateCH ( const std::size_t  control, const std::size_t  target  )

inlineinherited

Apply Controlled Hadamard on target qubit.

Parameters

control	Qubit index acting as control
target	Qubit index acting as target

Definition at line 294 of file Simulator.hpp.

                                                                         {
            static_cast<DerivedType*>(this)->applyGateCH(control, target);
        }

applyGateCH() [2/2]

void QNLP::IntelSimulator::applyGateCH ( CST  control, CST  target  )

inline

Apply Controlled Hadamard on target qubit.

Parameters

control	Qubit index acting as control
target	Qubit index acting as target

Definition at line 496 of file IntelSimulator.cpp.

                                                    {
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyCHadamard(control, target);
        #endif

        gate_count_2qubit++;

        #ifdef GATE_LOGGING
        writer.twoQubitGateCall( "H", getGateH().tostr(), control, target );
        #endif
    }

References gate_count_2qubit, getGateH(), qubitRegister, and ncu_opt_tester::target.

Here is the call graph for this function:

applyGateCPhaseShift() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateCPhaseShift ( double  angle, std::size_t  control, std::size_t  target  )

inlineinherited

Perform controlled phase shift gate.

Parameters

angle	Angle of phase shift in rads
control	Index of control qubit
target	Index of target qubit

Definition at line 335 of file Simulator.hpp.

                                                                                    {
            static_cast<DerivedType*>(this)->applyGateCPhaseShift(angle, control, target);
        }

applyGateCPhaseShift() [2/2]

void QNLP::IntelSimulator::applyGateCPhaseShift ( double  angle, unsigned int  control, unsigned int  target  )

inline

Perform controlled phase shift gate.

Parameters

angle	Angle of phase shift in rads
control	Index of control qubit
target	Index of target qubit

Definition at line 515 of file IntelSimulator.cpp.

                                                                                             {
        TMDP U(gates[3]);
        U(1, 1) = ComplexDP(cos(angle), sin(angle));

        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyControlled1QubitGate(control, target, U);
        #endif

        gate_count_2qubit++;

        #ifdef GATE_LOGGING
        writer.twoQubitGateCall( "CPhase", U.tostr(), control, target );
        #endif
    }

References gate_count_2qubit, gates, qubitRegister, and ncu_opt_tester::target.

applyGateCRotX() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateCRotX ( std::size_t  ctrl_qubit, std::size_t  qubit_idx, double  angle_rad  )

inlineinherited

Apply the given Controlled Rotation about X-axis to the given qubit.

Parameters

ctrl_qubit	Control qubit
qubit_idx	Index of qubit to rotate about X-axis
angle_rad	Rotation angle

Definition at line 373 of file Simulator.hpp.

                                                                                        {
            static_cast<DerivedType&>(*this).applyGateCRotX(ctrl_qubit, qubit_idx, angle_rad);
        }

applyGateCRotX() [2/2]

void QNLP::IntelSimulator::applyGateCRotX ( CST  control, CST  target, const double  theta  )

inline

Apply the given Controlled Rotation about X-axis to the given qubit.

Parameters

control	Control qubit
target	Index of qubit to rotate about X-axis
theta	Rotation angle

Definition at line 537 of file IntelSimulator.cpp.

                                                                           {
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyCRotationX(control, target, theta);
        #endif

        gate_count_2qubit++;

        #ifdef GATE_LOGGING
        writer.twoQubitGateCall( "CR_X", getGateI().tostr(), control, target );
        #endif
    }

References gate_count_2qubit, getGateI(), qubitRegister, and ncu_opt_tester::target.

Here is the call graph for this function:

applyGateCRotY() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateCRotY ( std::size_t  ctrl_qubit, std::size_t  qubit_idx, double  angle_rad  )

inlineinherited

Apply the given Controlled Rotation about Y-axis to the given qubit.

Parameters

ctrl_qubit	Control qubit
qubit_idx	Index of qubit to rotate about Y-axis
angle_rad	Rotation angle

Definition at line 384 of file Simulator.hpp.

                                                                                        {
            static_cast<DerivedType&>(*this).applyGateCRotY(ctrl_qubit, qubit_idx, angle_rad);
        }

applyGateCRotY() [2/2]

void QNLP::IntelSimulator::applyGateCRotY ( CST  control, CST  target, double  theta  )

inline

Apply the given Controlled Rotation about Y-axis to the given qubit.

Parameters

control	Control qubit
target	Index of qubit to rotate about Y-axis
theta	Rotation angle

Definition at line 556 of file IntelSimulator.cpp.

                                                                     {
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyCRotationY(control, target, theta);
        #endif

        gate_count_2qubit++;

        #ifdef GATE_LOGGING
        writer.twoQubitGateCall( "CR_Y", getGateI().tostr(), control, target );
        #endif
    }

References gate_count_2qubit, getGateI(), qubitRegister, and ncu_opt_tester::target.

Here is the call graph for this function:

applyGateCRotZ() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateCRotZ ( std::size_t  ctrl_qubit, std::size_t  qubit_idx, double  angle_rad  )

inlineinherited

Apply the given Controlled Rotation about Z-axis to the given qubit.

Parameters

ctrl_qubit	Control qubit
qubit_idx	Index of qubit to rotate about Z-axis
angle_rad	Rotation angle

Definition at line 395 of file Simulator.hpp.

                                                                                        {
            static_cast<DerivedType&>(*this).applyGateCRotZ(ctrl_qubit, qubit_idx, angle_rad);
        }

applyGateCRotZ() [2/2]

void QNLP::IntelSimulator::applyGateCRotZ ( CST  control, CST  target, const double  theta  )

inline

Apply the given Controlled Rotation about Z-axis to the given qubit.

Parameters

control	Control qubit
target	Index of qubit to rotate about Z-axis
theta	Rotation angle

Definition at line 575 of file IntelSimulator.cpp.

                                                                           {
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyCRotationZ(control, target, theta);
        #endif
        
        gate_count_2qubit++;
        
        #ifdef GATE_LOGGING
        writer.twoQubitGateCall( "CR_Z", getGateI().tostr(), control, target );
        #endif
    }

References gate_count_2qubit, getGateI(), qubitRegister, and ncu_opt_tester::target.

Here is the call graph for this function:

applyGateCSwap()

void QNLP::IntelSimulator::applyGateCSwap ( std::size_t  ctrl_qubit, std::size_t  qubit_swap0, std::size_t  qubit_swap1  )

inline

   @brief Controlled SWAP gate (Controlled swap decomposition taken from arXiV:1301.3727

)

   @param ctrl_qubit Control qubit
   @param qubit_swap0 Swap qubit 0
   @param qubit_swap1 Swap qubit 1

Definition at line 205 of file IntelSimulator.cpp.

                                                                                                  {
        //V = sqrt(X)
        TMDP V;
        V(0,0) = {0.5,  0.5};
        V(0,1) = {0.5, -0.5};
        V(1,0) = {0.5, -0.5};
        V(1,1) = {0.5,  0.5};
        
        TMDP V_dag;
        V_dag(0,0) = {0.5, -0.5};
        V_dag(0,1) = {0.5,  0.5};
        V_dag(1,0) = {0.5,  0.5};
        V_dag(1,1) = {0.5, -0.5};
        
        applyGateCX(qubit_swap1, qubit_swap0);
        applyGateCU(V, qubit_swap0, qubit_swap1, "X");
        applyGateCU(V, ctrl_qubit, qubit_swap1, "X");
        
        applyGateCX(ctrl_qubit, qubit_swap0);
        applyGateCU(V_dag, qubit_swap0, qubit_swap1, "X");
        applyGateCX(qubit_swap1, qubit_swap0);
        applyGateCX(ctrl_qubit, qubit_swap0);
    }

References applyGateCU(), and applyGateCX().

Here is the call graph for this function:

applyGateCU() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateCU ( const Mat2x2Type &  U, const std::size_t  control, const std::size_t  target, std::string  label = "CU"  )

inlineinherited

Apply the given controlled unitary gate on target qubit.

Parameters

U	User-defined arbitrary 2x2 unitary gate (matrix)
control	Qubit index acting as control
target	Qubit index acting as target

Definition at line 254 of file Simulator.hpp.

                                                                                                                    {
            static_cast<DerivedType*>(this)->applyGateCU(U, control, target, label);
        }

applyGateCU() [2/2]

void QNLP::IntelSimulator::applyGateCU ( const TMDP &  U, CST  control, CST  target, std::string  label = "U"  )

inline

Apply the given controlled unitary gate on target qubit.

Parameters

U	User-defined arbitrary 2x2 unitary gate (matrix)
control	Qubit index acting as control
target	Qubit index acting as target
label	Optional parameter to label the gate U

Definition at line 424 of file IntelSimulator.cpp.

                                                                                        {
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyControlled1QubitGate(control, target, U);
        #endif

        gate_count_2qubit++;

        #ifdef GATE_LOGGING
        writer.twoQubitGateCall( label, U.tostr(), control, target );
        #endif
    }

References gate_count_2qubit, qubitRegister, and ncu_opt_tester::target.

Referenced by applyGateCSwap().

Here is the caller graph for this function:

applyGateCX() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateCX ( const std::size_t  control, const std::size_t  target  )

inlineinherited

Apply Controlled Pauli-X (CNOT) on target qubit.

Parameters

control	Qubit index acting as control
target	Qubit index acting as target

Definition at line 264 of file Simulator.hpp.

                                                                         {
            static_cast<DerivedType*>(this)->applyGateCX(control, target);
        }

applyGateCX() [2/2]

void QNLP::IntelSimulator::applyGateCX ( CST  control, CST  target  )

inline

Apply Controlled Pauli-X (CNOT) on target qubit.

Parameters

control	Qubit index acting as control
target	Qubit index acting as target

Definition at line 442 of file IntelSimulator.cpp.

                                                    {
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyCPauliX(control, target);
        #endif

        gate_count_2qubit++;

        #ifdef GATE_LOGGING
        writer.twoQubitGateCall( "X", getGateX().tostr(), control, target );
        #endif
    }

References gate_count_2qubit, getGateX(), qubitRegister, and ncu_opt_tester::target.

Referenced by applyGateCSwap().

Here is the call graph for this function:

Here is the caller graph for this function:

applyGateCY() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateCY ( const std::size_t  control, const std::size_t  target  )

inlineinherited

Apply Controlled Pauli-Y on target qubit.

Parameters

control	Qubit index acting as control
target	Qubit index acting as target

Definition at line 274 of file Simulator.hpp.

                                                                         {
            static_cast<DerivedType*>(this)->applyGateCY(control, target);
        }

applyGateCY() [2/2]

void QNLP::IntelSimulator::applyGateCY ( CST  control, CST  target  )

inline

Apply Controlled Pauli-Y on target qubit.

Parameters

control	Qubit index acting as control
target	Qubit index acting as target

Definition at line 460 of file IntelSimulator.cpp.

                                                    {
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyCPauliY(control, target);
        #endif

        gate_count_2qubit++;

        #ifdef GATE_LOGGING
        writer.twoQubitGateCall( "Y", getGateY().tostr(), control, target );
        #endif
    }

References gate_count_2qubit, getGateY(), qubitRegister, and ncu_opt_tester::target.

Here is the call graph for this function:

applyGateCZ() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateCZ ( const std::size_t  control, const std::size_t  target  )

inlineinherited

Apply Controlled Pauli-Z on target qubit.

Parameters

control	Qubit index acting as control
target	Qubit index acting as target

Definition at line 284 of file Simulator.hpp.

                                                                         {
            static_cast<DerivedType*>(this)->applyGateCZ(control, target);
        }

applyGateCZ() [2/2]

void QNLP::IntelSimulator::applyGateCZ ( CST  control, CST  target  )

inline

Apply Controlled Pauli-Z on target qubit.

Parameters

control	Qubit index acting as control
target	Qubit index acting as target

Definition at line 478 of file IntelSimulator.cpp.

                                                    {
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyCPauliZ(control, target);
        #endif

        gate_count_2qubit++;

        #ifdef GATE_LOGGING
        writer.twoQubitGateCall( "Z", getGateZ().tostr(), control, target );
        #endif
    }

References gate_count_2qubit, getGateZ(), qubitRegister, and ncu_opt_tester::target.

Here is the call graph for this function:

applyGateH() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateH ( std::size_t  qubit_idx )

inlineinherited

Apply the Hadamard gate to the given qubit.

Parameters

qubit_idx

Definition at line 155 of file Simulator.hpp.

                                            {
            static_cast<DerivedType&>(*this).applyGateH(qubit_idx);
        }

applyGateH() [2/2]

void QNLP::IntelSimulator::applyGateH ( CST  qubitIndex )

inline

Apply the Hadamard gate to the given qubit.

Parameters

qubitIndex

Definition at line 287 of file IntelSimulator.cpp.

                                          { 
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyHadamard(qubitIndex);
        #endif

        gate_count_1qubit++;

        #ifdef GATE_LOGGING
        writer.oneQubitGateCall("H", getGateH().tostr(), qubitIndex);
        #endif
    }

References gate_count_1qubit, getGateH(), and qubitRegister.

Here is the call graph for this function:

applyGateI()

void QNLP::IntelSimulator::applyGateI ( std::size_t  qubitIndex )

inline

Apply the Identity gate to the given qubit.

Parameters

qubitIndex

Definition at line 138 of file IntelSimulator.cpp.

                                                {
        #ifndef RESOURCE_ESTIMATE
        applyGateU(getGateI(), qubitIndex, "I");
        #endif

        gate_count_1qubit++;

        #ifdef GATE_LOGGING
        writer.oneQubitGateCall("I", getGateI().tostr(), qubitIndex);
        #endif
    }

References applyGateU(), gate_count_1qubit, and getGateI().

Here is the call graph for this function:

applyGateNCU() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateNCU ( const Mat2x2Type &  U, const std::vector< std::size_t > &  ctrlIndices, std::size_t  target, std::string  label  )

inlineinherited

Apply n-control unitary gate to the given qubit target.

Template Parameters

Mat2x2Type

2x2 Matrix type of unitary gate in the format expected by the derived simulator object; decltype(simulator.getGateX()) can be used in template

Parameters

U	2x2 unitary matrix
ctrlIndices	Vector of the control lines for NCU operation
target	Target qubit index to apply nCU
label	Gate label string (U, X, Y, etc.)

Definition at line 462 of file Simulator.hpp.

                                                                                                                          {
            #if defined(__INTEL_COMPILER) || defined(__INTEL_LLVM_COMPILER)
            std::experimental::any_cast<NCU<DerivedType>&>(sim_ncu).applyNQubitControl(static_cast<DerivedType&>(*this), ctrlIndices, {}, target, label, U, 0);
            #else
            std::any_cast<NCU<DerivedType>&>(sim_ncu).applyNQubitControl(static_cast<DerivedType&>(*this), ctrlIndices, {}, target, label, U, 0);
            #endif
        }

applyGateNCU() [2/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateNCU ( const Mat2x2Type &  U, const std::vector< std::size_t > &  ctrlIndices, const std::vector< std::size_t > &  auxIndices, std::size_t  target, std::string  label  )

inlineinherited

Apply n-control sigma_x gate to the given qubit target, using auxiliary qubits for 5CX optimisation.

Template Parameters

Mat2x2Type

2x2 Matrix type of unitary gate in the format expected by the derived simulator object; decltype(simulator.getGateX()) can be used in template

Parameters

U	2x2 unitary matrix
minIdx	Lowest index of the control lines expected for nCU
maxIdx	Highest index of the control lines expected for the nCU
target	Target qubit index to apply nCU

Definition at line 480 of file Simulator.hpp.

                                                                                                                                                                  {
            #if defined(__INTEL_COMPILER) || defined(__INTEL_LLVM_COMPILER)
            std::experimental::any_cast<NCU<DerivedType>&>(sim_ncu).applyNQubitControl(static_cast<DerivedType&>(*this), ctrlIndices, auxIndices, target, label, U, 0);
            #else
            std::any_cast<NCU<DerivedType>&>(sim_ncu).applyNQubitControl(static_cast<DerivedType&>(*this), ctrlIndices, auxIndices, target, label, U, 0);
            #endif
        }

applyGatePhaseShift() [1/2]

void QNLP::IntelSimulator::applyGatePhaseShift ( std::size_t  qubit_idx, double  angle  )

inline

Apply phase shift to given Qubit; [[1 0] [0 exp(i*angle)]].

Parameters

qubit_idx	Qubit index to perform phase shift upon
angle	Angle of phase shift in rads

Definition at line 156 of file IntelSimulator.cpp.

                                                                      {
        //Phase gate is identity with 1,1 index modulated by angle
        TMDP U(gates[3]);
        U(1, 1) = ComplexDP(cos(angle), sin(angle));

        #ifndef RESOURCE_ESTIMATE
        applyGateU(U, qubit_idx, "Phase:=" + std::to_string(angle));
        #endif

        gate_count_1qubit++;

        #ifdef GATE_LOGGING
        writer.oneQubitGateCall("PShift(theta=" + std::to_string(angle) + ")", U.tostr(), qubitIndex);
        #endif

    }

References applyGateU(), gate_count_1qubit, and gates.

Here is the call graph for this function:

applyGatePhaseShift() [2/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGatePhaseShift ( double  angle, std::size_t  qubit_idx  )

inlineinherited

Apply phase shift to given Qubit; [[1 0] [0 exp(i*angle)]].

Parameters

angle	Angle of phase shift in rads
qubit_idx	Qubit index to perform phase shift upon

Definition at line 324 of file Simulator.hpp.

                                                                   {
            static_cast<DerivedType*>(this)->applyGatePhaseShift(angle, qubit_idx);
        }

applyGateRotX() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateRotX ( std::size_t  qubit_idx, double  angle_rad  )

inlineinherited

Apply the given Rotation about X-axis to the given qubit.

Parameters

qubit_idx	Index of qubit to rotate about X-axis
angle_rad	Rotation angle

Definition at line 172 of file Simulator.hpp.

                                                                 {
            static_cast<DerivedType&>(*this).applyGateRotX(qubit_idx, angle_rad);
        }

applyGateRotX() [2/2]

void QNLP::IntelSimulator::applyGateRotX ( CST  qubitIndex, double  angle  )

inline

Apply the given Rotation about X-axis to the given qubit.

Parameters

qubitIndex	Index of qubit to rotate about X-axis
angle	Rotation angle

Definition at line 326 of file IntelSimulator.cpp.

                                                            {
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyRotationX(qubitIndex, angle);
        #endif

        gate_count_1qubit++;

        #ifdef GATE_LOGGING
        writer.oneQubitGateCall(
            "R_X(\\theta=" + std::to_string(angle) + ")", 
            getGateI().tostr(), 
            qubitIndex
        );
        #endif
    };

References gate_count_1qubit, getGateI(), and qubitRegister.

Here is the call graph for this function:

applyGateRotY() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateRotY ( std::size_t  qubit_idx, double  angle_rad  )

inlineinherited

Apply the given Rotation about Y-axis to the given qubit.

Parameters

qubit_idx	Index of qubit to rotate about Y-axis
angle_rad	Rotation angle

Definition at line 181 of file Simulator.hpp.

                                                                 {
            static_cast<DerivedType&>(*this).applyGateRotY(qubit_idx, angle_rad);
        }

applyGateRotY() [2/2]

void QNLP::IntelSimulator::applyGateRotY ( CST  qubitIndex, double  angle  )

inline

Apply the given Rotation about Y-axis to the given qubit.

Parameters

qubitIndex	Index of qubit to rotate about X-axis
angle	Rotation angle

Definition at line 348 of file IntelSimulator.cpp.

                                                            {
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyRotationY(qubitIndex, angle);
        #endif

        gate_count_1qubit++;

        #ifdef GATE_LOGGING
        writer.oneQubitGateCall(
            "R_Y(\\theta=" + std::to_string(angle) + ")", 
            getGateI().tostr(), 
            qubitIndex
        );
        #endif
    };

References gate_count_1qubit, getGateI(), and qubitRegister.

Here is the call graph for this function:

applyGateRotZ() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateRotZ ( std::size_t  qubit_idx, double  angle_rad  )

inlineinherited

Apply the given Rotation about Z-axis to the given qubit.

Parameters

qubit_idx	Index of qubit to rotate about Z-axis
angle_rad	Rotation angle

Definition at line 190 of file Simulator.hpp.

                                                                 {
            static_cast<DerivedType&>(*this).applyGateRotZ(qubit_idx, angle_rad);
        }

applyGateRotZ() [2/2]

void QNLP::IntelSimulator::applyGateRotZ ( CST  qubitIndex, double  angle  )

inline

Apply the given Rotation about Z-axis to the given qubit.

Parameters

qubitIndex	Index of qubit to rotate about X-axis
angle	Rotation angle

Definition at line 370 of file IntelSimulator.cpp.

                                                            {
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyRotationZ(qubitIndex, angle);
        #endif

        gate_count_1qubit++;

        #ifdef GATE_LOGGING
        writer.oneQubitGateCall(
            "R_Z(\\theta=" + std::to_string(angle) + ")", 
            getGateI().tostr(), 
            qubitIndex
        );
        #endif
    };

References gate_count_1qubit, getGateI(), and qubitRegister.

Here is the call graph for this function:

applyGateSqrtSwap()

void QNLP::IntelSimulator::applyGateSqrtSwap ( std::size_t  qubit_idx0, std::size_t  qubit_idx1  )

inline

Performs Sqrt SWAP gate between two given qubits (half way SWAP)

Parameters

qubit_idx0	Qubit index 0
qubit_idx1	Qubit index 1

Definition at line 180 of file IntelSimulator.cpp.

                                                                               {    
        std::cerr << "NOT YET IMPLEMENTED" << std::endl; 
        std::abort();
    }

applyGateSqrtX() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateSqrtX ( std::size_t  qubit_idx )

inlineinherited

Apply the Sqrt{Pauli X} gate to the given qubit.

Parameters

qubit_idx

Definition at line 163 of file Simulator.hpp.

                                                {
            static_cast<DerivedType&>(*this).applyGateSqrtX(qubit_idx);
        }

applyGateSqrtX() [2/2]

void QNLP::IntelSimulator::applyGateSqrtX ( CST  qubitIndex )

inline

Apply the Sqrt{Pauli X} gate to the given qubit.

Parameters

qubit_idx

Definition at line 304 of file IntelSimulator.cpp.

                                             {
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyPauliSqrtX(qubitIndex);
        #endif

        gate_count_1qubit++;

        #ifdef GATE_LOGGING
        writer.oneQubitGateCall(
            "\\sqrt[2]{X}", 
            matrixSqrt<decltype(getGateX())>(getGateX()).tostr(), 
            qubitIndex
        );
        #endif
    };

References gate_count_1qubit, getGateX(), QNLP::SimulatorGeneral< IntelSimulator >::matrixSqrt(), and qubitRegister.

Here is the call graph for this function:

applyGateSwap() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateSwap ( std::size_t  qubit_idx0, std::size_t  qubit_idx1  )

inlineinherited

Swap the qubits at the given indices.

Parameters

qubit_idx0	Index of qubit 0 to swap &(0 -> 1)
qubit_idx1	Index of qubit 1 to swap &(1 -> 0)

Definition at line 304 of file Simulator.hpp.

                                                                      {
            static_cast<DerivedType*>(this)->applyGateSwap(qubit_idx0,qubit_idx1);
        }

applyGateSwap() [2/2]

void QNLP::IntelSimulator::applyGateSwap ( CST  qubit_idx0, CST  qubit_idx1  )

inline

Swap the qubits at the given indices.

Parameters

qubit_idx0	Index of qubit 0 to swap &(0 -> 1)
qubit_idx1	Index of qubit 1 to swap &(1 -> 0)

Definition at line 593 of file IntelSimulator.cpp.

                                                             {
        qubitRegister.ApplySwap(qubit_idx0, qubit_idx1);
        #ifdef GATE_LOGGING
        writer.twoQubitGateCall( "SWAP", getGateI().tostr(), qubit_idx0, qubit_idx1 );
        #endif
    }

References getGateI(), and qubitRegister.

Here is the call graph for this function:

applyGateU() [1/2]

void QNLP::IntelSimulator::applyGateU ( const TMDP &  U, CST  qubitIndex, std::string  label = "U"  )

inline

Apply arbitrary user-defined unitary gate to qubit at qubit_idx.

Parameters

U	User-defined unitary 2x2 matrix of templated type Mat2x2Type
qubitIndex	Index of qubit to apply gate upon
label	Label for the gate U

Definition at line 121 of file IntelSimulator.cpp.

                                                                              {
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.Apply1QubitGate(qubitIndex, U);
        #endif

        gate_count_1qubit++;

        #ifdef GATE_LOGGING
        writer.oneQubitGateCall(label, U.tostr(), qubitIndex);
        #endif
    }

References gate_count_1qubit, and qubitRegister.

Referenced by applyGateI(), and applyGatePhaseShift().

Here is the caller graph for this function:

applyGateU() [2/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateU ( const Mat2x2Type &  U, std::size_t  qubit_idx  )

inlineinherited

Apply arbitrary user-defined unitary gate to qubit at qubit_idx.

Parameters

U	User-defined unitary 2x2 matrix of templated type Mat2x2Type
qubit_idx	Index of qubit to apply gate upon

Definition at line 201 of file Simulator.hpp.

                                                                 {
            static_cast<DerivedType*>(this)->applyGateU(U, qubit_idx);
        }

applyGateX() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateX ( std::size_t  qubit_idx )

inlineinherited

Apply the Pauli X gate to the given qubit.

Parameters

qubit_idx

Definition at line 123 of file Simulator.hpp.

                                            { 
            static_cast<DerivedType&>(*this).applyGateX(qubit_idx);
        };

applyGateX() [2/2]

void QNLP::IntelSimulator::applyGateX ( CST  qubitIndex )

inline

Apply the Pauli X gate to the given qubit.

Parameters

qubitIndex

Definition at line 236 of file IntelSimulator.cpp.

                                          {
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyPauliX(qubitIndex);
        #endif

        gate_count_1qubit++;

        #ifdef GATE_LOGGING
        writer.oneQubitGateCall("X", getGateX().tostr(), qubitIndex);
        #endif
    }

References gate_count_1qubit, getGateX(), and qubitRegister.

Here is the call graph for this function:

applyGateY() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateY ( std::size_t  qubit_idx )

inlineinherited

Apply the Pauli Y gate to the given qubit.

Parameters

qubit_idx

Definition at line 131 of file Simulator.hpp.

                                            {
            static_cast<DerivedType&>(*this).applyGateY(qubit_idx);
        }

applyGateY() [2/2]

void QNLP::IntelSimulator::applyGateY ( CST  qubitIndex )

inline

Apply the Pauli Y gate to the given qubit.

Parameters

qubitIndex

Definition at line 253 of file IntelSimulator.cpp.

                                          { 
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyPauliY(qubitIndex);
        #endif

        gate_count_1qubit++;

        #ifdef GATE_LOGGING
        writer.oneQubitGateCall("Y", getGateY().tostr(), qubitIndex);
        #endif
    }

References gate_count_1qubit, getGateY(), and qubitRegister.

Here is the call graph for this function:

applyGateZ() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyGateZ ( std::size_t  qubit_idx )

inlineinherited

Apply the Pauli Z gate to the given qubit.

Parameters

qubit_idx

Definition at line 139 of file Simulator.hpp.

                                            {
            static_cast<DerivedType&>(*this).applyGateZ(qubit_idx);
        }

applyGateZ() [2/2]

void QNLP::IntelSimulator::applyGateZ ( CST  qubitIndex )

inline

Apply the Pauli Z gate to the given qubit.

Parameters

qubitIndex

Definition at line 270 of file IntelSimulator.cpp.

                                          { 
        #ifndef RESOURCE_ESTIMATE
        qubitRegister.ApplyPauliZ(qubitIndex);
        #endif

        gate_count_1qubit++;

        #ifdef GATE_LOGGING
        writer.oneQubitGateCall("Z", getGateZ().tostr(), qubitIndex);
        #endif
    }

References gate_count_1qubit, getGateZ(), and qubitRegister.

Here is the call graph for this function:

applyHammingDistanceOverwrite()

void QNLP::SimulatorGeneral< IntelSimulator >::applyHammingDistanceOverwrite ( std::size_t  test_pattern, const std::vector< std::size_t >  reg_mem, const std::vector< std::size_t >  reg_auxiliary, std::size_t  len_bin_pattern  )

inlineinherited

Computes the relative Hamming distance between the test pattern and the pattern stored in each state of the superposition, overwriting the aux register pattern with the resulting bit differences.

Parameters

test_pattern	The binary pattern used as the the basis for the Hamming Distance.
reg_mem	Vector containing the indices of the register qubits that contain the training patterns.
reg_auxiliary	Vector containing the indices of the register qubits which the first len_bin_pattern qubits will store the test_pattern.

Definition at line 609 of file Simulator.hpp.

                                          {

            assert(reg_mem.size() < reg_auxiliary.size()-1);

            // Encode test pattern to auxiliary register
            encodeToRegister(test_pattern, reg_auxiliary, len_bin_pattern);

            HammingDistance<DerivedType>::computeHammingDistanceOverwriteAux(static_cast<DerivedType&>(*this), reg_mem, reg_auxiliary);
        }

applyHammingDistanceRotY()

void QNLP::SimulatorGeneral< IntelSimulator >::applyHammingDistanceRotY ( std::size_t  test_pattern, const std::vector< std::size_t >  reg_mem, const std::vector< std::size_t >  reg_auxiliary, std::size_t  len_bin_pattern  )

inlineinherited

Computes the relative Hamming distance between the test pattern and the pattern stored in each state of the superposition, storing the result in the amplitude of the corresponding state.

Parameters

test_pattern	The binary pattern used as the the basis for the Hamming Distance.
reg_mem	Vector containing the indices of the register qubits that contain the training patterns.
reg_auxiliary	Vector containing the indices of the register qubits which the first len_bin_pattern qubits will store the test_pattern.
len_bin_pattern	Length of the binary patterns

Definition at line 584 of file Simulator.hpp.

                                          {

            assert(len_bin_pattern < reg_auxiliary.size()-1);

            // Encode test pattern to auxiliary register
            encodeToRegister(test_pattern, reg_auxiliary, len_bin_pattern);

            HammingDistance<DerivedType> hamming_operator(len_bin_pattern);
            hamming_operator.computeHammingDistanceRotY(static_cast<DerivedType&>(*this), reg_mem, reg_auxiliary, len_bin_pattern);

            // Un-encode test pattern from auxiliary register
            encodeToRegister(test_pattern, reg_auxiliary, len_bin_pattern);
        }

applyIQFT()

void QNLP::SimulatorGeneral< IntelSimulator >::applyIQFT ( std::size_t  minIdx, std::size_t  maxIdx  )

inlineinherited

Apply the inverse Quantum Fourier transform (IQFT) to the given register index range.

Parameters

minIdx	Lowest qubit index of the IQFT range
maxIdx	Highest qubit index of the IQFT range

Definition at line 433 of file Simulator.hpp.

                                                          {
            QFT<decltype(static_cast<DerivedType&>(*this))>::applyIQFT(static_cast<DerivedType&>(*this), minIdx, maxIdx);
        }

applyMeasurement() [1/2]

bool QNLP::SimulatorGeneral< IntelSimulator >::applyMeasurement ( std::size_t  target, bool  normalize = true  )

inlineinherited

Apply measurement to a target qubit, randomly collapsing the qubit proportional to the amplitude and returns the collapsed value.

Returns

bool Value that qubit is randomly collapsed to

Parameters

target	The index of the qubit being collapsed
normalize	Optional argument specifying whether amplitudes shoud be normalized (true) or not (false). Default value is true.

Definition at line 629 of file Simulator.hpp.

                                                                    {
            return static_cast<DerivedType*>(this)->applyMeasurement(target, normalize);
        }

applyMeasurement() [2/2]

bool QNLP::IntelSimulator::applyMeasurement ( CST  target, bool  normalize = true  )

inline

Apply measurement to a target qubit, randomly collapsing the qubit proportional to the amplitude and returns the collapsed value. If built with MPI enabled, this member function collpases the corresponding qubit in each state across all processes.

Returns

bool Value that qubit is randomly collapsed to

Parameters

target	The index of the qubit being collapsed
normalize	Optional argument specifying whether amplitudes should be normalized (true) or not (false). Default value is true.

Definition at line 653 of file IntelSimulator.cpp.

                                                          {
        double rand;
        bool bit_val;

        #ifdef ENABLE_MPI
            if(rank == 0){
                rand = dist(mt);
            }
            MPI_Bcast(&rand, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
            MPI_Barrier(MPI_COMM_WORLD);
        #else
            rand = dist(mt);
        #endif
        collapseQubit(target, (bit_val = ( rand < getStateProbability(target) ) ) );
        if(normalize){
            applyAmplitudeNorm();
        }
        return bit_val;
    }

References applyAmplitudeNorm(), collapseQubit(), dist, getStateProbability(), mt, ncu_opt_tester::rank, and ncu_opt_tester::target.

Here is the call graph for this function:

applyMeasurementToRegister()

std::size_t QNLP::SimulatorGeneral< IntelSimulator >::applyMeasurementToRegister ( std::vector< std::size_t >  target_qubits, bool  normalize = true  )

inlineinherited

Apply measurement to a set of target qubits, randomly collapsing the qubits proportional to the amplitude and returns the bit string of the qubits in the order they are represented in the vector of indexes, in the form of an unsigned integer.

Returns

std::size_t Integer representing the binary string of the collapsed qubits, ordered by least significant digit corresponding to first qubit in target vector of indices

Parameters

target_qubits	Vector of indices of qubits being collapsed
normalize	Optional argument specifying whether amplitudes shoud be normalized (true) or not (false). Default value is true.

Definition at line 640 of file Simulator.hpp.

                                                                                                     {
            // Store current state of training register in it's integer format
            std::size_t val = 0; 
            for(int j = target_qubits.size() - 1; j > -1; j--){
                val |= (static_cast<DerivedType*>(this)->applyMeasurement(target_qubits[j], normalize) << j);
            } 
            return val;
        }

applyOraclePhase()

void QNLP::SimulatorGeneral< IntelSimulator >::applyOraclePhase ( std::size_t  bit_pattern, const std::vector< std::size_t > &  ctrlIndices, std::size_t  target  )

inlineinherited

Apply oracle to match given binary index with linearly adjacent controls.

Parameters

bit_pattern	Oracle pattern in binary
ctrlIndices	Control lines for oracle
target	Target qubit index to apply Z gate upon

Definition at line 524 of file Simulator.hpp.

                                                                                                               {
            //applyOracleU<decltype(static_cast<DerivedType*>(this)->getGateZ())>(bit_pattern, ctrlIndices, target, static_cast<DerivedType*>(this)->getGateZ());
            Oracle<DerivedType> oracle;
            oracle.bitStringPhaseOracle(static_cast<DerivedType&>(*this), bit_pattern, ctrlIndices, target );
        }

applyOracleU() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyOracleU ( std::size_t  bit_pattern, const std::vector< std::size_t > &  ctrlIndices, std::size_t  target, const Mat2x2Type &  U, std::string  gateLabel  )

inlineinherited

Apply oracle to match given binary index with non adjacent controls.

Parameters

bit_pattern	Oracle state pattern (bitstring: 0-> |0>, 1-> |1>)
U	2x2 unitary matrix to apply
ctrlIndices	Control indices for operation
target	Target qubit index to apply U on
gateLabel	Label used to access required cached matrix for NCU

Definition at line 498 of file Simulator.hpp.

                                                                                                                                                      {
            Oracle<DerivedType>::bitStringNCU(static_cast<DerivedType&>(*this), bit_pattern, ctrlIndices, target, U, gateLabel);
        }

applyOracleU() [2/2]

void QNLP::SimulatorGeneral< IntelSimulator >::applyOracleU ( std::size_t  bit_pattern, const std::vector< std::size_t > &  ctrlIndices, const std::vector< std::size_t > &  auxIndices, std::size_t  target, const Mat2x2Type &  U, std::string  gateLabel  )

inlineinherited

Apply oracle to match given binary index with non adjacent controls.

Parameters

bit_pattern	Oracle state pattern (bitstring: 0-> |0>, 1-> |1>)
U	2x2 unitary matrix to apply
ctrlIndices	Control indices for operation
auxIndices	Auxiliary indices for operation
target	Target qubit index to apply U on
gateLabel	Label used to access required cached matrix for NCU

Definition at line 513 of file Simulator.hpp.

                                                                                                                                                                                              {
            Oracle<DerivedType>::bitStringNCU(static_cast<DerivedType&>(*this), bit_pattern, ctrlIndices, auxIndices, target, U, gateLabel);
        }

applyQFT()

void QNLP::SimulatorGeneral< IntelSimulator >::applyQFT ( std::size_t  minIdx, std::size_t  maxIdx  )

inlineinherited

Apply the forward Quantum Fourier transform (QFT) to the given register index range.

Parameters

minIdx	Lowest qubit index of the QFT range
maxIdx	Highest qubit index of the QFT range

Definition at line 423 of file Simulator.hpp.

                                                         {
            QFT<decltype(static_cast<DerivedType&>(*this))>::applyQFT(static_cast<DerivedType&>(*this), minIdx, maxIdx);
        }

collapseQubit()

void QNLP::IntelSimulator::collapseQubit ( CST  target, bool  collapseValue  )

inlineprivate

Collapses specified qubit in register to the collapseValue without applying normalization.

Parameters

target	Index of qubit to be collapsed
collapseValue	Value qubit is collapsed to (0 or 1)

Definition at line 758 of file IntelSimulator.cpp.

                                                             {
        qubitRegister.CollapseQubit(target, collapseValue);
    }

References qubitRegister, and ncu_opt_tester::target.

Referenced by applyMeasurement(), and collapseToBasisZ().

Here is the caller graph for this function:

collapseToBasisZ() [1/2]

void QNLP::SimulatorGeneral< IntelSimulator >::collapseToBasisZ ( std::size_t  target, bool  collapseValue  )

inlineinherited

Apply measurement to a target qubit with respect to the Z-basis, collapsing to a specified value (0 or 1). Amplitudes are r-normalized afterwards.

Parameters

target	The index of the qubit being collapsed
collapseValue	The value that the register will be collapsed to (either 0 ro 1).

Definition at line 671 of file Simulator.hpp.

                                                                   {
            static_cast<DerivedType*>(this)->collapseToBasisZ(target, collapseValue);
        }

collapseToBasisZ() [2/2]

void QNLP::IntelSimulator::collapseToBasisZ ( CST  target, bool  collapseValue  )

inline

Apply measurement to a target qubit with respect to the Z-basis, collapsing to a specified value (0 or 1). Amplitudes are r-normalized afterwards.

Parameters

target	The index of the qubit being collapsed
collapseValue	The value that the register will be collapsed to (either 0 ro 1).

Definition at line 679 of file IntelSimulator.cpp.

                                                         {
        collapseQubit(target, collapseValue);
        applyAmplitudeNorm();
    }

References applyAmplitudeNorm(), collapseQubit(), and ncu_opt_tester::target.

Here is the call graph for this function:

encodeBinToSuperpos_unique()

void QNLP::SimulatorGeneral< IntelSimulator >::encodeBinToSuperpos_unique ( const std::vector< std::size_t > &  reg_memory, const std::vector< std::size_t > &  reg_auxiliary, const std::vector< std::size_t > &  bin_patterns, const std::size_t  len_bin_pattern  )

inlineinherited

Encode inputted binary strings to the memory register specified as a superposition of states. Note that this implementation does not allow for multiple instances of the same input pattern but allows for 0 to be encoded.

Parameters

reg_memory	std::vector of unsigned integers containing the indices of the circuit's memory register
reg_auxiliary	std::vector of unsigned integers type containing the indices of the circuit's auxiliary register
bin_patterns	std::vector of unsigned integers representing the binary patterns to encode
len_bin_pattern	The length of the binary patterns being encoded

Definition at line 567 of file Simulator.hpp.

                                                {

            EncodeBinIntoSuperpos<DerivedType> encoder(bin_patterns.size(), len_bin_pattern);
            encoder.encodeBinInToSuperpos_unique(static_cast<DerivedType&>(*this), reg_memory, reg_auxiliary, bin_patterns);
        }

encodeToRegister()

void QNLP::SimulatorGeneral< IntelSimulator >::encodeToRegister ( std::size_t  target_pattern, const std::vector< std::size_t >  target_register, std::size_t  len_bin_pattern  )

inlineinherited

Encodes a defined binary pattern into a defined target register (initially in state |00...0>) of all quantum states in the superposition.

Parameters

target_pattern	The binary pattern that is to be encoded
target_register	Vector containing the indices of the register qubits that the pattern is to be encoded into (beginning at least significant digit). Note, the target register is expected to be in the state consisting of all 0's before the encoding.
Length	of the binary pattern to be encoded

Definition at line 548 of file Simulator.hpp.

                                          {

            for(std::size_t i = 0; i < len_bin_pattern; i++){
                if(IS_SET(target_pattern,i)){
                    applyGateX(target_register[i]);
                }
            }
        }

getGateCounts()

std::pair<std::size_t, std::size_t> QNLP::IntelSimulator::getGateCounts ( )

inline

Print 1 and 2 qubit gate call counts.

Definition at line 709 of file IntelSimulator.cpp.

                                                 {
        std::cout << "######### Gate counts #########" << std::endl;
        std::cout << "1 qubit = " << gate_count_1qubit << std::endl;
        std::cout << "2 qubit = " << gate_count_2qubit << std::endl;
        std::cout << "total = " << gate_count_1qubit + gate_count_2qubit << std::endl;
        std::cout << "###############################" << std::endl;
        return std::make_pair(gate_count_1qubit, gate_count_2qubit);
    }

References gate_count_1qubit, and gate_count_2qubit.

getGateH()

TMDP QNLP::IntelSimulator::getGateH ( )

inline

Get the Hadamard gate.

Returns

TMDP return type of Hadamard gate

Definition at line 414 of file IntelSimulator.cpp.

{ return gates[4]; }

References gates.

Referenced by applyGateCH(), and applyGateH().

Here is the caller graph for this function:

getGateI()

TMDP QNLP::IntelSimulator::getGateI ( )

inline

Get the Identity.

Returns

TMDP return type of the Identity

Definition at line 408 of file IntelSimulator.cpp.

{ return gates[3]; }

References gates.

Referenced by applyGateCRotX(), applyGateCRotY(), applyGateCRotZ(), applyGateI(), applyGateRotX(), applyGateRotY(), applyGateRotZ(), and applyGateSwap().

Here is the caller graph for this function:

getGateX()

TMDP QNLP::IntelSimulator::getGateX ( )

inline

Get the Pauli-X gate.

Returns

TMDP return type of Pauli-X gate

Definition at line 390 of file IntelSimulator.cpp.

{ return gates[0]; }

References gates.

Referenced by applyGateCCX(), applyGateCX(), applyGateSqrtX(), and applyGateX().

Here is the caller graph for this function:

getGateY()

TMDP QNLP::IntelSimulator::getGateY ( )

inline

Get the Pauli-Y gate.

Returns

TMDP return type of Pauli-Y gate

Definition at line 396 of file IntelSimulator.cpp.

{ return gates[1]; }

References gates.

Referenced by applyGateCY(), and applyGateY().

Here is the caller graph for this function:

getGateZ()

TMDP QNLP::IntelSimulator::getGateZ ( )

inline

Get the Pauli-Z gate.

Returns

TMDP return type of Pauli-Z gate

Definition at line 402 of file IntelSimulator.cpp.

{ return gates[2]; }

References gates.

Referenced by applyGateCZ(), and applyGateZ().

Here is the caller graph for this function:

getNumQubits()

std::size_t QNLP::IntelSimulator::getNumQubits ( )

inline

Get the number of Qubits.

Returns

std::size_t Number of qubits in register

Definition at line 623 of file IntelSimulator.cpp.

                             { 
        return numQubits; 
    }

References numQubits.

Referenced by TEST_CASE().

Here is the caller graph for this function:

getQubitRegister() [1/2]

QubitRegister<ComplexDP>& QNLP::IntelSimulator::getQubitRegister ( )

inline

Get the Qubit Register object.

Returns

QubitRegister<ComplexDP>& Returns a refernce to the Qubit Register object

Definition at line 605 of file IntelSimulator.cpp.

                                                        { 
        return this->qubitRegister; 
    }

References qubitRegister.

Referenced by TEST_CASE().

Here is the caller graph for this function:

getQubitRegister() [2/2]

const QubitRegister<ComplexDP>& QNLP::IntelSimulator::getQubitRegister ( ) const

inline

Get the Qubit Register object.

Returns

const QubitRegister<ComplexDP>& Returns a refernce to the Qubit Register object

Definition at line 614 of file IntelSimulator.cpp.

                                                                    { 
        return this->qubitRegister; 
    };

References qubitRegister.

getStateProbability()

double QNLP::IntelSimulator::getStateProbability ( CST  target )

inlineprivate

Get the probability of the specified qubit being in the state |1>

Parameters

target

Target qubit

Returns

double Probability that the target qubit is in the state |1>

Definition at line 768 of file IntelSimulator.cpp.

                                                 {
        return qubitRegister.GetProbability(target);
    }

References qubitRegister, and ncu_opt_tester::target.

Referenced by applyMeasurement().

Here is the caller graph for this function:

groupQubits()

void QNLP::SimulatorGeneral< IntelSimulator >::groupQubits ( const std::vector< std::size_t >  reg_auxiliary, bool  lsb = true  )

inlineinherited

Group all set qubits to MSB in register (ie |010100> -> |000011>)

Parameters

reg_mem	The indices of the qubits to perform operation upon
reg_auxiliary	The auxiliary control qubit register set to |......10> at the beginning, and guaranteed to be set the same at end.
lsb	Shifts to LSB position in register if true; MSB otherwise.

Definition at line 656 of file Simulator.hpp.

                                                                                 {
            assert( reg_auxiliary.size() >= 2);

            const std::vector<std::size_t> reg_ctrl ( reg_auxiliary.end()-2, reg_auxiliary.end() );
            const std::vector<std::size_t> sub_reg (reg_auxiliary.begin(), reg_auxiliary.end()-2 ) ;

            BitGroup<DerivedType>::bit_group(static_cast<DerivedType&>(*this), sub_reg, reg_ctrl, lsb);
        }

initCaches()

void QNLP::SimulatorGeneral< IntelSimulator >::initCaches ( )

inlineinherited

Initialise caches used in NCU operation.

Definition at line 687 of file Simulator.hpp.

                         {
            #if defined(__INTEL_COMPILER) || defined(__INTEL_LLVM_COMPILER)
            std::experimental::any_cast<NCU<DerivedType>&>(sim_ncu).initialiseMaps(static_cast<DerivedType&>(*this), 16);
            #else
            std::any_cast<NCU<DerivedType>&>(sim_ncu).initialiseMaps(static_cast<DerivedType&>(*this), 16);
            #endif
        }

initRegister()

void QNLP::IntelSimulator::initRegister ( )

inline

(Re)Initialise the underlying register of the encapsulated simulator to well-defined state (|0....0>)

Definition at line 631 of file IntelSimulator.cpp.

                       {
        this->qubitRegister.Initialize("base",0);
        this->initCaches();
        gate_count_1qubit = 0;
        gate_count_2qubit = 0;
    }

References gate_count_1qubit, gate_count_2qubit, QNLP::SimulatorGeneral< IntelSimulator >::initCaches(), and qubitRegister.

Here is the call graph for this function:

InvertRegister()

void QNLP::SimulatorGeneral< IntelSimulator >::InvertRegister ( const unsigned int  minIdx, const unsigned int  maxIdx  )

inlineinherited

Invert the register about the given indides: 0,1,2...n-1,n -> n,n-1,...,1,0.

Parameters

minIdx	The lower index of the inversion
maxIdx	The upper index of the inversion

Definition at line 776 of file Simulator.hpp.

                                                                                 {
            unsigned int range2 = ((maxIdx - minIdx)%2 == 1) ? (maxIdx - minIdx)/2 +1 : (maxIdx - minIdx)/2;
            for(unsigned int idx = 0; idx < range2; idx++){
                applyGateSwap(minIdx+idx, maxIdx-idx);
            }
        }

matrixSqrt()

Mat2x2Type QNLP::SimulatorGeneral< IntelSimulator >::matrixSqrt ( const Mat2x2Type &  U )

inlineinherited

Calculates the unitary matrix square root (U == VV, where V is returned)

Template Parameters

Mat2x2Type

Matrix type

Parameters

U	Unitary matrix to be rooted

Returns

openqu::TinyMatrix<Type, 2, 2, 32> V such that VV == U

Definition at line 729 of file Simulator.hpp.

                                                  {
            Mat2x2Type V(U);
            std::complex<double> delta = U(0,0)*U(1,1) - U(0,1)*U(1,0);
            std::complex<double> tau = U(0,0) + U(1,1);
            std::complex<double> s = sqrt(delta);
            std::complex<double> t = sqrt(tau + 2.0*s);

            //must be a way to vectorise these; TinyMatrix have a scale/shift option?
            V(0,0) += s;
            V(1,1) += s;
            std::complex<double> scale_factor(1.,0.);
            scale_factor/=t;
            V(0,0) *= scale_factor; //(std::complex<double>(1.,0.)/t);
            V(0,1) *= scale_factor; //(1/t);
            V(1,0) *= scale_factor; //(1/t);
            V(1,1) *= scale_factor; //(1/t);

            return V;
        }

overlap()

complex<double> QNLP::IntelSimulator::overlap ( IntelSimulator &  sim )

inline

Compute overlap between different simulators. Number of qubits must be the same.

Definition at line 723 of file IntelSimulator.cpp.

                                                        {
        if(sim.uid != this->uid){
            return qubitRegister.ComputeOverlap(sim.qubitRegister);
        }
        else{
            return std::numeric_limits<double>::quiet_NaN();
        }
    }

References qubitRegister, and ncu_opt_tester::sim.

PrintStates()

void QNLP::IntelSimulator::PrintStates ( std::string  x, std::vector< std::size_t >  qubits = {}  )

inline

Prints the string x and then for each state of the specified qubits in the superposition, prints each its amplitude, followed by state and then by the probability of that state. Note that this state observation method is not a permitted quantum operation, however it is provided for convenience and debugging/testing.

Parameters

x	String to be printed to stdout
qubits	Indices of qubits in register to be printed

Definition at line 690 of file IntelSimulator.cpp.

                                                                       {}){
        qubitRegister.Print(x,qubits);
    }

subReg()

void QNLP::SimulatorGeneral< IntelSimulator >::subReg ( std::size_t  r0_minIdx, std::size_t  r0_maxIdx, std::size_t  r1_minIdx, std::size_t  r1_maxIdx  )

inlineinherited

Applies |r1>|r2> -> |r1>|r1-r2>

Definition at line 448 of file Simulator.hpp.

                                                                                                       {
            Arithmetic<decltype(static_cast<DerivedType&>(*this))>::sub_reg(static_cast<DerivedType&>(*this), r0_minIdx, r0_maxIdx, r1_minIdx, r1_maxIdx);
        }

sumReg()

void QNLP::SimulatorGeneral< IntelSimulator >::sumReg ( std::size_t  r0_minIdx, std::size_t  r0_maxIdx, std::size_t  r1_minIdx, std::size_t  r1_maxIdx  )

inlineinherited

Applies |r1>|r2> -> |r1>|r1+r2>

Definition at line 441 of file Simulator.hpp.

                                                                                                       {
            Arithmetic<decltype(static_cast<DerivedType&>(*this))>::sum_reg(static_cast<DerivedType&>(*this), r0_minIdx, r0_maxIdx, r1_minIdx, r1_maxIdx);
        }

Field Documentation

dist

std::uniform_real_distribution<double> QNLP::IntelSimulator::dist

private

Definition at line 748 of file IntelSimulator.cpp.

Referenced by applyMeasurement(), and IntelSimulator().

gate_count_1qubit

std::size_t QNLP::IntelSimulator::gate_count_1qubit

private

Definition at line 743 of file IntelSimulator.cpp.

Referenced by applyGateH(), applyGateI(), applyGatePhaseShift(), applyGateRotX(), applyGateRotY(), applyGateRotZ(), applyGateSqrtX(), applyGateU(), applyGateX(), applyGateY(), applyGateZ(), getGateCounts(), initRegister(), and IntelSimulator().

gate_count_2qubit

std::size_t QNLP::IntelSimulator::gate_count_2qubit

private

Definition at line 744 of file IntelSimulator.cpp.

Referenced by applyGateCH(), applyGateCPhaseShift(), applyGateCRotX(), applyGateCRotY(), applyGateCRotZ(), applyGateCU(), applyGateCX(), applyGateCY(), applyGateCZ(), getGateCounts(), initRegister(), and IntelSimulator().

gates

std::vector<TMDP> QNLP::IntelSimulator::gates

private

Definition at line 738 of file IntelSimulator.cpp.

Referenced by applyGateCPhaseShift(), applyGatePhaseShift(), getGateH(), getGateI(), getGateX(), getGateY(), getGateZ(), and IntelSimulator().

mt

std::mt19937 QNLP::IntelSimulator::mt

private

Definition at line 747 of file IntelSimulator.cpp.

Referenced by applyMeasurement(), and IntelSimulator().

numQubits

std::size_t QNLP::IntelSimulator::numQubits

private

Definition at line 736 of file IntelSimulator.cpp.

Referenced by getNumQubits().

qubitRegister

QRDP QNLP::IntelSimulator::qubitRegister

private

Definition at line 737 of file IntelSimulator.cpp.

Referenced by applyAmplitudeNorm(), applyGateCH(), applyGateCPhaseShift(), applyGateCRotX(), applyGateCRotY(), applyGateCRotZ(), applyGateCU(), applyGateCX(), applyGateCY(), applyGateCZ(), applyGateH(), applyGateRotX(), applyGateRotY(), applyGateRotZ(), applyGateSqrtX(), applyGateSwap(), applyGateU(), applyGateX(), applyGateY(), applyGateZ(), collapseQubit(), getQubitRegister(), getStateProbability(), initRegister(), IntelSimulator(), and overlap().

rd

std::random_device QNLP::IntelSimulator::rd

private

Definition at line 746 of file IntelSimulator.cpp.

Referenced by IntelSimulator().

sim_ncu

std::any QNLP::SimulatorGeneral< IntelSimulator >::sim_ncu

protectedinherited

Definition at line 104 of file Simulator.hpp.

uid

const std::size_t QNLP::IntelSimulator::uid

private

Definition at line 734 of file IntelSimulator.cpp.

---

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

• /Users/mlxd/Desktop/intel-qnlp-rc2/modules/simulator/IntelSimulator.cpp