├── README.md
├── catch
    ├── catch_amalgamated.cpp
    └── catch_amalgamated.hpp
├── compile.sh
├── main.cpp
├── src
    ├── bit_maths.hpp
    ├── communication.hpp
    ├── distributed_densitymatrix.hpp
    ├── distributed_statevector.hpp
    ├── local_densitymatrix.hpp
    ├── local_statevector.hpp
    ├── misc.hpp
    ├── states.hpp
    └── types.hpp
└── tests
    ├── test_utilities.hpp
    ├── tests.cpp
    ├── tests_densitymatrix.hpp
    └── tests_statevector.hpp


/README.md:
--------------------------------------------------------------------------------
  1 | 
  2 | [Distributed Simulation of Statevectors and Density Matrices](https://arxiv.org/abs/2311.01512)
  3 | ===========================================================
  4 | 
  5 | > Tyson Jones, Balint Koczor, Simon C. Benjamin  
  6 | > - Department of Materials, University of Oxford  
  7 | > - Quantum Motion Technologies Ltd
  8 | 
  9 | 
 10 | This repository contains `C++` implementations of the multithreaded, distributed algorithms presented in [this manuscript](https://arxiv.org/abs/2311.01512), and unit tests using [Catch2](https://github.com/catchorg/Catch2). If the code is useful to you, feel free to cite
 11 | ```
 12 | @misc{jones2023distributed,
 13 |       title={Distributed Simulation of Statevectors and Density Matrices}, 
 14 |       author={Tyson Jones and Bálint Koczor and Simon C. Benjamin},
 15 |       year={2023},
 16 |       eprint={2311.01512},
 17 |       archivePrefix={arXiv},
 18 |       primaryClass={quant-ph}
 19 | }
 20 | ```
 21 | 
 22 | # Types
 23 | 
 24 | The below API makes use of the following custom types defined in [`types.hpp`](src/types.hpp), wherein you can vary their precision.
 25 | 
 26 | | Type   | Use           | Default
 27 | |--------|---------------|----------|
 28 | | `Real` | A real scalar | `double` |
 29 | | `Nat`  | A natural scalar | `unsigned int` |
 30 | | `Index` | A state index | `long long unsigned int` |
 31 | | `Amp` | A complex scalar | `std::complex<Real>` |
 32 | 
 33 | We also define arrays and matrices of these types, such as `NatArray`, which are merely eye-candy for `std::vector<Nat>`.
 34 | 
 35 | 
 36 | # API
 37 | 
 38 | Before calling any of the below functions, you should initialise MPI with `comm_init()`, and before exiting, finalise with `comm_end()`.
 39 | 
 40 | Instantiate a quantum state via:
 41 | ```C++
 42 | StateVector psi = StateVector(numQubits);
 43 | DensityMatrix rho = DensityMatrix(numQubits);
 44 | ```
 45 | 
 46 | Statevectors can be passed to the below unitary functions, prefixed with `distributed_statevector_`.
 47 | 
 48 | - ```C++
 49 |   oneTargGate(StateVector psi, Nat target, AmpMatrix gate)
 50 |   ```
 51 | - ```C++
 52 |   manyCtrlOneTargGate(StateVector psi, NatArray controls, Nat target, AmpMatrix gate)
 53 |   ```
 54 | - ```C++
 55 |   swapGate(StateVector psi, Nat qb1, Nat qb2)
 56 |   ```
 57 | - ```C++
 58 |   manyTargGate(StateVector psi, NatArray targets, AmpMatrix gate)
 59 |   ```
 60 | - ```C++
 61 |   pauliTensor(StateVector psi, NatArray targets, NatArray paulis)
 62 |   ```
 63 | - ```C++
 64 |   pauliGadget(StateVector psi, NatArray targets, NatArray paulis, Real theta)
 65 |   ```
 66 | - ```C++
 67 |   phaseGadget(StateVector psi, NatArray targets, Real theta)
 68 |   ```
 69 | 
 70 | Density matrices can be passed to the below functions, prefixed with `distributed_densitymatrix_`.
 71 | 
 72 | - ```C++
 73 |   manyTargGate(DensityMatrix rho, NatArray targets, AmpMatrix gate)
 74 |   ```
 75 | - ```C++
 76 |   swapGate(DensityMatrix rho, Nat qb1, Nat qb2)
 77 |   ```
 78 | - ```C++
 79 |   pauliTensor(DensityMatrix rho, NatArray targets, NatArray paulis)
 80 |   ```
 81 | - ```C++
 82 |   pauliGadget(DensityMatrix rho, NatArray targets, NatArray paulis, Real theta)
 83 |   ```
 84 | - ```C++
 85 |   phaseGadget(DensityMatrix rho, NatArray targets, Real theta)
 86 |   ```
 87 | - ```C++
 88 |   phaseGadget(DensityMatrix rho, NatArray targets, Real theta)
 89 |   ```
 90 | - ```C++
 91 |   oneQubitDephasing(DensityMatrix rho, Nat qb, Real prob)
 92 |   ```
 93 | - ```C++
 94 |   twoQubitDephasing(DensityMatrix rho, Nat qb1, Nat qb2, Real prob)
 95 |   ```
 96 | - ```C++
 97 |   oneQubitDepolarising(DensityMatrix rho, Nat qb, Real prob)
 98 |   ```
 99 | - ```C++
100 |   twoQubitDepolarising(DensityMatrix rho, Nat qb1, Nat qb2, Real prob)
101 |   ```
102 | - ```C++
103 |   damping(DensityMatrix rho, Nat qb, Real prob)
104 |   ```
105 | - ```C++
106 |   expecPauliString(DensityMatrix rho, RealArray coeffs, NatArray allPaulis)
107 |   ```
108 | - ```C++
109 |   partialTrace(DensityMatrix inRho, NatArray targets)
110 |   ```
111 | 
112 | View the definition of these functions in the [`src`](/src/) folder.
113 | 
114 | See an example in [`main.cpp`](main.cpp).
115 | 
116 | 
117 | # Compiling
118 | 
119 | To compile both [`main.cpp`](main.cpp) and the [unit tests](/tests/), simply call
120 | ```bash
121 | source ./compile
122 | ```
123 | Additionally, set the number of threads (per node) via
124 | ```bash
125 | export OMP_NUM_THREADS=24
126 | ```
127 | and launch the executables between (e.g.) `16` nodes via
128 | ```bash
129 | mpirun -np 16 ./main
130 | ```
131 | ```bash
132 | mpirun -np 16 ./test
133 | ```
134 | You must use a power-of-2 number of nodes.
135 | 
136 | 
137 | # License
138 | 
139 | This repository is licensed under the terms of the MIT license.


--------------------------------------------------------------------------------
/compile.sh:
--------------------------------------------------------------------------------
 1 | 
 2 | conf="-std=c++17 -O3 -fopenmp -march=native"
 3 | dirs="-Isrc -Itests -Icatch"
 4 | 
 5 | echo "compiling main..."
 6 | mpic++ $conf $dirs main.cpp -o main $*
 7 | 
 8 | echo "compiling tests..."
 9 | mpic++ $conf $dirs tests/tests.cpp catch/catch_amalgamated.cpp -o test $*
10 | 
11 | export OMP_WAIT_POLICY=active
12 | export OMP_DYNAMIC=false
13 | export OMP_PROC_BIND=true
14 | export OMP_NUM_THREADS=24            # set to #cores per node


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
 1 | #include "types.hpp"
 2 | #include "states.hpp"
 3 | #include "local_statevector.hpp"
 4 | #include "distributed_statevector.hpp"
 5 | #include "distributed_densitymatrix.hpp"
 6 | #include "test_utilities.hpp"
 7 | 
 8 | #include <stdio.h>
 9 | #include <iostream>
10 | #include <complex>
11 | #include <chrono>
12 | 
13 | using namespace std::chrono;
14 | using namespace std::complex_literals;
15 | 
16 | 
17 | 
18 | int main() {
19 |     
20 |     comm_init();
21 | 
22 |     Nat numQubits = 26;
23 |     StateVector state = StateVector(numQubits);
24 | 
25 |     NatArray targets = {0,6,4,2};
26 |     AmpMatrix matrix = getRandomMatrix( powerOf2(targets.size()) ); 
27 | 
28 |     auto start = high_resolution_clock::now();
29 |     comm_synch();
30 | 
31 |     distributed_statevector_manyTargGate(state, targets, matrix);
32 | 
33 |     comm_synch();
34 |     auto stop = high_resolution_clock::now();
35 |     auto dur = duration_cast<microseconds>(stop - start).count();
36 | 
37 |     rootNodePrint("done in " + std::to_string(dur) + " microseconds\n");
38 | 
39 |     comm_end();
40 |     return 0;
41 | }


--------------------------------------------------------------------------------
/src/bit_maths.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef BIT_MATHS_HPP
  2 | #define BIT_MATHS_HPP
  3 | 
  4 | 
  5 | #include "types.hpp"
  6 | 
  7 | 
  8 | 
  9 | /* 
 10 |  * Fast and inlined; safe to call in tight loops.
 11 |  * None of these twiddles may use sign tricks, 
 12 |  * since Nat and Index are unsigned.
 13 |  */
 14 | 
 15 | 
 16 | #define INLINE static inline __attribute__((always_inline))
 17 | 
 18 | 
 19 | INLINE Index powerOf2(Nat exponent) {
 20 |     
 21 |     return 1ULL << exponent;
 22 | }
 23 | 
 24 | 
 25 | INLINE bool isPowerOf2(Index number) {
 26 | 
 27 |     return (number > 0) && ((number & (number - 1U)) == 0);
 28 | }
 29 | 
 30 | 
 31 | INLINE Nat getBit(Index number, Nat bitIndex) {
 32 |     
 33 |     return (number >> bitIndex) & 1U;
 34 | }
 35 | 
 36 | 
 37 | INLINE Index flipBit(Index number, Nat bitIndex) {
 38 |     
 39 |     return number ^ (1ULL << bitIndex);
 40 | }
 41 | 
 42 | 
 43 | INLINE Index insertBit(Index number, Nat bitIndex, Nat bitValue) {
 44 |     
 45 |     Index left = (number >> bitIndex) << (bitIndex + 1);
 46 |     Index middle = bitValue << bitIndex;
 47 |     Index right = number & ((1ULL << bitIndex) - 1);
 48 |     return left | middle | right;
 49 | }
 50 | 
 51 | 
 52 | INLINE Index insertBits(Index number, NatArray bitIndices, Nat bitValue) {
 53 |     
 54 |     // bitIndices must be strictly increasing
 55 |     for (Nat i: bitIndices)
 56 |         number = insertBit(number, i, bitValue);
 57 |         
 58 |     return number;
 59 | }
 60 | 
 61 | 
 62 | INLINE Index setBit(Index number, Nat bitIndex, Nat bitValue) {
 63 | 
 64 |     Index comp = ~ (1ULL << bitIndex);
 65 |     Index mask = bitValue << bitIndex;
 66 |     return (number & (~comp)) | mask;
 67 | }
 68 | 
 69 | 
 70 | INLINE Index setBits(Index number, NatArray bitIndices, Index bitsValue) {
 71 |     
 72 |     for (Nat i=0; i<bitIndices.size(); i++) {
 73 |         Nat bit = getBit(bitsValue, i);
 74 |         number = setBit(number, bitIndices[i], bit);
 75 |     }
 76 |     
 77 |     return number;
 78 | }
 79 | 
 80 | 
 81 | INLINE Nat getBitMaskParity(Index mask) {
 82 |     
 83 |     // BEWARE:
 84 |     //  - this compiler extension may not be available on all compilers
 85 |     //  - the (Nat) cast may add additional clock cycles
 86 |     
 87 |     return (Nat) __builtin_parity(mask);
 88 | }
 89 | 
 90 | 
 91 | 
 92 | /*
 93 |  * Aliases for code clarity 
 94 |  */
 95 |  
 96 | 
 97 |  INLINE Index insertTwoBits(Index number, Nat highInd, Nat highBit, Nat lowInd, Nat lowBit) {
 98 |      
 99 |      number = insertBit(number, lowInd, lowBit);
100 |      number = insertBit(number, highInd, highBit);
101 |      return number;
102 |  }
103 |  
104 |  
105 |  INLINE Index insertThreeZeroBits(Index number, Nat i3, Nat i2, Nat i1) {
106 |      
107 |      number = insertTwoBits(number, i2, 0, i1, 0);
108 |      number = insertBit(number, i3, 0);
109 |      return number;
110 |  }
111 | 
112 | 
113 |  INLINE Index insertFourZeroBits(Index number, Nat i4, Nat i3, Nat i2, Nat i1) {
114 |      
115 |      number = insertTwoBits(number, i2, 0, i1, 0);
116 |      number = insertTwoBits(number, i4, 0, i3, 0);
117 |      return number;
118 |  }
119 |  
120 |  INLINE Index flipTwoBits(Index number, Nat i1, Nat i0) {
121 |      
122 |      number = flipBit(number, i1);
123 |      number = flipBit(number, i0);
124 |      return number;
125 |  }
126 | 
127 | 
128 | 
129 |  /* 
130 |  * Non-performance critical code; not to be used in tight loops
131 |  */
132 | 
133 | 
134 | static Nat getNextLeftmostZeroBit(Index mask, Nat bitInd) {
135 | 
136 |     bitInd--;
137 |     while (getBit(mask, bitInd))
138 |         bitInd--;
139 |     
140 |     return bitInd;
141 | }
142 | 
143 | 
144 | static bool allBitsAreOne(Index number, NatArray bitIndices) {
145 |     
146 |     for (Nat i : bitIndices)
147 |         if (!getBit(number, i))
148 |             return false;
149 |             
150 |     return true;
151 | }
152 | 
153 | 
154 | static Index getBitMask(NatArray bitIndices) {
155 |     
156 |     Index mask = 0;
157 |     for (Nat i: bitIndices)
158 |         mask = flipBit(mask, i);
159 |         
160 |     return mask;
161 | }
162 | 
163 | 
164 | static Nat logBase2(Index powerOf2) {
165 |     
166 |     Nat expo = 0;
167 |     while (getBit(powerOf2, 0) != 1) {
168 |         expo++;
169 |         powerOf2 >>= 1;
170 |     }
171 | 
172 |     return expo;
173 | }
174 | 
175 | 
176 | #endif // BIT_MATHS_HPP
177 | 


--------------------------------------------------------------------------------
/src/communication.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef COMMUNICATION_HPP
  2 | #define COMMUNICATION_HPP
  3 | 
  4 | 
  5 | #include "types.hpp"
  6 | #include "bit_maths.hpp"
  7 | 
  8 | #include <mpi.h>
  9 | 
 10 | 
 11 | 
 12 | /*
 13 |  * MPI environment management 
 14 |  */
 15 | 
 16 | static void comm_init() {
 17 |     int isInit;
 18 |     MPI_Initialized(&isInit);
 19 |     if (!isInit)
 20 |         MPI_Init(NULL, NULL);
 21 | }
 22 | 
 23 | 
 24 | static void comm_end() {
 25 |     MPI_Barrier(MPI_COMM_WORLD);
 26 |     MPI_Finalize();
 27 | }
 28 | 
 29 | 
 30 | static Nat comm_getRank() {
 31 |     int rank;
 32 |     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 33 |     return (Nat) rank;
 34 | }
 35 | 
 36 | 
 37 | static Nat comm_getNumNodes() {
 38 |     int numNodes;
 39 |     MPI_Comm_size(MPI_COMM_WORLD, &numNodes);
 40 |     return (Nat) numNodes;
 41 | }
 42 | 
 43 | 
 44 | static void comm_synch() {
 45 |     
 46 |     MPI_Barrier(MPI_COMM_WORLD);
 47 | }
 48 | 
 49 | 
 50 | /*
 51 |  * internal convenience functions
 52 |  */
 53 | 
 54 | static int NULL_TAG = 0;
 55 | 
 56 | static void getMessageConfig(Index *messageSize, Index *numMessages, Index numAmps) {
 57 | 
 58 |     assert( isPowerOf2(numAmps) );
 59 | 
 60 |     // determine the number of max-size messages
 61 |     *messageSize = powerOf2(30);
 62 |     *numMessages = numAmps / *messageSize; // divides evenly
 63 | 
 64 |     // when numAmps < messageSize, we need send only one smaller message (obviously)
 65 |     if (*numMessages == 0) {
 66 |         *messageSize = numAmps;
 67 |         *numMessages = 1;
 68 |     }
 69 | }
 70 | 
 71 | 
 72 | 
 73 | /*
 74 |  * synchronous amplitude exchange
 75 |  */
 76 | 
 77 | static void comm_exchangeInChunks(Amp* send, Amp* recv, Index numAmps, Nat pairRank) {
 78 | 
 79 |     // each message is asynchronously dispatched with a final wait, as per arxiv.org/abs/2308.07402
 80 | 
 81 |     // divide the data into multiple messages
 82 |     Index messageSize, numMessages;
 83 |     getMessageConfig(&messageSize, &numMessages, numAmps);
 84 | 
 85 |     // each asynch message below will create two requests for subsequent synch
 86 |     std::vector<MPI_Request> requests(2*numMessages);
 87 | 
 88 |     // asynchronously exchange the messages (effecting MPI_Isendrecv), exploiting orderedness gaurantee
 89 |     for (Index m=0; m<numMessages; m++) {
 90 |         MPI_Isend(&send[m*messageSize], messageSize, MPI_AMP, pairRank, NULL_TAG, MPI_COMM_WORLD, &requests[2*m]);
 91 |         MPI_Irecv(&recv[m*messageSize], messageSize, MPI_AMP, pairRank, NULL_TAG, MPI_COMM_WORLD, &requests[2*m+1]);
 92 |     }
 93 | 
 94 |     // wait for all exchanges to complete (MPI willl automatically free the request memory)
 95 |     MPI_Waitall(requests.size(), requests.data(), MPI_STATUSES_IGNORE);
 96 | }
 97 | 
 98 | 
 99 | static void comm_exchangeArrays(
100 |     AmpArray& toSend, Index toSendStartInd, 
101 |     AmpArray& toReceive, Index toReceiveStartInd, 
102 |     Index numAmpsToExchange, Nat pairRank
103 | ) {
104 |     comm_exchangeInChunks(
105 |         &toSend[toSendStartInd], &toReceive[toReceiveStartInd],
106 |         numAmpsToExchange, pairRank);
107 | }
108 | 
109 | 
110 | static void comm_exchangeArrays(AmpArray& toSend, AmpArray& toReceive, Nat pairRank) {
111 |     
112 |     comm_exchangeArrays(toSend, 0, toReceive, 0, toSend.size(), pairRank);
113 | }
114 | 
115 | 
116 | 
117 | /*
118 |  * asynch send and synch receive
119 |  */
120 | 
121 | 
122 | static void comm_asynchSendInChunks(Amp* send, Index numAmps, Nat pairRank) {
123 | 
124 |     // we will not track nor wait for the asynch send; instead, the caller will later comm_synch()
125 |     MPI_Request nullReq;
126 | 
127 |     // divide the data into multiple messages
128 |     Index messageSize, numMessages;
129 |     getMessageConfig(&messageSize, &numMessages, numAmps);
130 | 
131 |     // asynchronously send the messages; pairRank receives the same ordering
132 |     for (Index m=0; m<numMessages; m++)
133 |         MPI_Isend(&send[m*messageSize], messageSize, MPI_AMP, pairRank, NULL_TAG, MPI_COMM_WORLD, &nullReq);
134 | }
135 | 
136 | 
137 | static void comm_asynchSendArray(AmpArray& toSend, Index numAmpsToSend, Nat pairRank) {
138 |     
139 |     comm_asynchSendInChunks(toSend.data(), numAmpsToSend, pairRank);
140 | }
141 | 
142 | 
143 | static void comm_receiveInChunks(Amp* dest, Index numAmps, Nat pairRank) {
144 | 
145 |     // expect the data in multiple messages
146 |     Index messageSize, numMessages;
147 |     getMessageConfig(&messageSize, &numMessages, numAmps);
148 | 
149 |     // create a request for each asynch receive below
150 |     std::vector<MPI_Request> requests(numMessages);
151 | 
152 |     // listen to receive each message asynchronously (as per arxiv.org/abs/2308.07402)
153 |     for (Index m=0; m<numMessages; m++)
154 |         MPI_Irecv(&dest[m*messageSize], messageSize, MPI_AMP, pairRank, NULL_TAG, MPI_COMM_WORLD, &requests[m]);
155 | 
156 |     // receivers wait for all messages to be received (while sender asynch proceeds)
157 |     MPI_Waitall(requests.size(), requests.data(), MPI_STATUSES_IGNORE);
158 | }
159 | 
160 | 
161 | static void comm_receiveArray(AmpArray& toReceive, Index numAmpsToReceive, Nat pairRank) {
162 |     
163 |     comm_receiveInChunks(toReceive.data(), numAmpsToReceive, pairRank);
164 | }
165 | 
166 | 
167 | 
168 | /*
169 |  * synchronous reduction
170 |  */
171 | 
172 | static void comm_reduceAmp(Amp& localAmp) {
173 | 
174 |     Amp globalAmp;
175 |     MPI_Allreduce(&localAmp, &globalAmp, 1, MPI_AMP, MPI_SUM, MPI_COMM_WORLD);
176 |     localAmp = globalAmp;
177 | }
178 | 
179 | 
180 | 
181 | #endif // COMMUNICATION_HPP


--------------------------------------------------------------------------------
/src/distributed_densitymatrix.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef DISTRIBUTED_DENSITYMATRIX_HPP
  2 | #define DISTRIBUTED_DENSITYMATRIX_HPP
  3 | 
  4 | 
  5 | #include "types.hpp"
  6 | #include "states.hpp"
  7 | #include "bit_maths.hpp"
  8 | #include "misc.hpp"
  9 | #include "communication.hpp"
 10 | 
 11 | #include "local_densitymatrix.hpp"
 12 | #include "distributed_statevector.hpp"
 13 | 
 14 | 
 15 | static void distributed_densitymatrix_manyTargGate(DensityMatrix &rho, NatArray targets, AmpMatrix gate) {
 16 |     assert( 2*targets.size() <= rho.logNumAmpsPerNode );
 17 | 
 18 |     distributed_statevector_manyTargGate(rho, targets, gate);
 19 |     
 20 |     for (Nat &t : targets)
 21 |         t += rho.numQubits;
 22 |         
 23 |     gate = getConjugateMatrix(gate);
 24 |     distributed_statevector_manyTargGate(rho, targets, gate);
 25 | }
 26 | 
 27 | 
 28 | static void distributed_densitymatrix_swapGate(DensityMatrix &rho, Nat qb1, Nat qb2) {
 29 |     
 30 |     Nat n = rho.numQubits;
 31 |     distributed_statevector_swapGate(rho, qb1, qb2);
 32 |     distributed_statevector_swapGate(rho, qb1 + n, qb2 + n);
 33 | }
 34 | 
 35 | 
 36 | static void distributed_densitymatrix_pauliTensor(DensityMatrix &rho, NatArray targets, NatArray paulis) {
 37 |     
 38 |     distributed_statevector_pauliTensor(rho, targets, paulis);
 39 |     
 40 |     for (Nat &t : targets)
 41 |         t += rho.numQubits;
 42 |     
 43 |     distributed_statevector_pauliTensor(rho, targets, paulis);
 44 |     
 45 |     if (containsOddNumY(paulis)) {
 46 |         #pragma omp parallel for
 47 |         for (Amp &amp : rho.amps)
 48 |             amp *= -1;
 49 |     }
 50 | }
 51 | 
 52 | 
 53 | static void distributed_densitymatrix_pauliGadget(DensityMatrix &rho, NatArray targets, NatArray paulis, Real theta) {
 54 | 
 55 |     distributed_statevector_pauliGadget(rho, targets, paulis, theta);
 56 |     
 57 |     for (Nat &t : targets)
 58 |         t += rho.numQubits;
 59 |         
 60 |     if (!containsOddNumY(paulis))
 61 |         theta *= -1;
 62 | 
 63 |     distributed_statevector_pauliGadget(rho, targets, paulis, theta);
 64 | }
 65 | 
 66 | 
 67 | static void distributed_densitymatrix_phaseGadget(DensityMatrix &rho, NatArray targets, Real theta) {
 68 |     
 69 |     distributed_statevector_phaseGadget(rho, targets, theta);
 70 |     
 71 |     for (Nat &t : targets)
 72 |         t += rho.numQubits;
 73 |         
 74 |     theta *= -1;
 75 |     distributed_statevector_phaseGadget(rho, targets, theta);
 76 | }
 77 | 
 78 | 
 79 | static void distributed_densitymatrix_krausMap(DensityMatrix &rho, MatrixArray krausOps, NatArray targets) {
 80 |     assert( 2*targets.size() <= rho.logNumAmpsPerNode );
 81 | 
 82 |     AmpMatrix superOp = getSuperoperator(krausOps);
 83 | 
 84 |     NatArray extendedTargets = targets;
 85 |     for (Nat t : targets)
 86 |         extendedTargets.push_back(t + rho.numQubits);
 87 | 
 88 |     distributed_statevector_manyTargGate(rho, extendedTargets, superOp);
 89 | }
 90 | 
 91 | 
 92 | static void distributed_densitymatrix_oneQubitDephasing(DensityMatrix &rho, Nat qb, Real prob) {
 93 |     
 94 |     local_densitymatrix_oneQubitDephasing(rho, qb, prob);
 95 | }
 96 | 
 97 | 
 98 | static void distributed_densitymatrix_twoQubitDephasing(DensityMatrix &rho, Nat qb1, Nat qb2, Real prob) {
 99 |     
100 |     local_densitymatrix_twoQubitDephasing(rho, qb1, qb2, prob);
101 | }
102 | 
103 | 
104 | static void distributed_densitymatrix_oneQubitDepolarising(DensityMatrix &rho, Nat qb, Real prob) {
105 |     
106 |     Amp c1 = 2*prob/3;
107 |     Amp c2 = 1 - 2*prob/3;
108 |     Amp c3 = 1 - 4*prob/3;
109 |     
110 |     if (qb < rho.numQubits - rho.logNumNodes)
111 |         local_densitymatrix_oneQubitDepolarising(rho, qb, c1, c2, c3);
112 |     
113 |     else {
114 |         Nat qbShift = qb - (rho.numQubits - rho.logNumNodes);
115 |         Nat bit = getBit(rho.rank, qbShift);
116 |         Index numIts = rho.numAmpsPerNode / 2;
117 |         
118 |         // pack half of local amps into buffer
119 |         #pragma omp parallel for
120 |         for (Index k=0; k<numIts; k++) {
121 |             Index j = insertBit(k, qb, bit);
122 |             rho.buffer[k] = rho.amps[j];
123 |         }
124 |         
125 |         // swap half-buffers, by sending buffer[0...], receiving in buffer[offset...]
126 |         Nat pairRank = flipBit(rho.rank, qbShift);
127 |         Index bufferOffset = numIts;
128 |         comm_exchangeArrays(rho.buffer, 0, rho.buffer, bufferOffset, numIts, pairRank);
129 |         
130 |         #pragma omp parallel for
131 |         for (Index k=0; k<numIts; k++) {
132 |             Index j = insertBit(k, qb, ! bit);
133 |             rho.amps[j] *= c3;
134 |         }
135 |         
136 |         #pragma omp parallel for
137 |         for (Index k=0; k<numIts; k++) {
138 |             Index j = insertBit(k, qb, bit);
139 |             Index l = k + bufferOffset;
140 |             rho.amps[j] = c2*rho.amps[j] + c1*rho.buffer[l];
141 |         }
142 |     }
143 | }
144 | 
145 | 
146 | static void distributed_densitymatrix_twoQubitDepolarising_subroutine_pair(DensityMatrix &rho, Nat q0, Nat q1, Nat q2, Amp c1, Amp c2, Amp c3) {
147 | 
148 |     Nat alt1 = q1 - (rho.numQubits - rho.logNumNodes);
149 |     Nat bit = getBit(rho.rank, alt1);
150 |     
151 |     // scale all amplitudes
152 |     #pragma omp parallel for
153 |     for (Index j=0; j<rho.numAmpsPerNode; j++) {
154 |         Nat flag1 = getBit(j, q0) == getBit(j, q2); 
155 |         Nat flag2 = getBit(j, q1) == bit;
156 |         Amp fac = 1. + c3 * Amp(!(flag1 & flag2), 0);
157 |         rho.amps[j] *= fac;
158 |     }
159 |     
160 |     // pack eighth of buffer with pre-summed amp pairs
161 |     Index numIts = rho.numAmpsPerNode / 8;
162 |     #pragma omp parallel for
163 |     for (Index k=0; k<numIts; k++) {
164 |         Index j000 = insertThreeZeroBits(k, q2, q1, q0);
165 |         Index j0b0 = setBit(j000, q1, bit);
166 |         Index j1b1 = flipTwoBits(j0b0, q2, q0);
167 |         rho.buffer[k] = rho.amps[j0b0] + rho.amps[j1b1];
168 |     }
169 |     
170 |     // swap eighth-buffers (send buffer[0...], receive in buffer[offset...])
171 |     Nat pairRank = flipBit(rho.rank, alt1);
172 |     Index bufferOffset = numIts;
173 |     comm_exchangeArrays(rho.buffer, 0, rho.buffer, bufferOffset, numIts, pairRank);
174 |     
175 |     #pragma omp parallel for
176 |     for (Index k=0; k<numIts; k++) {
177 |         Index j000 = insertThreeZeroBits(k, q2, q1, q0);
178 |         Index j0b0 = setBit(j000, q1, bit);
179 |         Index j1b1 = flipTwoBits(j0b0, q2, q0);
180 |         Index l = k + bufferOffset;
181 |         rho.amps[j0b0] = c1*rho.amps[j0b0] + c2*(rho.amps[j1b1] + rho.buffer[l]);
182 |         rho.amps[j1b1] = c1*rho.amps[j1b1] + c2*(rho.amps[j0b0] + rho.buffer[l]);
183 |     }
184 | }
185 | 
186 | 
187 | static void distributed_densitymatrix_twoQubitDepolarising_subroutine_quad(DensityMatrix &rho, Nat q0, Nat q1, Amp c1, Amp c2, Amp c3) {
188 | 
189 |     Nat alt0 = q0 - (rho.numQubits - rho.logNumNodes);
190 |     Nat alt1 = q1 - (rho.numQubits - rho.logNumNodes);
191 |     Nat bit0 = getBit(rho.rank, alt0);
192 |     Nat bit1 = getBit(rho.rank, alt1);
193 |     
194 |     // scale all amplitudes
195 |     #pragma omp parallel for
196 |     for (Index j=0; j<rho.numAmpsPerNode; j++) {
197 |         Nat flag1 = getBit(j, q0) == bit0; 
198 |         Nat flag2 = getBit(j, q1) == bit1;
199 |         Amp fac = 1. + c3 * Amp(!(flag1 & flag2), 0);
200 |         rho.amps[j] *= fac;
201 |     }
202 |     
203 |     // pack fourth of buffer
204 |     Index numIts = rho.numAmpsPerNode / 4;
205 |     #pragma omp parallel for
206 |     for (Index k=0; k<numIts; k++) {
207 |         Index j = insertTwoBits(k, q1, bit1, q0, bit0);
208 |         rho.buffer[k] = rho.amps[j];
209 |     }
210 |     
211 |     // swap fourth-buffer with first pair node (send buffer[0...], receive in buffer[offset...])
212 |     Nat pairRank0 = flipBit(rho.rank, alt0);
213 |     Index bufferOffset = numIts;
214 |     comm_exchangeArrays(rho.buffer, 0, rho.buffer, bufferOffset, numIts, pairRank0);
215 |     
216 |     // update local amps and buffer
217 |     #pragma omp parallel for
218 |     for (Index k=0; k<numIts; k++) {
219 |         Index j = insertTwoBits(k, q1, bit1, q0, bit0);
220 |         Index l = k + bufferOffset;
221 |         Amp amp = c1*rho.amps[j] + c2*rho.buffer[l];
222 |         rho.amps[j] = amp;
223 |         rho.buffer[k] = amp;
224 |     }
225 |     
226 |     // swap fourth-buffer with second pair node (send buffer[0...], receive in buffer[offset...])
227 |     Nat pairRank1 = flipBit(rho.rank, alt1);
228 |     comm_exchangeArrays(rho.buffer, 0, rho.buffer, bufferOffset, numIts, pairRank1);
229 |     
230 |     // update local amps 
231 |     Amp c4 = c2/c1;
232 |     #pragma omp parallel for
233 |     for (Index k=0; k<numIts; k++) {
234 |         Index j = insertTwoBits(k, q1, bit1, q0, bit0);
235 |         Index l = k + bufferOffset;
236 |         rho.amps[j] = c4 * rho.buffer[l];
237 |     }
238 | }
239 | 
240 | 
241 | static void distributed_densitymatrix_twoQubitDepolarising(DensityMatrix &rho, Nat qb1, Nat qb2, Real prob) {
242 | 
243 |     // ensure qb2 is larger
244 |     if (qb1 > qb2)
245 |         std::swap(qb1, qb2);
246 |         
247 |     Amp c1 = 1 - 4*prob/5;
248 |     Amp c2 = 4*prob/15;
249 |     Amp c3 = -16*prob/15;
250 |     Nat shift1 = qb1 + rho.numQubits;
251 |     Nat shift2 = qb2 + rho.numQubits;
252 |     
253 |     Nat threshold = rho.numQubits - rho.logNumNodes;
254 |         
255 |     if (qb2 < threshold)
256 |         local_densitymatrix_twoQubitDepolarising(rho, qb1, qb2, shift1, shift2, c1, c2, c3);
257 |         
258 |     else if (qb2 >= threshold && qb1 < threshold)
259 |         distributed_densitymatrix_twoQubitDepolarising_subroutine_pair(rho, qb1, qb2, shift1, c1, c2, c3);
260 |     
261 |     else
262 |         distributed_densitymatrix_twoQubitDepolarising_subroutine_quad(rho, qb1, qb2, c1, c2, c3);
263 | }
264 | 
265 | 
266 | static void distributed_densitymatrix_damping(DensityMatrix &rho, Nat qb, Real prob) {
267 |     
268 |     Nat threshold = rho.numQubits - rho.logNumNodes;
269 |     
270 |     if (qb < threshold)
271 |         local_densitymatrix_damping(rho, qb, prob);
272 |         
273 |     else {
274 |         Index numIts = rho.numAmpsPerNode / 2;
275 |         Nat pairRank = flipBit(rho.rank, qb - threshold);
276 |         Nat bit = getBit(rho.rank, qb - threshold);
277 |         Amp c1 = sqrt(1 - prob);
278 |         Amp c2 = 1 - prob;
279 |         
280 |         // half of all nodes...
281 |         if (bit == 1) {
282 |             
283 |             // pack half buffer and scale half their amps
284 |             #pragma omp parallel for
285 |             for (Index k=0; k<numIts; k++) {
286 |                 Index j = insertBit(k, qb, 1);
287 |                 rho.buffer[k] = rho.amps[j];
288 |                 rho.amps[j] *= c2;
289 |             }
290 |             
291 |             // asynchronously send half-buffer, instantly proceeding
292 |             comm_asynchSendArray(rho.buffer, numIts, pairRank);
293 |         }
294 |         
295 |         // all nodes proceed to scale half their (remaining) local amps
296 |         #pragma omp parallel for
297 |         for (Index k=0; k<numIts; k++) {
298 |             Index j = insertBit(k, qb, !bit);
299 |             rho.amps[j] *= c1;
300 |         }
301 |         
302 |         // other half of all nodes...
303 |         if (bit == 0) {
304 |             
305 |             // receive half-buffer (waiting for full receive)
306 |             comm_receiveArray(rho.buffer, numIts, pairRank);
307 |             
308 |             // and combine it with their remaining local amps
309 |             #pragma omp parallel for
310 |             for (Index k=0; k<numIts; k++) {
311 |                 Index j = insertBit(k, qb, 0);
312 |                 rho.amps[j] += prob * rho.buffer[k];
313 |             }
314 |         }
315 |         
316 |         // stop asynch senders from proceeding, so their buffers aren't subsequently prematurely modified
317 |         comm_synch();
318 |     }
319 | }
320 | 
321 | 
322 | static Amp distributed_densitymatrix_expecPauliString(DensityMatrix &rho, RealArray coeffs, NatArray allPaulis) {
323 | 
324 |     Amp value = 0;
325 |     Index numCoeffs = coeffs.size();
326 |     
327 |     #pragma omp parallel for reduction(+:value)
328 |     for (Index j=0; j<rho.numAmpsPerNode; j++) {
329 |         Index i = (rho.rank << rho.logNumAmpsPerNode) | j;
330 | 
331 |         Amp term = 0;
332 |         
333 |         for (Index t=0; t<numCoeffs; t++) {
334 |             Nat* termPaulis = &allPaulis[t*rho.numQubits];
335 |             Amp elem = getPauliTensorElem(termPaulis, rho.numQubits, i);
336 |             term += elem * coeffs[t];
337 |         }
338 |         
339 |         value += term * rho.amps[j];
340 |     }
341 |     
342 |     comm_reduceAmp(value);
343 |     return value;
344 | }
345 | 
346 | 
347 | static DensityMatrix distributed_densitymatrix_partialTrace(DensityMatrix &inRho, NatArray targets) {
348 | 
349 |     // require that the reduced density matrix has more (or equal) columns than nodes, so
350 |     // that it is compatible with this project's other algorithms
351 |     Nat outRhoNumQubits = inRho.numQubits - targets.size();
352 |     assert( outRhoNumQubits >= inRho.logNumNodes );
353 | 
354 |     /* Note this algorithm imposes a looser constraint; that
355 |      *      targets.size() <= inRho.numQubits - (inRho.logNumNodes/2)
356 |      * and ergo permits tracing out more qubits than the above restriction
357 |      * permits. However, the reduced density matrices violate the precondition
358 |      * of the DensityMatrix constructor
359 |      */
360 | 
361 |     // targets must be sorted for bitwise insertions
362 |     std::sort(targets.begin(), targets.end());
363 | 
364 |     // if all targets are in suffix, invoke embarrassingly parallel trace on {t, t+N}, and return
365 |     if (targets.back() + inRho.numQubits < inRho.logNumAmpsPerNode) {
366 |         NatArray pairs = targets;
367 |         for (Nat &t : pairs)
368 |             t += inRho.numQubits;
369 |         return local_densitymatrix_partialTrace(inRho, targets, pairs);
370 |     }
371 | 
372 |     // otherwise, treating outRho as a statevector, collect all involved qubits...
373 |     NatArray extendedTargets = targets;
374 |     for (Nat t : targets)
375 |         extendedTargets.push_back(t + inRho.numQubits);
376 | 
377 |     // and find which qubits they should be swapped with, so that all effective targets lie in the suffix substate
378 |     NatArray reorderedTargets = getReorderedAllSuffixTargets(extendedTargets, inRho.logNumAmpsPerNode);
379 | 
380 |     // effect those swaps, enabling subsequent (disordered) partial trace to be embarrassingly parallel.
381 |     // we iterate in reverse (swap leftmost qubits first), to minimise violating relative order of non-targeted bits
382 |     for (Nat q = reorderedTargets.size(); q-- != 0; )
383 |         if (reorderedTargets[q] != extendedTargets[q])
384 |             distributed_statevector_swapGate(inRho, reorderedTargets[q], extendedTargets[q]);
385 | 
386 |     // embarassingly parallel reduce the density matrix
387 |     NatArray pairTargets(reorderedTargets.begin() + targets.size(), reorderedTargets.end());
388 |     DensityMatrix outRho = local_densitymatrix_partialTrace(inRho, targets, pairTargets);
389 | 
390 |     // determine the relative ordering of the remaining non-targered qubits
391 |     NatArray remainingQubits = getNonTargetedQubitOrder(2*inRho.numQubits, extendedTargets, reorderedTargets);
392 | 
393 |     // perform additional swaps to re-order the remaining qubits
394 |     for (Nat q=remainingQubits.size(); q-- != 0; ) {
395 |         if (remainingQubits[q] == q)
396 |             continue;
397 |         Nat p = 0;
398 |         while (remainingQubits[p] != q)
399 |             p++;
400 |         
401 |         distributed_statevector_swapGate(outRho, q, p);
402 |         std::swap(remainingQubits[q], remainingQubits[p]);
403 |     }
404 | 
405 |     return outRho;
406 | }
407 | 
408 | 
409 | #endif // DISTRIBUTED_DENSITYMATRIX_HPP


--------------------------------------------------------------------------------
/src/distributed_statevector.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef DISTRIBUTED_STATEVECTOR_HPP
  2 | #define DISTRIBUTED_STATEVECTOR_HPP
  3 | 
  4 | 
  5 | #include "types.hpp"
  6 | #include "states.hpp"
  7 | #include "bit_maths.hpp"
  8 | #include "misc.hpp"
  9 | #include "communication.hpp"
 10 | 
 11 | #include "local_statevector.hpp"
 12 | 
 13 | #include <cmath>
 14 | #include <algorithm>
 15 | #include <assert.h>
 16 | 
 17 | 
 18 | void distributed_statevector_oneTargGate(StateVector& psi, Nat target, AmpMatrix gate) {
 19 |     
 20 |     // embarrassingly parallel
 21 |     if (target < psi.logNumAmpsPerNode)
 22 |         local_statevector_oneTargGate(psi, target, gate);
 23 |     
 24 |     else {
 25 |         // exchange all amps (receive to buffer)
 26 |         Nat rankTarget = target - psi.logNumAmpsPerNode;
 27 |         Nat pairRank = flipBit(psi.rank, rankTarget);
 28 |         comm_exchangeArrays(psi.amps, psi.buffer, pairRank);
 29 |         
 30 |         // extract relevant gate elements
 31 |         Nat bit = getBit(psi.rank, rankTarget);
 32 |         Amp fac0 = gate[bit][bit];
 33 |         Amp fac1 = gate[bit][!bit];
 34 |         
 35 |         // update psi using local and received amps
 36 |         #pragma omp parallel for
 37 |         for (Index i=0; i<psi.numAmpsPerNode; i++)
 38 |             psi.amps[i] = fac0*psi.amps[i] + fac1*psi.buffer[i];
 39 |     }
 40 | }
 41 | 
 42 | 
 43 | static void distributed_statevector_manyCtrlOneTargGate_subroutine(StateVector& psi, NatArray controls, Nat target, AmpMatrix gate) {
 44 |     
 45 |     // controls must be sorted for subsequent insertBits() calls
 46 |     std::sort(controls.begin(), controls.end());
 47 |         
 48 |     Nat localTarget = target - psi.logNumAmpsPerNode;
 49 |     Nat pairRank = flipBit(psi.rank, localTarget);
 50 |     Nat bufferOffset = 0;
 51 | 
 52 |     // because controls.size() > 0, it's gauranteed that numAmpsToMod < logNumAmpsPerNode/2
 53 |     Index numAmpsToMod = psi.numAmpsPerNode / powerOf2(controls.size()); 
 54 | 
 55 |     // pack sub-buffer[0...]
 56 |     #pragma omp parallel for
 57 |     for (Index j=0; j<numAmpsToMod; j++) {
 58 |         Index k = insertBits(j, controls, 1);
 59 |         psi.buffer[j] = psi.amps[k];
 60 |     }
 61 | 
 62 |     // send buffer[0...], receive buffer[bufferOffset...] (gauranteed to fit)
 63 |     bufferOffset = numAmpsToMod;
 64 |     comm_exchangeArrays(psi.buffer, 0, psi.buffer, bufferOffset, numAmpsToMod, pairRank);
 65 |     
 66 |     // extract relevant gate elements
 67 |     Nat bit = getBit(psi.rank, localTarget);
 68 |     Amp fac0 = gate[bit][bit];
 69 |     Amp fac1 = gate[bit][!bit];
 70 |     
 71 |     // update psi using sub-buffer
 72 |     #pragma omp parallel for
 73 |     for (Index j=0; j<numAmpsToMod; j++) {
 74 |         Index k = insertBits(j, controls, 1);
 75 |         Index l = j + bufferOffset;
 76 |         psi.amps[k] = fac0*psi.amps[k] + fac1*psi.buffer[l];
 77 |     }
 78 | }
 79 | 
 80 | 
 81 | static void distributed_statevector_manyCtrlOneTargGate(StateVector& psi, NatArray controls, Nat target, AmpMatrix gate) {
 82 |     
 83 |     NatArray prefixCtrls = NatArray(0);
 84 |     NatArray suffixCtrls = NatArray(0);
 85 |     for(Nat q : controls)
 86 |         if (q >= psi.logNumAmpsPerNode)
 87 |             prefixCtrls.push_back(q - psi.logNumAmpsPerNode);
 88 |         else
 89 |             suffixCtrls.push_back(q);
 90 |             
 91 |     // do nothing if this node fails prefix control condition
 92 |     if (!allBitsAreOne(psi.rank, prefixCtrls))
 93 |         return;
 94 |     
 95 |     // embarrassingly parallel
 96 |     if (target < psi.logNumAmpsPerNode)
 97 |         local_statevector_manyCtrlOneTargGate(psi, suffixCtrls, target, gate);
 98 |     
 99 |     // no suffix controls; effect non-controlled gate
100 |     else if (suffixCtrls.size() == 0)
101 |         distributed_statevector_oneTargGate(psi, target, gate);
102 |     
103 |     // bespoke communication for controls required
104 |     else
105 |         distributed_statevector_manyCtrlOneTargGate_subroutine(psi, suffixCtrls, target, gate);
106 | }
107 | 
108 | 
109 | static void distributed_statevector_swapGate(StateVector &psi, Nat qb1, Nat qb2) {
110 |     
111 |     // ensure qb2 is larger
112 |     if (qb1 > qb2)
113 |         std::swap(qb1, qb2);
114 |         
115 |     // embarrassingly parallel
116 |     if (qb2 < psi.logNumAmpsPerNode)
117 |         local_statevector_swapGate(psi, qb1, qb2);
118 |     
119 |     // zero or one full-statevector swaps
120 |     else if (qb1 >= psi.logNumAmpsPerNode) {
121 |         Nat alt1 = qb1 - psi.logNumAmpsPerNode;
122 |         Nat alt2 = qb2 - psi.logNumAmpsPerNode;
123 | 
124 |         // half of the nodes do nothing, the other half swap
125 |         if (getBit(psi.rank, alt1) != getBit(psi.rank, alt2)) {
126 |             
127 |             Nat pairRank = flipBit(psi.rank, alt1);
128 |             pairRank = flipBit(pairRank, alt2);
129 | 
130 |             // directly swap amps (although MPI arrays must not overlap)
131 |             comm_exchangeArrays(psi.amps, psi.buffer, pairRank);
132 | 
133 |             #pragma omp parallel for
134 |             for (Index j=0; j<psi.numAmpsPerNode; j++)
135 |                 psi.amps[j] = psi.buffer[j];
136 |         }
137 |     }
138 | 
139 |     // contiguous half-statevector swap
140 |     else if (qb1 == psi.logNumAmpsPerNode - 1) {
141 |         Nat alt2 = qb2 - psi.logNumAmpsPerNode;
142 |         Nat pairRank = flipBit(psi.rank, alt2);
143 | 
144 |         // determine whether this node sends former or latter half of amps
145 |         Index numAmpsToMod = psi.numAmpsPerNode / 2;
146 |         Index ampIndOffset = numAmpsToMod * (! getBit(psi.rank, alt2));
147 | 
148 |         // swap half of amps, both nodes receiving to buffer[0...]
149 |         comm_exchangeArrays(psi.amps, ampIndOffset, psi.buffer, 0, numAmpsToMod, pairRank);
150 | 
151 |         // overwrite former or latter half of amps
152 |         #pragma omp parallel for
153 |         for (Index k=0; k<numAmpsToMod; k++) {
154 |             Index j = k + ampIndOffset;
155 |             psi.amps[j] = psi.buffer[k];
156 |         }
157 |     }
158 |     
159 |     // non-contiguous half-statevector swap, via packing
160 |     else {
161 |         Nat alt2 = qb2 - psi.logNumAmpsPerNode;
162 |         Nat pairRank = flipBit(psi.rank, alt2);
163 |         Index numAmpsToMod = psi.numAmpsPerNode / 2;
164 | 
165 |         // determine which bit value of qb1 is to be packed
166 |         Nat bit1 = (! getBit(psi.rank, alt2));
167 | 
168 |         // pack half of amps into buffer, where qb1 = bit1
169 |         #pragma omp parallel for
170 |         for (Index k=0; k<numAmpsToMod; k++) {
171 |             Index j = insertBit(k, qb1, bit1);
172 |             psi.buffer[k] = psi.amps[j];
173 |         }
174 | 
175 |         // swap packed buffers, both nodes receiving to buffer[numAmpsToMod...]
176 |         Index bufferOffset = numAmpsToMod;
177 |         comm_exchangeArrays(psi.buffer, 0, psi.buffer, bufferOffset, numAmpsToMod, pairRank);
178 | 
179 |         // replace same half of amps with buffer contents
180 |         #pragma omp parallel for
181 |         for (Index k=0; k<numAmpsToMod; k++) {
182 |             Index l = k + bufferOffset;
183 |             Index j = insertBit(k, qb1, bit1);
184 |             psi.amps[j] = psi.buffer[l];
185 |         }
186 |     }
187 | }
188 | 
189 | 
190 | static void distributed_statevector_manyTargGate(StateVector &psi, NatArray targets, AmpMatrix gate) {
191 |     assert( targets.size() <= psi.logNumAmpsPerNode );
192 |     
193 |     // locate smallest non-targeted qubit
194 |     Index mask = getBitMask(targets);
195 |     Nat minNonTarg = 0;
196 |     while (getBit(mask, minNonTarg))
197 |         minNonTarg++;
198 |         
199 |     // swap qubits above max into smallest non-targeted
200 |     NatArray newTargs(0);
201 |     for (Nat targ : targets) {
202 |         if (targ < psi.logNumAmpsPerNode)
203 |             newTargs.push_back(targ);
204 |         else {
205 |             newTargs.push_back(minNonTarg);
206 |             minNonTarg++;
207 |             while (getBit(mask, minNonTarg))
208 |                 minNonTarg++;
209 |         }
210 |     }
211 |     
212 |     // perform necessary swaps (each definitely inducing communication)
213 |     for (Nat i=0; i<targets.size(); i++)
214 |         if (newTargs[i] != targets[i])
215 |             distributed_statevector_swapGate(psi, newTargs[i], targets[i]);
216 |             
217 |     // embarrassingly parallel
218 |     local_statevector_manyTargGate(psi, newTargs, gate);
219 |     
220 |     // undo swaps
221 |     for (Nat i=0; i<targets.size(); i++)
222 |         if (newTargs[i] != targets[i])
223 |             distributed_statevector_swapGate(psi, newTargs[i], targets[i]);
224 | }
225 | 
226 | 
227 | static void distributed_statevector_pauliTensorOrGadget_subroutine(StateVector &psi, Nat pairRank, Amp powI, Index maskXY, Index maskYZ, Amp thisAmpFac, Amp otherAmpFac) {
228 |     
229 |     comm_exchangeArrays(psi.amps, psi.buffer, pairRank);
230 |     
231 |     Index rankShift = pairRank << psi.logNumAmpsPerNode;
232 |     
233 |     #pragma omp parallel for
234 |     for (Index j0=0; j0<psi.numAmpsPerNode; j0++) {
235 |         Index j1 = j0 ^ maskXY;
236 |         Index i1 = rankShift | j1;
237 |         Nat p1 = getBitMaskParity(i1 & maskYZ);
238 |         Amp b1 = (1. - 2.*p1) * powI;
239 |         psi.amps[j0] = thisAmpFac*psi.amps[j0] + otherAmpFac*b1*psi.buffer[j1];
240 |     }
241 | }
242 | 
243 | 
244 | static void distributed_statevector_pauliTensorOrGadget(StateVector &psi, NatArray targets, NatArray paulis, Amp thisAmpFac, Amp otherAmpFac) {
245 |     assert( targets.size() == paulis.size() );
246 |     
247 |     // determine powI = i^(number of Y paulis)
248 |     Amp powI = 1;
249 |     for (Nat pauli : paulis)
250 |         if (pauli == Y)
251 |             powI *= Amp(0,1);
252 |             
253 |     // determine pair rank
254 |     Nat pairRank = psi.rank;
255 |     for (Nat i=0; i<targets.size(); i++)
256 |         if (targets[i] >= psi.logNumAmpsPerNode)
257 |             if (paulis[i] == X || paulis[i] == Y)
258 |                 pairRank = flipBit(pairRank, targets[i] - psi.logNumAmpsPerNode);
259 |                 
260 |     NatArray suffixTargsXY(0);
261 |     for (Nat i=0; i<targets.size(); i++)
262 |         if (targets[i] < psi.logNumAmpsPerNode)
263 |             if (paulis[i] == X || paulis[i] == Y)
264 |                 suffixTargsXY.push_back(targets[i]);
265 |     
266 |     Index maskXY = getBitMask(suffixTargsXY);
267 |     Index maskYZ = 0;
268 |     for (Nat i=0; i<targets.size(); i++)
269 |         if (paulis[i] == Y || paulis[i] == Z)
270 |             maskYZ = flipBit(maskYZ, targets[i]);
271 |                 
272 |     if (psi.rank == pairRank)
273 |         local_statevector_pauliTensorOrGadget_subroutine(psi, suffixTargsXY, powI, maskXY, maskYZ, thisAmpFac, otherAmpFac);
274 |     else
275 |         distributed_statevector_pauliTensorOrGadget_subroutine(psi, pairRank, powI, maskXY, maskYZ, thisAmpFac, otherAmpFac);
276 | }
277 | 
278 | 
279 | static void distributed_statevector_pauliTensor(StateVector &psi, NatArray targets, NatArray paulis) {
280 |     Amp thisAmpFac = 0.;
281 |     Amp otherAmpFac = 1.;
282 |     
283 |     distributed_statevector_pauliTensorOrGadget(psi, targets, paulis, thisAmpFac, otherAmpFac);
284 | }
285 | 
286 | 
287 | static void distributed_statevector_pauliGadget(StateVector &psi, NatArray targets, NatArray paulis, Real theta) {
288 |     Amp thisAmpFac = Amp(cos(theta), 0);
289 |     Amp otherAmpFac = Amp(0, sin(theta));
290 |     
291 |     distributed_statevector_pauliTensorOrGadget(psi, targets, paulis, thisAmpFac, otherAmpFac);
292 | }
293 | 
294 | 
295 | static void distributed_statevector_phaseGadget(StateVector &psi, NatArray targets, Real theta) {
296 |     
297 |     local_statevector_phaseGadget(psi, targets, theta);
298 | }
299 | 
300 | 
301 | 
302 | #endif // DISTRIBUTED_STATEVECTOR_HPP


--------------------------------------------------------------------------------
/src/local_densitymatrix.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef LOCAL_DENSITYMATRIX_HPP
  2 | #define LOCAL_DENSITYMATRIX_HPP
  3 | 
  4 | 
  5 | #include "types.hpp"
  6 | #include "states.hpp"
  7 | #include "bit_maths.hpp"
  8 | 
  9 | #include <algorithm>
 10 | 
 11 | 
 12 | static void local_densitymatrix_oneQubitDephasing(DensityMatrix &rho, Nat qb, Real prob) {
 13 | 
 14 |     Amp fac = 1 - 2*prob;
 15 | 
 16 |     if (qb >= rho.numQubits - rho.logNumNodes) {
 17 |         
 18 |         Index numIts = rho.numAmpsPerNode / 2;
 19 |         Nat bit = ! getBit(rho.rank, qb - (rho.numQubits - rho.logNumNodes));
 20 |         
 21 |         #pragma omp parallel for
 22 |         for (Index k=0; k<numIts; k++) {
 23 |             Index j = insertBit(k, qb, bit);
 24 |             rho.amps[j] *= fac;
 25 |         }
 26 |     }
 27 |     
 28 |     else {
 29 |         
 30 |         Index numIts = rho.numAmpsPerNode / 4;
 31 |         Nat altQb = qb + rho.numQubits;
 32 |         
 33 |         #pragma omp parallel for
 34 |         for (Index k=0; k<numIts; k++) {
 35 |             Index j01 = insertTwoBits(k, altQb, 0, qb, 1);
 36 |             rho.amps[j01] *= fac;
 37 |             
 38 |             Index j10 = insertTwoBits(k, altQb, 1, qb, 0);
 39 |             rho.amps[j10] *= fac;
 40 |         }
 41 |     }
 42 | }
 43 | 
 44 | 
 45 | static void local_densitymatrix_twoQubitDephasing(DensityMatrix &rho, Nat qb1, Nat qb2, Real prob) {
 46 |     
 47 |     Index rankShift = rho.rank << rho.logNumAmpsPerNode;
 48 |     Nat alt1 = qb1 + rho.numQubits;
 49 |     Nat alt2 = qb2 + rho.numQubits;
 50 |     Amp term = - 4*prob/3;
 51 |     
 52 |     #pragma omp parallel for
 53 |     for (Index j=0; j<rho.numAmpsPerNode; j++) {
 54 |         Index i = rankShift | j;
 55 |         Nat bit1 = getBit(i, qb1) ^ getBit(i, alt1);
 56 |         Nat bit2 = getBit(i, qb2) ^ getBit(i, alt2);
 57 |         Amp flag = Amp(bit1 | bit2, 0);
 58 |         rho.amps[j] *= flag * term + 1.;
 59 |     }
 60 | }
 61 | 
 62 | 
 63 | static void local_densitymatrix_oneQubitDepolarising(DensityMatrix &rho, Nat qb, Amp c1, Amp c2, Amp c3) {
 64 |     
 65 |     Index numIts = rho.numAmpsPerNode / 4;
 66 |     Nat altQb = qb + rho.numQubits;
 67 |     
 68 |     #pragma omp parallel for
 69 |     for (Index k=0; k<numIts; k++) {
 70 |         Index j00 = insertTwoBits(k, altQb, 0, qb, 0);
 71 |         Index j01 = flipBit(j00, qb);
 72 |         Index j10 = flipBit(j00, altQb);
 73 |         Index j11 = flipBit(j01, altQb);
 74 |         
 75 |         Amp amp00 = rho.amps[j00];
 76 |         rho.amps[j00] = c2*amp00 + c1*rho.amps[j11];
 77 |         rho.amps[j01] *= c3;
 78 |         rho.amps[j10] *= c3;
 79 |         rho.amps[j11] = c1*amp00 + c2*rho.amps[j11];
 80 |     }
 81 | }
 82 | 
 83 | static void local_densitymatrix_twoQubitDepolarising(DensityMatrix &rho, Nat q0, Nat q1, Nat q2, Nat q3, Amp c1, Amp c2, Amp c3) {
 84 |     
 85 |     #pragma omp parallel for
 86 |     for (Index j=0; j<rho.numAmpsPerNode; j++) {
 87 |         Nat flag1 = !(getBit(j, q0) ^ getBit(j, q2));
 88 |         Nat flag2 = !(getBit(j, q1) ^ getBit(j, q3));
 89 |         Amp fac = 1. + c3 * Amp(!(flag1 & flag2), 0);
 90 |         rho.amps[j] *= fac;
 91 |     }
 92 |     
 93 |     Index numIts = rho.numAmpsPerNode / 16;
 94 | 
 95 |     #pragma omp parallel for
 96 |     for (Index k=0; k<numIts; k++) {
 97 |         Index j0000 = insertFourZeroBits(k, q3, q2, q1, q0);
 98 |         Index j0101 = flipTwoBits(j0000, q2, q0);
 99 |         Index j1010 = flipTwoBits(j0000, q3, q1);
100 |         Index j1111 = flipTwoBits(j0101, q3, q1);
101 |         
102 |         Amp term = rho.amps[j0000] + rho.amps[j0101] + rho.amps[j1010] + rho.amps[j1111];
103 |         rho.amps[j0000] = c1*rho.amps[j0000] + c2*term;
104 |         rho.amps[j0101] = c1*rho.amps[j0101] + c2*term;
105 |         rho.amps[j1010] = c1*rho.amps[j1010] + c2*term;
106 |         rho.amps[j1111] = c1*rho.amps[j1111] + c2*term;
107 |     }
108 | }
109 | 
110 | 
111 | static void local_densitymatrix_damping(DensityMatrix &rho, Nat qb, Real prob) {
112 |     
113 |     Nat qbAlt = qb + rho.numQubits;
114 |     Amp c1 = sqrt(1 - prob);
115 |     Amp c2 = 1 - prob;
116 | 
117 |     Index numIts = rho.numAmpsPerNode / 4;
118 | 
119 |     #pragma omp parallel for
120 |     for (Index k=0; k<numIts; k++) {
121 |         Index j00 = insertTwoBits(k, qbAlt, 0, qb, 0);
122 |         Index j01 = flipBit(j00, qb);
123 |         Index j10 = flipBit(j00, qbAlt);
124 |         Index j11 = flipBit(j01, qbAlt);
125 |         
126 |         rho.amps[j00] += prob*rho.amps[j11];
127 |         rho.amps[j01] *= c1;
128 |         rho.amps[j10] *= c1;
129 |         rho.amps[j11] *= c2;
130 |     }
131 | }
132 | 
133 | 
134 | static DensityMatrix local_densitymatrix_partialTrace(DensityMatrix &inRho, NatArray targs, NatArray pairTargs) {
135 | 
136 |     DensityMatrix outRho = DensityMatrix(inRho.numQubits - targs.size());
137 | 
138 |     // sort all targets
139 |     NatArray allTargs = targs;
140 |     allTargs.insert(allTargs.end(), pairTargs.begin(), pairTargs.end());
141 |     std::sort(allTargs.begin(), allTargs.end());
142 | 
143 |     Index numTracedAmps = powerOf2(targs.size());
144 | 
145 |     #pragma omp parallel for
146 |     for (Index l=0; l<outRho.numAmpsPerNode; l++) {
147 | 
148 |         outRho.amps[l] = 0.;
149 | 
150 |         Index lMask = insertBits(l, allTargs, 0);
151 | 
152 |         for (Index k=0; k<numTracedAmps; k++) {
153 | 
154 |             Index i = lMask;
155 |             i = setBits(i, targs, k);
156 |             i = setBits(i, pairTargs, k);
157 | 
158 |             outRho.amps[l] += inRho.amps[i];
159 |         }
160 |     }
161 | 
162 |     // return-value optimisation in most compilers should avoid a copy here
163 |     return outRho;
164 | }
165 | 
166 | 
167 | #endif // LOCAL_DENSITYMATRIX_HPP


--------------------------------------------------------------------------------
/src/local_statevector.hpp:
--------------------------------------------------------------------------------
  1 | 
  2 | #ifndef LOCAL_STATEVECTOR_HPP
  3 | #define LOCAL_STATEVECTOR_HPP
  4 | 
  5 | 
  6 | #include "types.hpp"
  7 | #include "states.hpp"
  8 | #include "bit_maths.hpp"
  9 | 
 10 | #include <algorithm>
 11 | #include <cmath>
 12 | 
 13 | 
 14 | static void local_statevector_oneTargGate(StateVector& psi, Nat target, AmpMatrix gate) {
 15 |     
 16 |     Index numIts = psi.numAmpsPerNode / 2;
 17 |     
 18 |     #pragma omp parallel for
 19 |     for (Index j=0; j<numIts; j++) {
 20 |         Index i0 = insertBit(j, target, 0);
 21 |         Index i1 = flipBit(i0, target);
 22 |         
 23 |         Amp amp0 = psi.amps[i0];
 24 |         Amp amp1 = psi.amps[i1];
 25 |         
 26 |         psi.amps[i0] = gate[0][0]*amp0 + gate[0][1]*amp1;
 27 |         psi.amps[i1] = gate[1][0]*amp0 + gate[1][1]*amp1;
 28 |     }
 29 | }
 30 | 
 31 | 
 32 | static void local_statevector_manyCtrlOneTargGate(StateVector& psi, NatArray controls, Nat target, AmpMatrix gate) {
 33 |     
 34 |     NatArray qubits = controls;
 35 |     qubits.push_back(target);
 36 |     std::sort(qubits.begin(), qubits.end());
 37 |     
 38 |     Index numIts = psi.numAmpsPerNode / powerOf2(qubits.size());
 39 |     
 40 |     #pragma omp parallel for
 41 |     for (Index j=0; j<numIts; j++) {
 42 |         Index i1 = insertBits(j, qubits, 1);
 43 |         Index i0 = flipBit(i1, target);
 44 |         
 45 |         Amp amp0 = psi.amps[i0];
 46 |         Amp amp1 = psi.amps[i1];
 47 |         
 48 |         psi.amps[i0] = gate[0][0]*amp0 + gate[0][1]*amp1;
 49 |         psi.amps[i1] = gate[1][0]*amp0 + gate[1][1]*amp1;
 50 |     }
 51 | }
 52 | 
 53 | 
 54 | static void local_statevector_swapGate(StateVector &psi, Nat qb1, Nat qb2) {
 55 |     
 56 |     // ensure qb2 is larger
 57 |     if (qb1 > qb2)
 58 |         std::swap(qb1, qb2);
 59 |         
 60 |     Index numIts = psi.numAmpsPerNode / 4;
 61 | 
 62 |     #pragma omp parallel for
 63 |     for (Index k=0; k<numIts; k++) {
 64 |         Index j11 = insertTwoBits(k, qb2, 1, qb1, 1);
 65 |         Index j10 = flipBit(j11, qb1);
 66 |         Index j01 = flipBit(j11, qb2);
 67 |         std::swap(psi.amps[j01], psi.amps[j10]);
 68 |     }
 69 | }
 70 | 
 71 | 
 72 | static void local_statevector_manyTargGate(StateVector &psi, NatArray targets, AmpMatrix gate) {
 73 |     
 74 |     // each thread receives private cache copy
 75 |     AmpArray cache(gate.size());
 76 |     NatArray qubits = targets;
 77 |     std::sort(qubits.begin(), qubits.end());
 78 |     
 79 |     Index numInnerIts = gate.size();
 80 |     Index numOuterIts = psi.numAmpsPerNode / numInnerIts;
 81 | 
 82 |     #pragma omp parallel for firstprivate(cache)
 83 |     for (Index k=0; k<numOuterIts; k++) {
 84 |         
 85 |         Index baseInd = insertBits(k, qubits, 0);
 86 |         
 87 |         for (Index j=0; j<numInnerIts; j++) {
 88 |             Index i = setBits(baseInd, targets, j);
 89 |             cache[j] = psi.amps[i];
 90 |         }
 91 |         
 92 |         for (Index j=0; j<numInnerIts; j++) {
 93 |             Index i = setBits(baseInd, targets, j);
 94 |             psi.amps[i] = 0;
 95 |             for (Index l=0; l<numInnerIts; l++)
 96 |                 psi.amps[i] += gate[j][l] * cache[l];
 97 |         }
 98 |     }
 99 | }
100 | 
101 | 
102 | static void local_statevector_pauliTensorOrGadget_subroutine(StateVector &psi, NatArray targs, Amp powI, Index maskXY, Index maskYZ, Amp thisAmpFac, Amp otherAmpFac) {
103 |     
104 |     // targs must be incresaing order before subsequent calls of insertBits()
105 |     std::sort(targs.begin(), targs.end());
106 | 
107 |     Index numOuterIts = psi.numAmpsPerNode / powerOf2(targs.size());
108 |     Index numInnerIts = powerOf2(targs.size()) / 2;
109 |     Index rankShift = psi.rank << psi.logNumAmpsPerNode;
110 |     
111 |     #pragma omp parallel for
112 |     for (Index k=0; k<numOuterIts; k++) {
113 |         Index h = insertBits(k, targs, 0);
114 |         
115 |         for (Index l=0; l<numInnerIts; l++) {
116 |             
117 |             // determine indices and signs of amps swapped by X and Y
118 |             Index j0 = setBits(h, targs, l);
119 |             Index i0 = rankShift | j0;
120 |             Nat p0 = getBitMaskParity(i0 & maskYZ);
121 |             Amp b0 = (1. - 2.*p0) * powI;
122 |             
123 |             Index j1 = j0 ^ maskXY;
124 |             Index i1 = rankShift | j1;
125 |             Nat p1 = getBitMaskParity(i1 & maskYZ);
126 |             Amp b1 = (1. - 2.*p1) * powI;
127 |             
128 |             // mix scaled amps (swaps scaled amps if theta=)
129 |             Amp amp0 = psi.amps[j0];
130 |             Amp amp1 = psi.amps[j1];
131 |             psi.amps[j0] = thisAmpFac*amp0 + otherAmpFac*b1*amp1;
132 |             psi.amps[j1] = thisAmpFac*amp1 + otherAmpFac*b0*amp0;
133 |         }
134 |     }
135 | }
136 | 
137 | 
138 | static void local_statevector_phaseGadget(StateVector &psi, NatArray targets, Real theta) {
139 |         
140 |     Index rankShift = psi.rank << psi.logNumAmpsPerNode;
141 |     Index targMask = getBitMask(targets);
142 |     
143 |     Amp fac0 = Amp(cos(theta), +sin(theta)); // exp(+i theta)
144 |     Amp fac1 = Amp(cos(theta), -sin(theta)); // exp(-i theta)
145 |     AmpArray facs = {fac0, fac1};
146 |     
147 |     #pragma omp parallel for
148 |     for (Index j=0; j<psi.numAmpsPerNode; j++) {
149 |         Index i = rankShift | j;
150 |         Nat p = getBitMaskParity(i & targMask);
151 |         psi.amps[j] *= facs[p]; // fac1*p + fac0*(!p);
152 |     }
153 | }
154 | 
155 | 
156 | #endif // LOCAL_STATEVECTOR_HPP


--------------------------------------------------------------------------------
/src/misc.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef MISC_HPP
  2 | #define MISC_HPP
  3 | 
  4 | 
  5 | #include <algorithm>
  6 | 
  7 | #include "bit_maths.hpp"
  8 | #include "types.hpp"
  9 | 
 10 | 
 11 | 
 12 | /* 
 13 |  * Relatively fast compared to caller; can be used in tight-loops
 14 |  */
 15 | 
 16 | INLINE Amp getPauliTensorElem(Nat* pauliCodes, Nat numQubits, Index flatInd) {
 17 |     
 18 |     AmpMatrix I{{1,0},{0,1}};
 19 |     AmpMatrix X{{0,1},{1,0}};
 20 |     AmpMatrix Y{{0,Amp(0,-1)},{Amp(0,1),0}};
 21 |     AmpMatrix Z{{1,0},{0,-1}};
 22 |     MatrixArray pauliMatrices{ I, X, Y, Z };
 23 |     
 24 |     Amp elem = 1.;
 25 |     
 26 |     for (Nat q=0; q<numQubits; q++) {
 27 |         Nat code = pauliCodes[q];
 28 |         AmpMatrix matrix = pauliMatrices[code];
 29 |         
 30 |         Nat colBit = getBit(flatInd, q);
 31 |         Nat rowBit = getBit(flatInd, q + numQubits);
 32 |     
 33 |         Amp fac = matrix[rowBit][colBit];
 34 |         elem *= fac;
 35 |     }
 36 | 
 37 |     return elem;
 38 | }
 39 | 
 40 | 
 41 | 
 42 | /* 
 43 |  * Slow; not to be used in tight-loops
 44 |  */
 45 | 
 46 | 
 47 | static bool containsOddNumY(NatArray paulis) {
 48 |     
 49 |     bool isOddNumY = false;
 50 |     for (Nat op : paulis)
 51 |         if ((PauliOperator) op == Y)
 52 |             isOddNumY = ! isOddNumY;
 53 |             
 54 |     return isOddNumY;
 55 | }
 56 | 
 57 | 
 58 | static AmpMatrix getSuperoperator(MatrixArray krausOps) {
 59 |     
 60 |     Index krausDim = krausOps[0].size();
 61 |     Index superDim = krausDim * krausDim;
 62 |     AmpMatrix superOp = getZeroMatrix(superDim);
 63 |     
 64 |     for (AmpMatrix krausOp : krausOps) {
 65 |         
 66 |         // superOp += conj(krausOp) (tensor) krausOp
 67 | 
 68 |         #pragma omp parallel for
 69 |         for (Index i=0; i<krausDim; i++)
 70 |             for (Index j=0; j<krausDim; j++)
 71 |                 for (Index k=0; k<krausDim; k++)
 72 |                     for (Index l=0; l<krausDim; l++) {
 73 |                         Index r = i*krausDim + k;
 74 |                         Index c = j*krausDim + l;
 75 |                         Amp term = conj(krausOp[i][j]) * krausOp[k][l];
 76 |                         superOp[r][c] += term;
 77 |                     }
 78 |     }
 79 |     
 80 |     return superOp;        
 81 | }
 82 | 
 83 | 
 84 | static NatArray getReorderedAllSuffixTargets(NatArray targets, Nat suffixSize) {
 85 | 
 86 |     // locate largest non-targeted qubit of the suffix subregister
 87 |     Index targetMask = getBitMask(targets);
 88 |     Nat maxSuffixNonTarg = getNextLeftmostZeroBit(targetMask, suffixSize);
 89 |         
 90 |     // determine desired target ordering, where prefix targets are swapped with largest un-targeted un-swapped suffix qubits
 91 |     NatArray reorderedTargets(0);
 92 |     for (Nat q = targets.size(); q-- != 0; ) {
 93 |         if (targets[q] < suffixSize)
 94 |             reorderedTargets.push_back(targets[q]);
 95 |         else {
 96 |             reorderedTargets.push_back(maxSuffixNonTarg);
 97 |             maxSuffixNonTarg = getNextLeftmostZeroBit(targetMask, maxSuffixNonTarg);
 98 |         }
 99 |     }
100 |     std::reverse(reorderedTargets.begin(), reorderedTargets.end());
101 | 
102 |     return reorderedTargets;
103 | }
104 | 
105 | 
106 | static NatArray getNonTargetedQubitOrder(Nat numAllQubits, NatArray originalTargets, NatArray reorderedTargets) {
107 | 
108 |     // determine the ordering of all qubits after swaps
109 |     NatArray allQubits(numAllQubits);
110 |     for (Nat q=0; q<allQubits.size(); q++)
111 |         allQubits[q] = q;
112 |     for (Nat q=0; q<reorderedTargets.size(); q++) {
113 |         Nat qb1 = originalTargets[q];
114 |         Nat qb2 = reorderedTargets[q];
115 |         if (qb1 != qb2)
116 |             std::swap(allQubits[qb1], allQubits[qb2]);
117 |     }
118 | 
119 |     // remove the targeted qubit indices, momentarily maintaining non-targeted indices
120 |     NatArray remainingQubits(0);
121 |     Index reorderedMask = getBitMask(reorderedTargets);
122 |     for (Nat i=0; i<allQubits.size(); i++)
123 |         if (!getBit(reorderedMask, i))
124 |             remainingQubits.push_back(allQubits[i]);
125 | 
126 |     // shift remaining qubits to be contiguous [0, ..., 2N-len(reorderedTargets))
127 |     Index remainingMask = getBitMask(remainingQubits);
128 |     for (Nat &q : remainingQubits) {
129 |         Nat p = q;
130 |         for (Nat i=0; i<p; i++)
131 |             q -= ! getBit(remainingMask, i);
132 |     }
133 | 
134 |     return remainingQubits;
135 | }
136 | 
137 | 
138 | 
139 | #endif // MISC_HPP


--------------------------------------------------------------------------------
/src/states.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef STATES_HPP
 2 | #define STATES_HPP
 3 | 
 4 | #include "types.hpp"
 5 | #include "bit_maths.hpp"
 6 | #include "misc.hpp"
 7 | #include "communication.hpp"
 8 | 
 9 | #include <assert.h>
10 | 
11 | 
12 | 
13 | class StateVector {
14 |     
15 | public:
16 |     Nat rank;
17 |     Nat numNodes;
18 |     Nat logNumNodes;
19 |     
20 |     Nat numQubits;
21 |     Index numAmpsPerNode;
22 |     Index logNumAmpsPerNode;
23 |     
24 |     AmpArray amps;
25 |     AmpArray buffer;
26 |     
27 |     AmpArray getAllVecAmps();
28 |     void setRandomAmps();
29 |     void printAmps();
30 |     bool agreesWith(AmpArray allAmps, Real tol);
31 |     
32 |     StateVector(Nat numQubits) {
33 |         
34 |         // enforces >=1 statevec amp per node, and >=1 density-matrix column per node
35 |         assert( powerOf2(numQubits) >= comm_getNumNodes() );
36 |         
37 |         this->rank = comm_getRank();
38 |         this->numNodes = comm_getNumNodes();
39 |         
40 |         this->numQubits = numQubits;
41 |         this->logNumNodes = logBase2(this->numNodes);
42 |         
43 |         this->logNumAmpsPerNode = (numQubits - this->logNumNodes);
44 |         this->numAmpsPerNode = powerOf2(this->logNumAmpsPerNode);
45 |         
46 |         this->amps = AmpArray(this->numAmpsPerNode, 0);
47 |         this->buffer = AmpArray(this->numAmpsPerNode, 0);
48 |     }
49 | };
50 | 
51 | 
52 | 
53 | class DensityMatrix : public StateVector {
54 | 
55 | public:
56 |     
57 |     AmpMatrix getAllMatrAmps();
58 |     bool agreesWith(AmpMatrix allAmps, Real tol);
59 |     
60 |     DensityMatrix(Nat numQubits) : StateVector(numQubits) {
61 |         
62 |         // increase the number of initialised statevector amps 
63 |         this->logNumAmpsPerNode = (2*numQubits - this->logNumNodes);
64 |         this->numAmpsPerNode = powerOf2(this->logNumAmpsPerNode);
65 |         
66 |         this->amps.resize(this->numAmpsPerNode, 0);
67 |         this->buffer.resize(this->numAmpsPerNode, 0);
68 |     }
69 | };
70 | 
71 | 
72 | 
73 | #endif // STATES_HPP


--------------------------------------------------------------------------------
/src/types.hpp:
--------------------------------------------------------------------------------
  1 | 
  2 | #ifndef TYPES_HPP
  3 | #define TYPES_HPP
  4 | 
  5 | 
  6 | #include <complex>
  7 | #include <vector>
  8 | #include <assert.h>
  9 | 
 10 | 
 11 | 
 12 | /*
 13 |  * interface for specifying Pauli tensors and gadgets
 14 |  */
 15 | 
 16 | enum PauliOperator {
 17 |     I, X, Y, Z
 18 | };
 19 | 
 20 | 
 21 | 
 22 | /*
 23 |  * numerical precision config 
 24 |  */
 25 |  
 26 | typedef double Real;
 27 | typedef unsigned int Nat;
 28 | typedef long long unsigned int Index;
 29 | #define MPI_AMP MPI_DOUBLE_COMPLEX
 30 | 
 31 | 
 32 | 
 33 | /*
 34 |  * local complex, array, matrix convenience types 
 35 |  */
 36 |  
 37 | typedef std::complex<Real> Amp;
 38 | typedef std::vector<Amp> AmpArray;
 39 | typedef std::vector<AmpArray> AmpMatrix;
 40 | typedef std::vector<Nat> NatArray;
 41 | typedef std::vector<AmpMatrix> MatrixArray;
 42 | typedef std::vector<Real> RealArray;
 43 | 
 44 | 
 45 | 
 46 | /*
 47 |  * inform OpenMP how to reduce Amp
 48 |  */
 49 | 
 50 | #pragma omp declare	reduction(+ : Amp : omp_out += omp_in ) initializer( omp_priv = omp_orig )
 51 | 
 52 | 
 53 | 
 54 | /*
 55 |  * operator overloads for array and matrix
 56 |  */
 57 | 
 58 | static AmpMatrix getZeroMatrix(Index dim) {
 59 |     assert( dim > 0 );
 60 |     
 61 |     AmpMatrix matrix = AmpMatrix(dim);
 62 |     for (Index r=0; r<dim; r++)
 63 |         matrix[r] = AmpArray(dim, 0);
 64 |     return matrix;
 65 | }
 66 | 
 67 | 
 68 | static AmpMatrix getIdentityMatrix(Index dim) {
 69 |     assert( dim > 0 );
 70 |     
 71 |     AmpMatrix matrix = getZeroMatrix(dim);
 72 |     for (Index r=0; r<dim; r++)
 73 |         matrix[r][r] = 1;
 74 |     return matrix;
 75 | }
 76 | 
 77 | 
 78 | static AmpMatrix getConjugateMatrix(AmpMatrix matrOrig) {
 79 |     AmpMatrix matrConj = getZeroMatrix(matrOrig.size());
 80 |     for (Index r=0; r<matrConj.size(); r++)
 81 |         for (Index c=0; c<matrConj.size(); c++)
 82 |             matrConj[r][c] = conj(matrOrig[r][c]);
 83 |     return matrConj;
 84 | }
 85 | 
 86 | 
 87 | static AmpMatrix getDaggerMatrix(AmpMatrix matrOrig) {
 88 |     AmpMatrix matrDag = getZeroMatrix(matrOrig.size());
 89 |     for (Index r=0; r<matrDag.size(); r++)
 90 |         for (Index c=0; c<matrDag.size(); c++)
 91 |             matrDag[r][c] = conj(matrOrig[c][r]);
 92 |     return matrDag;
 93 | }
 94 | 
 95 | 
 96 | static AmpMatrix operator * (const Amp& f, const AmpMatrix& m) {
 97 |     AmpMatrix out = m;
 98 |     for (Nat r=0; r<out.size(); r++)
 99 |         for (Nat c=0; c<out.size(); c++)
100 |             out[r][c] *= f;
101 |     return out;
102 | }
103 | 
104 | 
105 | static AmpMatrix operator * (const AmpMatrix& m1, const AmpMatrix& m2) {
106 |     assert( m1.size() == m2.size() );
107 |     
108 |     AmpMatrix prod = getZeroMatrix(m1.size());
109 |     for (Nat r=0; r<m1.size(); r++)
110 |         for (Nat c=0; c<m1.size(); c++)
111 |             for (Nat k=0; k<m1.size(); k++)
112 |                 prod[r][c] += m1[r][k] * m2[k][c];
113 |     return prod;
114 | }
115 | 
116 | 
117 | static AmpMatrix operator + (const AmpMatrix& m1, const AmpMatrix& m2) {
118 |     assert( m1.size() == m2.size() );
119 |     
120 |     AmpMatrix res = m1;
121 |     for (Nat r=0; r<m2.size(); r++)
122 |         for (Nat c=0; c<m2.size(); c++)
123 |             res[r][c] += m2[r][c];
124 |     return res;
125 | }
126 | 
127 | 
128 | static AmpMatrix operator % (const AmpMatrix& a, const AmpMatrix& b) {
129 |     
130 |     // Kronecker product
131 |     AmpMatrix prod = getZeroMatrix(a.size() * b.size());
132 |     for (Index r=0; r<b.size(); r++)
133 |         for (Index c=0; c<b.size(); c++)
134 |             for (Index i=0; i<a.size(); i++)
135 |                 for (Index j=0; j<a.size(); j++)
136 |                     prod[r+b.size()*i][c+b.size()*j] = a[i][j] * b[r][c];
137 |     return prod;
138 | }
139 | 
140 | 
141 | static AmpArray operator * (const AmpMatrix& m, const AmpArray& v) {
142 |     assert( m.size() == v.size() );
143 |     
144 |     AmpArray prod = AmpArray(v.size());
145 |     for (Nat r=0; r<v.size(); r++)
146 |         for (Nat c=0; c<v.size(); c++)
147 |             prod[r] += m[r][c] * v[c];
148 |     return prod;
149 | }
150 | 
151 | 
152 | 
153 | #endif // TYPES_HPP


--------------------------------------------------------------------------------
/tests/test_utilities.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef TEST_UTILITIES_HPP
  2 | #define TEST_UTILITIES_HPP
  3 | 
  4 | 
  5 | #include "types.hpp"
  6 | #include "bit_maths.hpp"
  7 | #include "states.hpp"
  8 | #include "misc.hpp"
  9 | 
 10 | #include <random>
 11 | #include <iostream>
 12 | #include <algorithm>
 13 | #include <assert.h>
 14 | 
 15 | 
 16 | #include "catch_amalgamated.hpp"
 17 | 
 18 | 
 19 | Real PI = 3.14159265358979323846;
 20 | 
 21 | AmpMatrix matrI = {{1,0}, {0,1}};
 22 | AmpMatrix matrX = {{0,1}, {1,0}};
 23 | AmpMatrix matrY = {{0,Amp(0,-1)}, {Amp(0,1),0}};
 24 | AmpMatrix matrZ = {{1,0}, {0,-1}};
 25 | 
 26 | 
 27 | static void printMatrix(AmpMatrix matrix) {
 28 |     for (Nat r=0; r<matrix.size(); r++) {
 29 |         for (Nat c=0; c<matrix.size(); c++)
 30 |             std::cout << matrix[r][c] << " ";
 31 |         std::cout << "\n";
 32 |     }
 33 | }
 34 | 
 35 | 
 36 | template<typename T> 
 37 | static void printArray(std::vector<T> array) {
 38 |     std::cout << "{";
 39 |     for (Nat i=0; i<array.size(); i++)
 40 |         std::cout << array[i] << ((i<array.size()-1)? " ":"");
 41 |     std::cout << "}\n" << std::flush;
 42 | }
 43 | 
 44 | 
 45 | static void rootNodePrint(std::string msg) {
 46 |     comm_synch();
 47 |     std::cout << std::flush;
 48 |     comm_synch();
 49 |     if (comm_getRank() == 0)
 50 |         std::cout << msg << "\n" << std::flush;
 51 |     comm_synch();
 52 | }
 53 | 
 54 | 
 55 | template<typename T>
 56 | static void allNodesPrintLocalArray(std::vector<T> array) {
 57 |     Nat thisRank = comm_getRank();
 58 |     Nat numNodes = comm_getNumNodes();
 59 |     for (Nat rank=0; rank<numNodes; rank++) {
 60 |         if (rank == thisRank) {
 61 |             std::cout << "  rank: " << rank << "\n    ";
 62 |             printArray(array);
 63 |         }
 64 |         comm_synch();
 65 |     }
 66 |     comm_synch();
 67 |     std::cout << std::flush;
 68 |     comm_synch();
 69 | }
 70 | 
 71 | 
 72 | template<typename T>
 73 | static void rootNodePrintLocalArray(std::vector<T> array) {
 74 |     comm_synch();
 75 |     if (comm_getRank() == 0)
 76 |         printArray(array);
 77 |     comm_synch();
 78 |     std::cout << std::flush;
 79 |     comm_synch();
 80 | }
 81 | 
 82 | 
 83 | static Nat getRandomNat(Nat minInclusive, Nat maxExclusive) {
 84 |     assert( maxExclusive > minInclusive );
 85 | 
 86 |     // unimportantly uniform (and MPI-safe)
 87 |     Nat n = maxExclusive - minInclusive;
 88 |     Nat r = (Nat) (rand() % n);
 89 |     Nat result = minInclusive + r;
 90 |     return result;
 91 | }
 92 | 
 93 | 
 94 | static Real getRandomReal(Real minInclusive, Real maxExclusive) {
 95 | 
 96 |     Real r = rand()/(Real) RAND_MAX;
 97 |     Real result = minInclusive + r*(maxExclusive - minInclusive);
 98 |     return result;
 99 | }
100 | 
101 | 
102 | static RealArray getRandomRealArray(Real minInclusive, Real maxExclusive, Nat numElems) {
103 |     assert( maxExclusive > minInclusive );
104 |     assert( numElems > 0 );
105 | 
106 |     RealArray arr = RealArray(numElems);
107 |     for (Real& elem : arr)
108 |         elem = getRandomReal(minInclusive, maxExclusive);
109 | 
110 |     return arr;
111 | }
112 | 
113 | 
114 | static Amp getRandomAmp() {
115 |     
116 |     // generate 2 normally-distributed random numbers via Box-Muller (MPI-safe)
117 |     Real a = rand()/(Real) RAND_MAX;
118 |     Real b = rand()/(Real) RAND_MAX;
119 |     Real r1 = sqrt(-2 * log(a)) * cos(2 * 3.14159265 * b);
120 |     Real r2 = sqrt(-2 * log(a)) * sin(2 * 3.14159265 * b);
121 |     return Amp(r1, r2);
122 | }
123 | 
124 | 
125 | static AmpArray getRandomArray(Index dim) {
126 |     assert( dim > 0 );
127 |     
128 |     AmpArray arr = AmpArray(dim);
129 |     for (Index i=0; i<dim; i++)
130 |         arr[i] = getRandomAmp();
131 |     return arr;
132 | }
133 | 
134 | 
135 | static AmpMatrix getRandomMatrix(Index dim) {
136 |     assert( dim > 0 );
137 |     
138 |     AmpMatrix matr = getZeroMatrix(dim);
139 |     for (Index i=0; i<dim; i++)
140 |         for (Index j=0; j<dim; j++)
141 |             matr[i][j] = getRandomAmp();
142 |     return matr;
143 | }
144 | 
145 | 
146 | static MatrixArray getRandomMatrices(Index dim, Nat numMatrices) {
147 |     assert( dim > 0 );
148 |     assert( numMatrices > 0 );
149 | 
150 |     MatrixArray matrices(numMatrices);
151 |     for (AmpMatrix& matrix : matrices)
152 |         matrix = getRandomMatrix(dim);
153 | 
154 |     return matrices;
155 | }
156 | 
157 | 
158 | static NatArray getRandomNatArray(Nat minIncl, Nat maxExcl, Nat numElem) {
159 |     assert( maxExcl > minIncl );
160 |     assert( numElem > 0 );
161 | 
162 |     NatArray choices(numElem);
163 |     for (Nat i=0; i<numElem; i++)
164 |         choices[i] = getRandomNat(minIncl, maxExcl);
165 | 
166 |     return choices;
167 | }
168 | 
169 | 
170 | static NatArray getRandomUniqueNatArray(Nat minIncl, Nat maxExcl, Nat numElem) {
171 |     assert( maxExcl > minIncl );
172 |     assert( numElem > 0 );
173 |     Nat numAllChoices = maxExcl - minIncl;
174 |     assert( numElem <= numAllChoices );
175 | 
176 |     // generate [minIncl,maxExcl)
177 |     NatArray allChoices(numAllChoices);
178 |     for (Nat i=0; i<numAllChoices; i++)
179 |         allChoices[i] = minIncl + i;
180 | 
181 |     // shuffle [minIncl,maxExcl)
182 |     Nat numReps = 10*numAllChoices;
183 |     while ((numReps--) > 0) {
184 |         Nat i = getRandomNat(0, numAllChoices);
185 |         Nat j = getRandomNat(0, numAllChoices);
186 |         std::swap(allChoices[i], allChoices[j]);
187 |     }
188 | 
189 |     // select first numElem
190 |     NatArray choices(allChoices.begin(), allChoices.begin()+numElem);
191 |     return choices;
192 | }
193 | 
194 | 
195 | static NatArray getRandomUniqueNatArray(Nat minIncl, Nat maxExcl, Nat numElem, Nat exclude) {
196 |     assert( exclude >= minIncl && exclude < maxExcl );
197 |     assert( (maxExcl - minIncl) > numElem ); // we need 1 for exclude
198 | 
199 |     NatArray choices = getRandomUniqueNatArray(minIncl, maxExcl, numElem);
200 | 
201 |     for (Nat i=0; i<choices.size(); i++)
202 |         if (choices[i] == exclude) {
203 | 
204 |             // find first not-included element
205 |             Nat notIncluded = minIncl;
206 |             while (std::find(choices.begin(), choices.end(), notIncluded) != choices.end())
207 |                 notIncluded++;
208 | 
209 |             // replace bad element with it
210 |             choices[i] = notIncluded;
211 |             break;
212 |         }
213 | 
214 |     return choices;
215 | }
216 | 
217 | 
218 | static void ensureNotAllPauliZ(NatArray& paulis) {
219 |     for (Nat pauli : paulis)
220 |         if (pauli != 3)
221 |             return;
222 |     
223 |     paulis[0] = getRandomNat(1, 2+1);
224 | }
225 | 
226 | 
227 | AmpMatrix getExponentialOfPauliTensor(Real angle, AmpMatrix pauliTensor) {
228 |     AmpMatrix iden = getIdentityMatrix(pauliTensor.size());
229 |     AmpMatrix expo = (cos(angle) * iden) + (Amp(0,1) * sin(angle) * pauliTensor);
230 |     return expo;
231 | }
232 | 
233 | 
234 | static void setSubMatrix(AmpMatrix &dest, AmpMatrix sub, Index r, Index c) {
235 |     assert( r + sub.size() <= dest.size() );
236 |     assert( c + sub.size() <= dest.size() );
237 |     
238 |     for (Nat i=0; i<sub.size(); i++)
239 |         for (Nat j=0; j<sub.size(); j++)
240 |             dest[r+i][c+j] = sub[i][j];
241 | }
242 | 
243 | 
244 | static AmpMatrix getFullSwapMatrix(Nat qb1, Nat qb2, Nat numQb) {
245 |     assert( qb1 < numQb && qb2 < numQb );
246 |     
247 |     if (qb1 > qb2)
248 |         std::swap(qb1, qb2);
249 |         
250 |     if (qb1 == qb2)
251 |         return getIdentityMatrix(powerOf2(numQb));
252 | 
253 |     AmpMatrix swap;
254 |     
255 |     if (qb2 == qb1 + 1) {
256 |         // qubits are adjacent
257 |         swap = AmpMatrix{{1,0,0,0},{0,0,1,0},{0,1,0,0},{0,0,0,1}};
258 |         
259 |     } else {
260 |         // qubits are distant
261 |         Index block = powerOf2(qb2 - qb1);
262 |         swap = getZeroMatrix(block*2);
263 |         AmpMatrix iden = getIdentityMatrix(block/2);
264 |         
265 |         // Lemma 3.1 of arxiv.org/pdf/1711.09765.pdf
266 |         AmpMatrix p0{{1,0},{0,0}};
267 |         AmpMatrix l0{{0,1},{0,0}};
268 |         AmpMatrix l1{{0,0},{1,0}};
269 |         AmpMatrix p1{{0,0},{0,1}};
270 |         
271 |         /* notating a^(n+1) = identity(1<<n) (otimes) a, we construct the matrix
272 |          * [ p0^(N) l1^N ]
273 |          * [ l0^(N) p1^N ]
274 |          * where N = qb2 - qb1 */
275 |         setSubMatrix(swap, iden % p0, 0, 0);
276 |         setSubMatrix(swap, iden % l0, block, 0);
277 |         setSubMatrix(swap, iden % l1, 0, block);
278 |         setSubMatrix(swap, iden % p1, block, block);
279 |     }
280 |     
281 |     // pad swap with outer identities
282 |     if (qb1 > 0)
283 |         swap = swap % getIdentityMatrix(powerOf2(qb1));
284 |     if (qb2 < numQb-1)
285 |         swap = getIdentityMatrix(powerOf2(numQb-qb2-1)) % swap;
286 |     
287 |     return swap;
288 | }
289 | 
290 | 
291 | static bool containsDuplicate(NatArray list1, NatArray list2) {
292 |     NatArray combined = list1;
293 |     combined.insert(combined.end(), list2.begin(), list2.end());
294 |     std::sort(combined.begin(), combined.end());
295 |     for (Nat i=0; i<combined.size()-1; i++)
296 |         if (combined[i+1] == combined[i])
297 |             return true;
298 |     return false;
299 | }
300 | 
301 | 
302 | static AmpMatrix getFullGateMatrix(AmpMatrix gateMatr, NatArray ctrls, NatArray targs, Nat numQb) {
303 |     assert( targs.size() > 0 );
304 |     assert( ctrls.size() + targs.size() <= numQb );
305 |     assert( gateMatr.size() == powerOf2(targs.size()) );
306 |     assert( !containsDuplicate(ctrls, targs) );
307 |     assert( *std::max_element(targs.begin(), targs.end()) < numQb );
308 |     if (ctrls.size() > 0)
309 |         assert( *std::max_element(ctrls.begin(), ctrls.end()) < numQb );
310 | 
311 |     // concatenate all qubits
312 |     NatArray qubits = targs;
313 |     qubits.insert( qubits.end(), ctrls.begin(), ctrls.end() );
314 |     
315 |     // create sub-matrix with qubits #(ctrls+targs), with left-most controlled and 
316 |     // rightmost targetted as if qubits = {0,1,2,3,...}
317 |     Index subDim = powerOf2(qubits.size());
318 |     Index subInd = subDim - gateMatr.size();
319 |     AmpMatrix subMatr = getIdentityMatrix(subDim);
320 |     setSubMatrix(subMatr, gateMatr, subInd, subInd);
321 |     
322 |     // pad sub-matrix to #numQb
323 |     AmpMatrix fullMatr;
324 |     if (numQb == qubits.size())
325 |         fullMatr = subMatr;
326 |     else {
327 |         Index idenDim = powerOf2(numQb - qubits.size());
328 |         fullMatr = getIdentityMatrix(idenDim) % subMatr;
329 |     }
330 |     
331 |     // create swap matrices which sort qubits
332 |     Index fullDim = powerOf2(numQb);
333 |     AmpMatrix swapsMatr = getIdentityMatrix(fullDim);
334 |     AmpMatrix unswapsMatr = getIdentityMatrix(fullDim);
335 |     
336 |     for (Nat q=0; q<qubits.size(); q++) {
337 |         if (qubits[q] != q) {
338 |             AmpMatrix m = getFullSwapMatrix(q, qubits[q], numQb);
339 |             swapsMatr = m * swapsMatr;
340 |             unswapsMatr = unswapsMatr * m;
341 |             
342 |             for (Nat i=q+1; i<qubits.size(); i++)
343 |                 if (qubits[i] == q)
344 |                     qubits[i] = qubits[q];
345 |         }
346 |     }
347 |     
348 |     // apply the swaps to our final matrix
349 |     fullMatr = unswapsMatr * fullMatr * swapsMatr;
350 |     return fullMatr;
351 | }
352 | 
353 | 
354 | static void applyGateToLocalState(AmpArray& state, NatArray ctrls, NatArray targs, AmpMatrix gateMatr) {
355 |     Nat numQb = logBase2(state.size());
356 |     AmpMatrix fullGateMatr = getFullGateMatrix(gateMatr, ctrls, targs, numQb);
357 |     state = fullGateMatr * state;
358 | }
359 | 
360 | 
361 | static void applyGateToLocalState(AmpMatrix& state, NatArray ctrls, NatArray targs, AmpMatrix gateMatr) {
362 |     Nat numQb = logBase2(state.size());
363 |     AmpMatrix fullGateMatr = getFullGateMatrix(gateMatr, ctrls, targs, numQb);
364 |     state = fullGateMatr * state * getDaggerMatrix(fullGateMatr);
365 | }
366 | 
367 | 
368 | static void applyKrausMapToLocalState(AmpMatrix& state, NatArray targets, MatrixArray krausOps) {
369 | 
370 |     AmpMatrix copy = state;
371 |     AmpMatrix tmp;
372 |     
373 |     state = getZeroMatrix( state.size() );
374 | 
375 |     for (AmpMatrix op : krausOps) {
376 |         tmp = copy;
377 |         applyGateToLocalState(tmp, {}, targets, op);
378 |         state = state + tmp;
379 |     }
380 | }
381 | 
382 | 
383 | AmpMatrix getKroneckerProduct(AmpMatrix a, AmpMatrix b) {
384 | 
385 |     AmpMatrix prod = getZeroMatrix(a.size() * b.size());
386 | 
387 |     for (size_t r=0; r<b.size(); r++)
388 |         for (size_t c=0; c<b.size(); c++)
389 |             for (size_t i=0; i<a.size(); i++)
390 |                 for (size_t j=0; j<a.size(); j++)
391 |                     prod[r+b.size()*i][c+b.size()*j] = a[i][j] * b[r][c];
392 | 
393 |     return prod;
394 | }
395 | 
396 | 
397 | AmpMatrix getKroneckerProductOfPaulis(NatArray paulis) {
398 |     for (Nat pauli: paulis)
399 |         assert( pauli <= 3);
400 | 
401 |     AmpMatrix prod = getZeroMatrix(1);
402 |     prod[0][0] = 1;
403 | 
404 |     for (Nat i=0; i<paulis.size(); i++) {
405 |         AmpMatrix pauli;
406 |         switch (paulis[i]) {
407 |             case 0: pauli = matrI; break;
408 |             case 1: pauli = matrX; break;
409 |             case 2: pauli = matrY; break;
410 |             case 3: pauli = matrZ; break;
411 |         }
412 |         prod = getKroneckerProduct(pauli, prod);
413 |     }
414 | 
415 |     return prod;
416 | }
417 | 
418 | 
419 | AmpArray StateVector::getAllVecAmps() {
420 |     
421 |     comm_synch();
422 |     
423 |     if (this->numNodes == 1)
424 |         return this->amps;
425 |         
426 |     Index numAllAmps = this->numNodes * this->numAmpsPerNode;
427 |     AmpArray allAmps(numAllAmps);
428 | 
429 |     MPI_Allgather(
430 |         (this->amps).data(), this->numAmpsPerNode, MPI_AMP,
431 |         allAmps.data(),      this->numAmpsPerNode, MPI_AMP,
432 |         MPI_COMM_WORLD);
433 |         
434 |     return allAmps;
435 | }
436 | 
437 | 
438 | void StateVector::setRandomAmps() {
439 |     
440 |     comm_synch();
441 |     
442 |     // all nodes generate all amps to keep RNG in-synch
443 |     for (Nat rank=0; rank<this->numNodes; rank++) {
444 |         AmpArray amps = getRandomArray(this->numAmpsPerNode);
445 |         if (this->rank == rank)
446 |             this->amps = amps;
447 |     }
448 | }
449 | 
450 | 
451 | void StateVector::printAmps() {
452 |     
453 |     comm_synch();
454 |     
455 |     // nominated rank prints while others wait
456 |     for (Nat rank=0; rank<this->numNodes; rank++) {
457 |         if (this->rank == rank) {
458 |             printf("rank %u:\n", rank);
459 |             printArray(this->amps);
460 |         }
461 |         
462 |         comm_synch();
463 |     }
464 |     
465 |     std::cout << std::flush;
466 |     comm_synch();
467 | }
468 | 
469 | 
470 | bool StateVector::agreesWith(AmpArray ref, Real tol=1E-5) {
471 |     assert( ref.size() == powerOf2(this->numQubits) );
472 |     
473 |     comm_synch();
474 |     
475 |     AmpArray allAmps = this->getAllVecAmps();
476 |     
477 |     for (Index i=0; i<ref.size(); i++) {
478 |         Amp dif = ref[i] - allAmps[i];
479 |         if (real(dif) > tol || imag(dif) > tol) {
480 |             if (this->rank == 0)
481 |                 printf("disagreement of (%g) + i(%g)\n", real(dif), imag(dif));
482 |             return false;
483 |         }
484 |     }
485 |     
486 |     return true;
487 | }
488 | 
489 | 
490 | AmpMatrix DensityMatrix::getAllMatrAmps() {
491 |     
492 |     comm_synch();
493 |     
494 |     Index dim = powerOf2(this->numQubits);
495 |     AmpArray vec = this->getAllVecAmps();
496 |     AmpMatrix matr = getZeroMatrix(dim);
497 |     
498 |     for (Index r=0; r<dim; r++)
499 |         for (Index c=0; c<dim; c++)
500 |             matr[r][c] = vec[dim*c+r];
501 | 
502 |     return matr;
503 | }
504 | 
505 | 
506 | bool DensityMatrix::agreesWith(AmpMatrix ref, Real tol=1E-5) {
507 |     assert( ref.size() == powerOf2(this->numQubits) );
508 |     
509 |     comm_synch();
510 |     
511 |     AmpMatrix allAmps = this->getAllMatrAmps();
512 |     
513 |     for (Index r=0; r<ref.size(); r++)
514 |         for (Index c=0; c<ref.size(); c++) {
515 |             Amp dif = ref[r][c] - allAmps[r][c];
516 |             if (real(dif) > tol || imag(dif) > tol) {
517 |                 if (this->rank == 0)
518 |                     printf("disagreement of (%g) + i(%g)\n", real(dif), imag(dif));
519 |                 return false;
520 |             }
521 |         }
522 |     
523 |     return true;
524 | }
525 | 
526 | 
527 | #endif // TEST_UTILITIES_HPP
528 | 


--------------------------------------------------------------------------------
/tests/tests.cpp:
--------------------------------------------------------------------------------
 1 | #define CATCH_CONFIG_RUNNER
 2 | #define CATCH_AMALGAMATED_CUSTOM_MAIN
 3 | #include "catch_amalgamated.hpp"
 4 | 
 5 | #include "test_utilities.hpp"
 6 | #include "tests_statevector.hpp"
 7 | #include "tests_densitymatrix.hpp"
 8 | 
 9 | #include "communication.hpp"
10 | 
11 | 
12 | int main( int argc, char* argv[] ) {
13 |     comm_init();  
14 |     int result = Catch::Session().run( argc, argv ); 
15 |     comm_end();
16 |     return result;
17 | }


--------------------------------------------------------------------------------
/tests/tests_densitymatrix.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef TESTS_DENSITYMATRIX_HPP
  2 | #define TESTS_DENSITYMATRIX_HPP
  3 | 
  4 | 
  5 | #include "types.hpp"
  6 | #include "states.hpp"
  7 | #include "distributed_densitymatrix.hpp"
  8 | 
  9 | #include "test_utilities.hpp"
 10 | #include "catch_amalgamated.hpp"
 11 | 
 12 | #include <algorithm>
 13 | 
 14 | 
 15 | int NUM_QUBITS_RHO = 5;
 16 | int NUM_TRIALS_PER_RHO_TEST = 5000;
 17 | 
 18 | 
 19 | #define PREPARE_RHO_TEST(rhoVar, refVar) \
 20 |     GENERATE( range(0,NUM_TRIALS_PER_RHO_TEST) ); \
 21 |     DensityMatrix rhoVar = DensityMatrix(NUM_QUBITS_RHO); \
 22 |     rhoVar.setRandomAmps(); \
 23 |     AmpMatrix refVar = rhoVar.getAllMatrAmps();
 24 | 
 25 | 
 26 | TEST_CASE( "densitymatrix_manyTargGate" ) {
 27 |         
 28 |     PREPARE_RHO_TEST( rho, ref );
 29 |     
 30 |     Nat maxNumTargs = NUM_QUBITS_RHO - ceil(rho.logNumNodes / 2.);
 31 |     Nat numTargs = getRandomNat(1, maxNumTargs + 1);
 32 |     NatArray targets = getRandomUniqueNatArray(0, NUM_QUBITS_RHO, numTargs);
 33 |     AmpMatrix gate = getRandomMatrix( powerOf2(numTargs) );
 34 | 
 35 |     distributed_densitymatrix_manyTargGate(rho, targets, gate);
 36 |     applyGateToLocalState(ref, {}, targets, gate);
 37 | 
 38 |     REQUIRE( rho.agreesWith(ref) );
 39 | }
 40 | 
 41 | 
 42 | TEST_CASE( "densitymatrix_swapGate" ) {
 43 | 
 44 |     PREPARE_RHO_TEST( rho, ref );
 45 | 
 46 |     AmpMatrix gate = {{1,0,0,0}, {0,0,1,0}, {0,1,0,0}, {0,0,0,1}};
 47 |     NatArray targets = getRandomUniqueNatArray(0, NUM_QUBITS_RHO, 2);
 48 | 
 49 |     distributed_densitymatrix_swapGate(rho, targets[0], targets[1]);
 50 |     applyGateToLocalState(ref, {}, targets, gate);
 51 | 
 52 |     REQUIRE( rho.agreesWith(ref) );
 53 | }
 54 | 
 55 | 
 56 | TEST_CASE( "densitymatrix_pauliTensor" ) {
 57 | 
 58 |     PREPARE_RHO_TEST( rho, ref );
 59 | 
 60 |     Nat numTargs = getRandomNat(1, NUM_QUBITS_RHO + 1);
 61 |     NatArray targets = getRandomUniqueNatArray(0, NUM_QUBITS_RHO, numTargs);
 62 |     NatArray paulis = getRandomNatArray(1, 4, numTargs);
 63 |     ensureNotAllPauliZ(paulis);
 64 |     AmpMatrix gate = getKroneckerProductOfPaulis(paulis);
 65 | 
 66 |     distributed_densitymatrix_pauliTensor(rho, targets, paulis);
 67 |     applyGateToLocalState(ref, {}, targets, gate);
 68 | 
 69 |     REQUIRE( rho.agreesWith(ref) );
 70 | }
 71 | 
 72 | 
 73 | TEST_CASE( "densitymatrix_pauliGadget" ) {
 74 | 
 75 |     PREPARE_RHO_TEST( rho, ref );
 76 | 
 77 |     Nat numTargs = getRandomNat(1, NUM_QUBITS_RHO + 1);
 78 |     NatArray targets = getRandomUniqueNatArray(0, NUM_QUBITS_RHO, numTargs);
 79 |     NatArray paulis = getRandomNatArray(1, 4, numTargs);
 80 |     ensureNotAllPauliZ(paulis);
 81 |     Real theta = getRandomReal(-PI, PI);
 82 |     AmpMatrix tensor = getKroneckerProductOfPaulis(paulis);
 83 |     AmpMatrix gate = getExponentialOfPauliTensor(theta, tensor);
 84 | 
 85 |     distributed_densitymatrix_pauliGadget(rho, targets, paulis, theta);
 86 |     applyGateToLocalState(ref, {}, targets, gate);
 87 | 
 88 |     REQUIRE( rho.agreesWith(ref) );
 89 | }
 90 | 
 91 | 
 92 | TEST_CASE( "densitymatrix_phaseGadget") {
 93 |     
 94 |     PREPARE_RHO_TEST( rho, ref );
 95 | 
 96 |     Nat numTargs = getRandomNat(1, NUM_QUBITS_RHO + 1);
 97 |     NatArray targets = getRandomUniqueNatArray(0, NUM_QUBITS_RHO, numTargs);
 98 |     Real theta = getRandomReal(-PI, PI);
 99 |     AmpMatrix tensor = getKroneckerProductOfPaulis(NatArray(numTargs, 3));
100 |     AmpMatrix gate = getExponentialOfPauliTensor(theta, tensor);
101 | 
102 |     distributed_densitymatrix_phaseGadget(rho, targets, theta);
103 |     applyGateToLocalState(ref, {}, targets, gate);
104 | 
105 |     REQUIRE( rho.agreesWith(ref) );
106 | }
107 | 
108 | 
109 | TEST_CASE( "densitymatrix_krausMap" ) {
110 | 
111 |     PREPARE_RHO_TEST( rho, ref );
112 | 
113 |     Nat maxNumTargs = NUM_QUBITS_RHO - ceil(rho.logNumNodes / 2.);
114 |     Nat numTargs = getRandomNat(1, maxNumTargs + 1);
115 |     NatArray targets = getRandomUniqueNatArray(0, NUM_QUBITS_RHO, numTargs);
116 |     Nat numKrausOps = getRandomNat(1, 10);
117 |     MatrixArray krausOps = getRandomMatrices(powerOf2(numTargs), numKrausOps);
118 | 
119 |     distributed_densitymatrix_krausMap(rho, krausOps, targets);
120 |     applyKrausMapToLocalState(ref, targets, krausOps);
121 | 
122 |     REQUIRE( rho.agreesWith(ref) );
123 | }
124 | 
125 | 
126 | TEST_CASE( "densitymatrix_oneQubitDephasing" ) {
127 | 
128 |     PREPARE_RHO_TEST( rho, ref );
129 | 
130 |     Nat target = getRandomNat(0, NUM_QUBITS_RHO);
131 |     Real prob = getRandomReal(0, 1/2.);
132 |     MatrixArray krausOps(2);
133 |     krausOps[0] = sqrt(1-prob) * matrI;
134 |     krausOps[1] = sqrt(prob)   * matrZ;
135 | 
136 |     distributed_densitymatrix_oneQubitDephasing(rho, target, prob);
137 |     applyKrausMapToLocalState(ref, {target}, krausOps);
138 |     
139 |     REQUIRE( rho.agreesWith(ref) );
140 | }
141 | 
142 | 
143 | TEST_CASE( "densitymatrix_twoQubitDephasing" ) {
144 | 
145 |     PREPARE_RHO_TEST( rho, ref );
146 | 
147 |     NatArray targets = getRandomUniqueNatArray(0, NUM_QUBITS_RHO, 2);
148 |     Real prob = getRandomReal(0, 3/4.);
149 |     MatrixArray krausOps(4);
150 |     krausOps[0] = sqrt(1-prob)  * getKroneckerProduct(matrI, matrI);
151 |     krausOps[1] = sqrt(prob/3.) * getKroneckerProduct(matrI, matrZ);
152 |     krausOps[2] = sqrt(prob/3.) * getKroneckerProduct(matrZ, matrI);
153 |     krausOps[3] = sqrt(prob/3.) * getKroneckerProduct(matrZ, matrZ);
154 | 
155 |     distributed_densitymatrix_twoQubitDephasing(rho, targets[0], targets[1], prob);
156 |     applyKrausMapToLocalState(ref, targets, krausOps);
157 |     
158 |     REQUIRE( rho.agreesWith(ref) );
159 | }
160 | 
161 | 
162 | TEST_CASE( "densitymatrix_oneQubitDepolarising" ) {
163 | 
164 |     PREPARE_RHO_TEST( rho, ref );
165 | 
166 |     Nat target = getRandomNat(0, NUM_QUBITS_RHO);
167 |     Real prob = getRandomReal(0, 1/2.);
168 |     MatrixArray krausOps(4);
169 |     krausOps[0] = sqrt(1-prob)  * matrI;
170 |     krausOps[1] = sqrt(prob/3.) * matrX;
171 |     krausOps[2] = sqrt(prob/3.) * matrY;
172 |     krausOps[3] = sqrt(prob/3.) * matrZ;
173 | 
174 |     distributed_densitymatrix_oneQubitDepolarising(rho, target, prob);
175 |     applyKrausMapToLocalState(ref, {target}, krausOps);
176 |     
177 |     REQUIRE( rho.agreesWith(ref) );
178 | }
179 | 
180 | 
181 | TEST_CASE( "densitymatrix_twoQubitDepolarising" ) {
182 | 
183 |     PREPARE_RHO_TEST( rho, ref );
184 | 
185 |     NatArray targets = getRandomUniqueNatArray(0, NUM_QUBITS_RHO, 2);
186 |     Real prob = getRandomReal(0, 3/4.);
187 |     MatrixArray krausOps(16);
188 |     Nat i=0;
189 |     for (AmpMatrix matr1 : {matrI, matrX, matrY, matrZ})
190 |         for (AmpMatrix matr2 : {matrI, matrX, matrY, matrZ})
191 |             krausOps[i++] = sqrt(prob/15.) * getKroneckerProduct(matr1, matr2);
192 |     krausOps[0] = sqrt(1-16/15.) * getIdentityMatrix( powerOf2(2) );
193 | 
194 |     distributed_densitymatrix_twoQubitDepolarising(rho, targets[0], targets[1], prob);
195 |     applyKrausMapToLocalState(ref, targets, krausOps);
196 |     
197 |     REQUIRE( rho.agreesWith(ref) );
198 | }
199 | 
200 | 
201 | TEST_CASE( "densitymatrix_damping" ) {
202 | 
203 |     PREPARE_RHO_TEST( rho, ref );
204 | 
205 |     Nat target = getRandomNat(0, NUM_QUBITS_RHO);
206 |     Real prob = getRandomReal(0, 1/2.);
207 |     MatrixArray krausOps(2);
208 |     krausOps[0] = {{1,0},{0,sqrt(1-prob)}};
209 |     krausOps[1] = {{0,sqrt(prob)},{0,0}};
210 | 
211 |     distributed_densitymatrix_damping(rho, target, prob);
212 |     applyKrausMapToLocalState(ref, {target}, krausOps);
213 |     
214 |     REQUIRE( rho.agreesWith(ref) );
215 | }
216 | 
217 | 
218 | TEST_CASE( "densitymatrix_expecPauliString" ) {
219 | 
220 |     PREPARE_RHO_TEST( rho, ref );
221 | 
222 |     Nat numQubits = NUM_QUBITS_RHO;
223 |     Nat numTerms = getRandomNat(1, 30);
224 |     Nat numPaulis = numTerms * numQubits;
225 |     NatArray paulis = getRandomNatArray(0, 4, numPaulis);
226 |     RealArray coeffs = getRandomRealArray(-10, 10, numTerms);
227 | 
228 |     Amp expec1 = distributed_densitymatrix_expecPauliString(rho, coeffs, paulis);
229 | 
230 |     AmpMatrix pauliStringMatr = getZeroMatrix( powerOf2(numQubits) );
231 |     for (Nat i=0; i<numTerms; i++) {
232 |         NatArray prodPaulis = NatArray(paulis.begin() + i*numQubits, paulis.begin() + (i+1)*numQubits);
233 |         AmpMatrix prodMatrix = getKroneckerProductOfPaulis(prodPaulis);
234 |         pauliStringMatr = pauliStringMatr +  coeffs[i] * prodMatrix;
235 |     }
236 |     ref = pauliStringMatr * ref;
237 | 
238 |     Amp expec2 = 0;
239 |     for (Nat r=0; r<ref.size(); r++)
240 |         expec2 += ref[r][r];
241 | 
242 |     REQUIRE_THAT( real(expec1), Catch::Matchers::WithinAbs(real(expec2), 1e-12) );
243 |     REQUIRE_THAT( imag(expec1), Catch::Matchers::WithinAbs(imag(expec2), 1e-12) );
244 | }
245 | 
246 | 
247 | TEST_CASE( "densitymatrix_partialTrace" ) {
248 | 
249 |     PREPARE_RHO_TEST( rho, ref );
250 | 
251 |     // output, reduced density matrix must have >=1 columns per-node.
252 |     // this is _not_ essential for the algorithm, which actually permits looser
253 |     //      maxNumTargs = NUM_QUBITS_RHO - (rho.logNumNodes/2),
254 |     // but required as a precondition to our density-matrix constructor, to
255 |     // maintain compatibility with the other algorithms in this project
256 |     Nat maxNumTargs = NUM_QUBITS_RHO - rho.logNumNodes;
257 |     
258 |     Nat numTargs = getRandomNat(1, maxNumTargs + 1);
259 |     NatArray targs = getRandomUniqueNatArray(0, NUM_QUBITS_RHO, numTargs);
260 | 
261 |     DensityMatrix rhoOut = distributed_densitymatrix_partialTrace(rho, targs);
262 | 
263 |     // serially populate the reference reduced matrix
264 |     AmpMatrix refOut = getZeroMatrix( powerOf2(NUM_QUBITS_RHO - numTargs) );
265 |     
266 |     std::sort(targs.begin(), targs.end());
267 |     for (Index i=0; i<refOut.size(); i++) {
268 |         for (Index j=0; j<refOut.size(); j++) {
269 |             Index i0 = insertBits(i, targs, 0);
270 |             Index j0 = insertBits(j, targs, 0);
271 | 
272 |             refOut[i][j] = 0;
273 |             for (Index k=0; k<powerOf2(numTargs); k++) {
274 |                 Index ik = setBits(i0, targs, k);
275 |                 Index jk = setBits(j0, targs, k);
276 |                 refOut[i][j] += ref[ik][jk];
277 |             }
278 |         }
279 |     }
280 | 
281 |     REQUIRE( rhoOut.agreesWith(refOut) );
282 | }
283 | 
284 | 
285 | #endif // TESTS_DENSITYMATRIX_HPP


--------------------------------------------------------------------------------
/tests/tests_statevector.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef TESTS_STATEVECTOR_HPP
  2 | #define TESTS_STATEVECTOR_HPP
  3 | 
  4 | 
  5 | #include "types.hpp"
  6 | #include "states.hpp"
  7 | #include "distributed_statevector.hpp"
  8 | 
  9 | #include "test_utilities.hpp"
 10 | #include "catch_amalgamated.hpp"
 11 | 
 12 | 
 13 | int NUM_QUBITS_PSI = 6;
 14 | int NUM_TRIALS_PER_PSI_TEST = 5000;
 15 | 
 16 | 
 17 | #define PREPARE_PSI_TEST(psiVar, refVar) \
 18 |     GENERATE( range(0,NUM_TRIALS_PER_PSI_TEST) ); \
 19 |     StateVector psiVar = StateVector(NUM_QUBITS_PSI); \
 20 |     psiVar.setRandomAmps(); \
 21 |     AmpArray refVar = psiVar.getAllVecAmps();
 22 | 
 23 |     
 24 | TEST_CASE( "statevector_oneTargGate" ) {
 25 |         
 26 |     PREPARE_PSI_TEST( psi, ref );
 27 |     
 28 |     AmpMatrix gate = getRandomMatrix( powerOf2(1) );
 29 |     Nat target = getRandomNat(0, NUM_QUBITS_PSI);
 30 | 
 31 |     distributed_statevector_oneTargGate(psi, target, gate);
 32 |     applyGateToLocalState(ref, {}, {target}, gate);
 33 | 
 34 |     REQUIRE( psi.agreesWith(ref) );
 35 | }
 36 | 
 37 | 
 38 | TEST_CASE( "statevector_manyCtrlOneTargGate") {
 39 |     
 40 |     PREPARE_PSI_TEST( psi, ref );
 41 |     
 42 |     AmpMatrix gate = getRandomMatrix( powerOf2(1) );
 43 |     Nat target = getRandomNat(0, NUM_QUBITS_PSI);
 44 |     Nat numCtrls = getRandomNat(1, NUM_QUBITS_PSI-1);
 45 |     NatArray controls = getRandomUniqueNatArray(0, NUM_QUBITS_PSI, numCtrls, target);
 46 | 
 47 |     distributed_statevector_manyCtrlOneTargGate(psi, controls, target, gate);
 48 |     applyGateToLocalState(ref, controls, {target}, gate);
 49 | 
 50 |     REQUIRE( psi.agreesWith(ref) );
 51 | }
 52 | 
 53 | 
 54 | TEST_CASE( "statevector_swapGate" ) {
 55 | 
 56 |     PREPARE_PSI_TEST( psi, ref );
 57 | 
 58 |     AmpMatrix gate = {{1,0,0,0}, {0,0,1,0}, {0,1,0,0}, {0,0,0,1}};
 59 |     NatArray targets = getRandomUniqueNatArray(0, NUM_QUBITS_PSI, 2);
 60 | 
 61 |     distributed_statevector_swapGate(psi, targets[0], targets[1]);
 62 |     applyGateToLocalState(ref, {}, targets, gate);
 63 | 
 64 |     REQUIRE( psi.agreesWith(ref) );
 65 | }
 66 | 
 67 | 
 68 | TEST_CASE( "statevector_manyTargGate") {
 69 |     
 70 |     PREPARE_PSI_TEST( psi, ref );
 71 | 
 72 |     Nat maxNumTargs = NUM_QUBITS_PSI - psi.logNumNodes;
 73 |     Nat numTargs = getRandomNat(1, maxNumTargs + 1);
 74 |     NatArray targets = getRandomUniqueNatArray(0, NUM_QUBITS_PSI, numTargs);
 75 |     AmpMatrix gate = getRandomMatrix( powerOf2(numTargs) );
 76 | 
 77 |     distributed_statevector_manyTargGate(psi, targets, gate);
 78 |     applyGateToLocalState(ref, {}, targets, gate);
 79 | 
 80 |     REQUIRE( psi.agreesWith(ref) );
 81 | }
 82 | 
 83 | 
 84 | TEST_CASE( "statevector_pauliTensor" ) {
 85 | 
 86 |     PREPARE_PSI_TEST( psi, ref );
 87 | 
 88 |     Nat numTargs = getRandomNat(1, NUM_QUBITS_PSI + 1);
 89 |     NatArray targets = getRandomUniqueNatArray(0, NUM_QUBITS_PSI, numTargs);
 90 |     NatArray paulis = getRandomNatArray(1, 4, numTargs);
 91 |     ensureNotAllPauliZ(paulis);
 92 |     AmpMatrix gate = getKroneckerProductOfPaulis(paulis);
 93 | 
 94 |     distributed_statevector_pauliTensor(psi, targets, paulis);
 95 |     applyGateToLocalState(ref, {}, targets, gate);
 96 | 
 97 |     REQUIRE( psi.agreesWith(ref) );
 98 | }
 99 | 
100 | 
101 | TEST_CASE( "statevector_pauliGadget" ) {
102 | 
103 |     PREPARE_PSI_TEST( psi, ref );
104 | 
105 |     Nat numTargs = getRandomNat(1, NUM_QUBITS_PSI + 1);
106 |     NatArray targets = getRandomUniqueNatArray(0, NUM_QUBITS_PSI, numTargs);
107 |     NatArray paulis = getRandomNatArray(1, 4, numTargs);
108 |     ensureNotAllPauliZ(paulis);
109 |     Real theta = getRandomReal(-PI, PI);
110 |     AmpMatrix tensor = getKroneckerProductOfPaulis(paulis);
111 |     AmpMatrix gate = getExponentialOfPauliTensor(theta, tensor);
112 | 
113 |     distributed_statevector_pauliGadget(psi, targets, paulis, theta);
114 |     applyGateToLocalState(ref, {}, targets, gate);
115 | 
116 |     REQUIRE( psi.agreesWith(ref) );
117 | }
118 | 
119 | 
120 | TEST_CASE( "statevector_phaseGadget") {
121 |     
122 |     PREPARE_PSI_TEST( psi, ref );
123 | 
124 |     Nat numTargs = getRandomNat(1, NUM_QUBITS_PSI + 1);
125 |     NatArray targets = getRandomUniqueNatArray(0, NUM_QUBITS_PSI, numTargs);
126 |     Real theta = getRandomReal(-PI, PI);
127 |     AmpMatrix tensor = getKroneckerProductOfPaulis(NatArray(numTargs, 3));
128 |     AmpMatrix gate = getExponentialOfPauliTensor(theta, tensor);
129 | 
130 |     distributed_statevector_phaseGadget(psi, targets, theta);
131 |     applyGateToLocalState(ref, {}, targets, gate);
132 | 
133 |     REQUIRE( psi.agreesWith(ref) );
134 | }
135 | 
136 | 
137 | #endif // TESTS_STATEVECTOR_HPP


--------------------------------------------------------------------------------