Decoherence

	TEST_CASE ("mixDephasing", TEST_CATEGORY)
	TEST_CASE ("mixDepolarising", TEST_CATEGORY)
	TEST_CASE ("mixDamping", TEST_CATEGORY)
	TEST_CASE ("mixPaulis", TEST_CATEGORY)
	TEST_CASE ("mixTwoQubitDephasing", TEST_CATEGORY)
	TEST_CASE ("mixTwoQubitDepolarising", TEST_CATEGORY)
	TEST_CASE ("mixKrausMap", TEST_CATEGORY)
	TEST_CASE ("mixSuperOp", TEST_CATEGORY)
	TEST_CASE ("mixQureg", TEST_CATEGORY LABEL_MIXED_DEPLOY_TAG)

Detailed Description

Function Documentation

TEST_CASE() [1/9]

TEST_CASE	(	"mixDamping"	,
		TEST_CATEGORY	)

Definition at line 156 of file decoherence.cpp.

                                         {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numQubits = getNumCachedQubits();
        int targ = GENERATE_COPY( range(0,numQubits) );
        qreal prob = getRandomReal(0, 1);
 
        vector<qmatrix> kraus = {
            {{1,0},{0,std::sqrt(1-prob)}},
            {{0,std::sqrt(prob)}, {0,0}}
        };
 
        auto apiFunc = [&](Qureg qureg) { mixDamping(qureg, targ, prob); };
 
        CAPTURE( targ, prob );
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(apiFunc, {targ}, kraus); }
    }
 
    /// @todo input validation
}

TEST_CASE() [2/9]

TEST_CASE	(	"mixDephasing"	,
		TEST_CATEGORY	)

TESTS

Definition at line 108 of file decoherence.cpp.

                                           {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numQubits = getNumCachedQubits();
        int targ = GENERATE_COPY( range(0,numQubits) );
        qreal prob = getRandomReal(0, 1/2.);
 
        vector<qmatrix> kraus = {
            std::sqrt(1-prob) * getPauliMatrix(0),
            std::sqrt(prob)   * getPauliMatrix(3)
        };
 
        auto apiFunc = [&](Qureg qureg) { mixDephasing(qureg, targ, prob); };
 
        CAPTURE( targ, prob );
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(apiFunc, {targ}, kraus); }
    }
 
    /// @todo input validation
}

TEST_CASE() [3/9]

TEST_CASE	(	"mixDepolarising"	,
		TEST_CATEGORY	)

Definition at line 131 of file decoherence.cpp.

                                              {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numQubits = getNumCachedQubits();
        int targ = GENERATE_COPY( range(0,numQubits) );
        qreal prob = getRandomReal(0, 3/4.);
 
        vector<qmatrix> kraus = {
            std::sqrt(1-prob) * getPauliMatrix(0),
            std::sqrt(prob/3) * getPauliMatrix(1), 
            std::sqrt(prob/3) * getPauliMatrix(2), 
            std::sqrt(prob/3) * getPauliMatrix(3),
        };
 
        auto apiFunc = [&](Qureg qureg) { mixDepolarising(qureg, targ, prob); };
 
        CAPTURE( targ, prob );
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(apiFunc, {targ}, kraus); }
    }
 
    /// @todo input validation
}

TEST_CASE() [4/9]

TEST_CASE	(	"mixKrausMap"	,
		TEST_CATEGORY	)

Definition at line 273 of file decoherence.cpp.

                                          {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int maxFlag = TEST_MAX_NUM_SUPEROP_TARGETS;
        int numQubits = getNumCachedQubits();
        int maxNumTargs = (maxFlag != 0 && numQubits > maxFlag)?
            maxFlag : numQubits;
 
        int numTargs = GENERATE_COPY( range(1,maxNumTargs+1) );
        int numKraus = GENERATE( 1, 2, 10 );
        auto targs = GENERATE_TARGS( numQubits, numTargs );
        auto matrices = getRandomKrausMap(numTargs, numKraus);
 
        KrausMap map = createKrausMap(numTargs, numKraus);
        setKrausMap(map, matrices);
        auto apiFunc = [&](Qureg qureg) { mixKrausMap(qureg, targs.data(), numTargs, map); };
 
        CAPTURE( maxNumTargs, targs, numKraus );
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(apiFunc, targs, matrices); }
 
        destroyKrausMap(map);
    }
 
    /// @todo input validation
}

TEST_CASE() [5/9]

TEST_CASE	(	"mixPaulis"	,
		TEST_CATEGORY	)

Definition at line 179 of file decoherence.cpp.

                                        {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numQubits = getNumCachedQubits();
        int targ = GENERATE_COPY( range(0,numQubits) );
 
        qreal pX = getRandomReal(0, 1);
        qreal pY = getRandomReal(0, 1);
        qreal pZ = getRandomReal(0, 1);
 
        // we require pX+pY+pZ <= 1
        qreal norm = pX + pY + pZ;
        pX /= norm;
        pY /= norm;
        pZ /= norm;
 
        // and max(pX,pY,pZ) <= 1-pX-pY-pZ, which we'll
        // lazily achieve with iteration (truly stinky)
        qreal pI = 1 - pX - pY - pZ;
        while (std::max({pX,pY,pZ}) > pI) {
            pX /= 1.1;
            pY /= 1.1;
            pZ /= 1.1;
            pI = 1 - pX - pY - pZ;
        }
 
        vector<qmatrix> kraus = {
            std::sqrt(pI) * getPauliMatrix(0),
            std::sqrt(pX) * getPauliMatrix(1),
            std::sqrt(pY) * getPauliMatrix(2),
            std::sqrt(pZ) * getPauliMatrix(3)
        };
 
        auto apiFunc = [&](Qureg qureg) { mixPaulis(qureg, targ, pX, pY, pZ); };
 
        CAPTURE( targ, pX, pY, pZ );
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(apiFunc, {targ}, kraus); }
    }
 
    /// @todo input validation
}

TEST_CASE() [6/9]

TEST_CASE	(	"mixQureg"	,
		TEST_CATEGORY	LABEL_MIXED_DEPLOY_TAG )

Definition at line 328 of file decoherence.cpp.

                                                              {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        qreal prob = getRandomReal(0, 1);
        auto apiFunc = [&](Qureg a, Qureg b) { mixQureg(a, b, prob); };
 
        CAPTURE( prob );
        
        GENERATE( range(0, TEST_NUM_MIXED_DEPLOYMENT_REPETITIONS) );
 
        SECTION( LABEL_DENSMATR LABEL_DELIMITER LABEL_STATEVEC ) { 
 
            auto refFunc = [&](qmatrix& a, qvector b) { a = (1-prob)*a + prob*getOuterProduct(b,b); };
            
            TEST_ON_MIXED_CACHED_QUREGS( getAltCachedStatevecs(), apiFunc, getRefStatevec(), refFunc); 
        }
 
        SECTION( LABEL_DENSMATR LABEL_DELIMITER LABEL_DENSMATR ) {
 
            auto refFunc = [&](qmatrix& a, qmatrix b) { a = (1-prob)*a + prob*b; };
 
            TEST_ON_MIXED_CACHED_QUREGS( getAltCachedDensmatrs(), apiFunc, getRefDensmatr(), refFunc); 
        }
    }
 
    /// @todo input validation
}

TEST_CASE() [7/9]

TEST_CASE	(	"mixSuperOp"	,
		TEST_CATEGORY	)

Definition at line 301 of file decoherence.cpp.

                                         {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numQubits = getNumCachedQubits();
        int maxFlag = TEST_MAX_NUM_SUPEROP_TARGETS;
        int maxNumTargs = (maxFlag != 0 && numQubits > maxFlag)?
            maxFlag : numQubits;
 
        int numTargs = GENERATE_COPY( range(1,maxNumTargs+1) );
        auto targs = GENERATE_TARGS( numQubits, numTargs );
        auto matrices = getRandomKrausMap(numTargs, getRandomInt(1,4+1));
 
        SuperOp superOp = createSuperOp(numTargs);
        setSuperOp(superOp, getSuperOperator(matrices));
        auto apiFunc = [&](Qureg qureg) { mixSuperOp(qureg, targs.data(), numTargs, superOp); };
 
        CAPTURE( targs );
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(apiFunc, targs, matrices); }
 
        destroySuperOp(superOp);
    }
 
    /// @todo input validation
}

TEST_CASE() [8/9]

TEST_CASE	(	"mixTwoQubitDephasing"	,
		TEST_CATEGORY	)

Definition at line 223 of file decoherence.cpp.

                                                   {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        auto targs = GENERATE_TARGS( getNumCachedQubits(), 2 );
        qreal prob = getRandomReal(0, 3/4.);
 
        qmatrix i = getPauliMatrix(0);
        qmatrix z = getPauliMatrix(3);
 
        vector<qmatrix> kraus = {
            std::sqrt(1-prob) * getKroneckerProduct(i, i),
            std::sqrt(prob/3) * getKroneckerProduct(i, z),
            std::sqrt(prob/3) * getKroneckerProduct(z, i),
            std::sqrt(prob/3) * getKroneckerProduct(z, z)
        };
 
        auto apiFunc = [&](Qureg qureg) { mixTwoQubitDephasing(qureg, targs[0], targs[1], prob); };
 
        CAPTURE( targs, prob );
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(apiFunc, targs, kraus); }
    }
 
    /// @todo input validation
}

TEST_CASE() [9/9]

TEST_CASE	(	"mixTwoQubitDepolarising"	,
		TEST_CATEGORY	)

Definition at line 250 of file decoherence.cpp.

                                                      {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        auto targs = GENERATE_TARGS( getNumCachedQubits(), 2 );
        qreal prob = getRandomReal(0, 15/16.);
 
        vector<qmatrix> kraus = { std::sqrt(1-16*prob/15) * getIdentityMatrix(4) };
        for (int a=0; a<4; a++)
            for (int b=0; b<4; b++)
                kraus.push_back( std::sqrt(prob/15) * 
                    getKroneckerProduct(getPauliMatrix(a), getPauliMatrix(b)));
 
        auto apiFunc = [&](Qureg qureg) { mixTwoQubitDepolarising(qureg, targs[0], targs[1], prob); };
 
        CAPTURE( targs, prob );
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(apiFunc, targs, kraus); }
    }
 
    /// @todo input validation
}