Eqcs-0.0.8

Because a bitset build from a 32 bit unsigned long is by far to small for holding all the bits nessecary to simulate a multi register quantum computer, a special class for holding a theoreticlly infinite number of bits is needed. The class should allow for all the bit operations known from the integral build-in types.

Looking at the standard template library (STL) the following classes are provided:

vector<bool>

• the size is chosen at runtime
• no bit operator overloads
• expensive copying

bitset<n>

• the size n is fixed at compile time
• bit operator overloads available
• expensive copying

Both classes offer only part of the features needed. That's why the eqcs library has it's own class for bitsets:

EqcsBitset

• the size is chosen at runtime
• bit operator overloads available
• inexpensive copying

1.1. The Class EqcsBitset

Following is an excerpt from class EqcsBitset's declaration. (See "eqcs_bitset.h" for details.)

class EqcsBitset: public EqcsHandle {
public:
    // ...

    EqcsBitset();
    explicit EqcsBitset(int nbits);

    int nbits() const;

    void set(int i) const;
    void reset(int i) const;
    bool test(int i) const;

    EqcsBitset operator~() const;
    EqcsBitset &operator&=(const EqcsBitset &bitset);
    EqcsBitset &operator|=(const EqcsBitset &bitset);
    EqcsBitset &operator<<=(int i);
    EqcsBitset &operator>>=(int i);

    // ...
};

The class EqcsBitset has the following operations:

• A constructor for creating an EqcsBitset with a default number of bits. The default number is chosen to be 8. The constructor switches all bits off.
• A constructor for creating an EqcsBitset with nbits bits. The constructor switches all nbits bits off.
• A method nbits() for getting the number of bits.
• A method set() for switching on the i'th bit. The parameter i must be taken from [0, nbits).
• A method reset() for switching off the i'th bit. The parameter i must be taken from [0, nbits).
• A method test() for testing whether the i'th bit is on or off. The parameter i must be taken from [0, nbits).
• An unary operator ~ for getting a new EqcsBitset with all bits in the opposite state then the corresponding original ones. The program fragment

  EqcsBitset bitset(4);
  bitset.set(0);
  bitset.set(2);
  
  cout << "original: " << bitset << endl;
  cout << "negated:  " << ~bitset << endl;
  

  should produce the output

  original: 0101
  negated:  1010
  

• A binary operator &= for "anding" an EqcsBitset. The method throws away the EqcsBitset's old representation and replaces it by a new one. The program fragment

  EqcsBitset bitset1(2);
  bitset1.set(0);
  bitset1.set(1);
  
  EqcsBitset bitset2(4);
  bitset1.set(0);
  bitset2.set(2);
  
  cout << "bitset 1 before 'anding': " << bitset1 << endl;
  cout << "bitset 2:                 " << bitset2 << endl;
  
  bitset1 &= bitset2;
  cout << "bitset 1 after  'anding': " << bitset1 << endl;
  

  should produce the output

  bitset 1 before 'anding': 11
  bitset 2:                 0101
  bitset 1 after 'anding':  0001
  

  Note that in the above example the EqcsBitset's number of bits is extended after "anding".
• A binary operator |= for "oring" an EqcsBitset. The method throws away the EqcsBitset's old representation and replaces it by a new one. The program fragment

  EqcsBitset bitset1(2);
  bitset1.set(0);
  bitset1.set(1);
  
  EqcsBitset bitset2(4);
  bitset1.set(0);
  bitset2.set(2);
  
  cout << "bitset 1 before 'oring': " << bitset1 << endl;
  cout << "bitset 2:               " << bitset2 << endl;
  
  bitset1 |= bitset2;
  cout << "bitset 1 after  'oring': " << bitset1 << endl;
  

  should produce the output

  bitset 1 before 'oring': 11
  bitset 2:                0101
  bitset 1 after 'oring':  0111
  

  Note that in the above example the EqcsBitset's number of bits is extended after "oring".
• A binary operator <<= for shifting an EqcsBitset i times to the left. The method throws away the EqcsBitset's old representation and replaces it by a new one. The program fragment

  EqcsBitset bitset(2);
  bitset1.set(0);
  bitset1.set(1);
  
  cout << "bitset before shifting: " << bitset << endl;
  bitset <<= 2;
  cout << "bitset after shifting:  " << bitset << endl;
  

  should produce the output

  bitset before shifting: 11
  bitset after shifting:  1100
  

  Note that in the above example the EqcsBitset's number of bits is extended after shifting, no bits are lost.
• A binary operator >>= for shifting an EqcsBitset i times to the right. The method throws away the EqcsBitset's old representation and replaces it by a new one. The program fragment

  EqcsBitset bitset(2);
  bitset1.set(0);
  bitset1.set(1);
  
  cout << "bitset before shifting: " << bitset << endl;
  bitset >>= 1;
  cout << "bitset after shifting:  " << bitset << endl;
  

  should produce the output

  bitset before shifting: 11
  bitset after shifting:  01
  

  Note that in the above example the EqcsBitset's number of bits is not extended after shifting, some bits are lost.

1.2. Comparing two EqcsBitsets

The operators behave as expected. The program fragment

EqcsBitset bitset1(2);
bitset1.set(0);
bitset1.set(1);
cout << "bitset 1: " << bitset1 << endl;

EqcsBitset bitset2(4);
bitset2.set(3);
cout << "bitset 2: " << bitset2 << endl;

cout << endl;
cout << "bitset 1 == bitset 2: " << (bitset1 == bitset2) << endl;
cout << "bitset 1 != bitset 2: " << (bitset1 != bitset2) << endl;
cout << "bitset 1 < bitset 2:  " << (bitset1 < bitset2) << endl;
cout << "bitset 1 <= bitset 2: " << (bitset1 <= bitset2) << endl;
cout << "bitset 1 >= bitset 2: " << (bitset1 >= bitset2) << endl;
cout << "bitset 1 > bitset 2:  " << (bitset1 > bitset2) << endl;

bitset 1: 11
bitset 2: 0100

bitset 1 == bitset 2: 0
bitset 1 != bitset 2: 1
bitset 1 < bitset 2:  1
bitset 1 <= bitset 2: 1
bitset 1 >= bitset 2: 0
bitset 1 > bitset 2:  0

1.3. Set Operations

Listing 3 shows the global operators for doing set operations with two EqcsStates.

EqcsBitset operator&(const EqcsBitset &l, const EqcsBitset &r);
EqcsBitset operator|(const EqcsBitset &l, const EqcsBitset &r);
EqcsBitset operator>>(const EqcsBitset &l, int i);
EqcsBitset operator<<(const EqcsBitset &l, int i);

There are the following operators:

• An operator for "anding" two EqcsBitsets. The result is a new EqcsBitset. The program fragment

  EqcsBitset bitset1(2);
  bitset1.set(0);
  bitset1.set(1);
  
  EqcsBitset bitset2(4);
  bitset1.set(0);
  bitset2.set(2);
  
  cout << "bitset 1:            " << bitset1 << endl;
  cout << "bitset 2:            " << bitset2 << endl;
  
  cout << "bitset 1 & bitset 2: " << (bitset1 & bitset2) << endl;
  

  should produce the output

  bitset 1:           11
  bitset 2:           0101
  bitset 1 & bitset2: 0001
  

  Note that in the above example the result of the and-operation appears as a temporary object.
• An operator for "oring" two EqcsBitsets. The result is a new EqcsBitset. The program fragment

  EqcsBitset bitset1(2);
  bitset1.set(0);
  bitset1.set(1);
  
  EqcsBitset bitset2(4);
  bitset1.set(0);
  bitset2.set(2);
  
  cout << "bitset 1:            " << bitset1 << endl;
  cout << "bitset 2:            " << bitset2 << endl;
  
  cout << "bitset 1 | bitset 2: " << (bitset1 | bitset2) << endl;
  

  should produce the output

  bitset 1:           11
  bitset 2:           0101
  bitset 1 | bitset2: 0111
  

  Note that in the above example the result of the or-operation appears as a temporary object.

1.3. Printing an EqcsBitset

ostream &operator<<(ostream &os, const EqcsBitset &bitset);
EqcsBitset::omanip0_t ket(const EqcsBitset &bitset);
EqcsBitset::omanip1_t ket(const EqcsBitset &bitset, int nbits);
EqcsBitset::omanip2_t bits(const EqcsBitset &bitset, int nregs, int regwidth);
EqcsBitset::omanip2_t nums(const EqcsBitset &bitset, int nregs, int regwidth);

The following methods to print an EqcsBitset are provided:

• Print the bit pattern. The code fragment

  EqcsBitset bitset(4);
  bitset.set(0);
  bitset.set(2);
  
  cout << bitset << endl;
  

  should produce the output

  0101
  

• Print the bit pattern as a ket. The code fragment

  EqcsBitset bitset(4);
  bitset.set(0);
  bitset.set(2);
  
  cout << ket(bitset) << endl;
  

  should produce the output

  |0101>
  

• Print the bit pattern as a ket with some padding. The code fragment

  EqcsBitset bitset(4);
  bitset.set(0);
  bitset.set(2);
  
  cout << ket(bitset, 8) << endl;
  

  should produce the output

  |00000101>
  

• Print the bitset as a sequence of bit pattern kets belonging to nregs registers of width regwidth. The code fragment

  EqcsBitset bitset(8);
  bitset.set(1);
  bitset.set(5);
  
  cout << bits(bitset, 2, 4) << endl;
  

  should produce the output

  |0010>|0010>
  

• Print the bitset as a sequence of number kets belonging to nregs registers of width regwidth. The code fragment

  EqcsBitset bitset(8);
  bitset.set(1);
  bitset.set(5);
  
  cout << nums(bitset, 2, 4) << endl;
  

  should produce the output

  |2>|2>
  

2. States

+---------------+        * +---------------+
|     State     |<>--------+    Bitset     |
+---------------+          +---------------+

2.1. The Class EqcsState

class EqcsState: public EqcsHandle {
public:
    // ...

    EqcsState(unsigned long bits);

    // Define a partial order.
    bool operator<(const EqcsState &state) const;

    // Negate the state.
    EqcsState operator-() const;

    // Add a state.
    EqcsState operator+=(const EqcsState &state) const;
    EqcsState operator-=(const EqcsState &state) const;
    // Multiply by a complex number.
    EqcsState operator*=(const complex_t &c) const;

    // Measure some bits.
    EqcsState collapse(unsigned long bits) const;

    // ...
};

2.2. Arithmetics with EqcsStates

// Add two states.
EqcsState operator+(const EqcsState &l, const EqcsState &r);
EqcsState operator-(const EqcsState &l, const EqcsState &r);
// Multiply a state by a complex number.
EqcsState operator*(const EqcsState::complex_t &l, const EqcsState &r);
EqcsState operator*(const EqcsState &l, const EqcsState::complex_t &r);

2.3. Printing an EqcsState

ostream &operator<<(ostream &os, const EqcsState &state);
EqcsState::omanip2_t bits(const EqcsState &state, int nregs, int regwidth);
EqcsState::omanip2_t nums(const EqcsState &state, int nregs, int regwidth);

3. Gate Arrays

+---------------+        * +---------------+
|   GateArray   |<>--------+     Gate      |
+---------------+          +---------------+
                                  ^
                                  |
                         +--------+--------+
                         |                 |
                 +-------+-------+ +-------+-------+
                 |    Lambda     | |    Matrix     |
                 +---------------+ +---------------+

4. The Quantum Computer

+---------------+        1 +---------------+
|      QC       |<>--------+     State     |
+---------------+          +---------------+

4.1. An Example Program

#include "eqcs_state_rep.h"
#include "eqcs_qc.h"
#include "eqcs_lambda.h"

int main()
{
    EqcsGateArray program;      // A gate array.

    // Create a controlled not gate (a special lamda(1) gate).
    EqcsLambda cnot(0.0, 1.0, 1.0, 0.0, 1);

    cnot.set(0, 1);             // The working bit is 1.
    cnot.set(1, 5);             // The controlling bit is 5.

    // Add the controlled not gate to the gate array.
    program.push_back(cnot);

    // Create the state |0010>|0010>.
    EqcsState state = (1ul << 5) | (1ul << 1);
    cout << "the input:  " << bits(state, 2, 4) << endl;

    // Create a quantum computer initially in state |0010>|0010>.
    EqcsQc qc(state);

    // Run the program.
    qc.perform(program);

    // Print the result.
    cout << "the result: " << bits(qc.state(), 2, 4) << endl;

    // Iterate through the result's terms.
    cout << "the result's terms:" << endl;

    for (EqcsStateRep::const_iterator i=qc.state()->terms().begin();
            i!=qc.state()->terms().end(); ++i) {

        EqcsBitset bitset = i->first;
        complex<double> coeff = i->second;

        cout << "    " << bits(bitset, 2, 4) << ": " << coeff << endl;
    }
}