main (2).cpp

#include "Quantum/Quantum.h"
#include "attack.h"
 
namespace QKD
{
  enum GateType
  {
    NOT=0,
    Rotation,
    Hadamard,
 
    Measure
  };
 
  struct Gate
  {
    Gate()
    {
      type = 0;
      controlMode = false;
      target = 0;
      control = 0;
      p = 0;
      theta = 0;
      psi = 0;
    }
    int type;
    bool controlMode;
    int target, control;
    double p, theta, psi;
  };
}
 
double SafeLog(double x)
{
  if(x < 0.000000001)
    return 0;
  return log(x) / log(2.0);
}
double entropy(double x)
{
  return -x*SafeLog(x) - (1-x)*SafeLog(1-x);
}
double entropy(double a, double b, double c, double d)
{
  return -a*SafeLog(a) - b*SafeLog(b) - c*SafeLog(c) - d*SafeLog(d);
}
 
QKD::Attack* atk;
std::vector <algebra::mat> EVec;
bool COMPUTE_ACTUAL_RATE = false;
 
void setupAttackVectors(QKD::Stats& stats) // run this once at startup!
{
  EVec.resize(4);
  for(int i=0; i<EVec.size(); ++i)
    EVec[i].create(4,1);
 
  atk = new QKD::Attack(stats);
}
 
double ComputeFitness(std::list <QKD::Gate>& A, std::list <QKD::Gate>& B)
{
  const int keyA = 0;
  const int arA = 1;
  const int extraA = 2;
  const int numExtraA = 0;
 
  const int T = extraA+numExtraA;
 
  const int keyB = T+1;
  const int arB = T+2;
  const int extraB = T+3;
  const int numExtraB = 0;
 
  const int E = extraB+numExtraB;
 
  const int NUM_WIRES = E+1;
 
  const int ASpace = T;  // largest wire (inclusive) A is allowed access to
 
  quantum::DensityList dl;
 
  for(int i=0; i<NUM_WIRES; ++i){
    if(i != E)
      dl.dimension.push_back(2);
    else
      dl.dimension.push_back(4);
  }
 
  quantum::KetBra kb(NUM_WIRES);
  kb.p = 1;
  dl.density.push_back(kb);
 
  // run A:
  if(!A.empty()){
    std::list<QKD::Gate>::iterator Iter;
    for(Iter = A.begin(); Iter != A.end(); ++Iter){
      int target = Iter->target;
      int control = Iter->control;
      if(!Iter->controlMode)
    control = -1;
 
      // ensure that gates aren't applied to wires that cannot be accessed:
      if(target > ASpace || control > ASpace)
    continue;
      if(target == E || control == E)
    continue;
 
      if(Iter->controlMode && control == target)
    continue;
 
      switch(Iter->type){
      case QKD::Hadamard: dl.applyHadamard(target, control);
    break;
 
      case QKD::NOT: dl.applyNOT(target, control);
    break;
 
      case QKD::Rotation: dl.applySU2(target, control, Iter->p, Iter->theta, Iter->psi);
    break;
 
      case QKD::Measure: dl.measure(target);
    break;
      }
    }
  }
 
  dl.applyAttackOp(T, E);  // E attacks
 
  // Run B:
  if(!B.empty()){
    std::list<QKD::Gate>::iterator Iter;
    for(Iter = B.begin(); Iter != B.end(); ++Iter){
      int target = Iter->target;
      int control = Iter->control;
      if(!Iter->controlMode)
    control = -1;
 
      // ensure that gates aren't applied to wires that cannot be accessed:
      if(target < T || (control < T && control >= 0))
    continue;
      if(target == E || control == E)
    continue;
 
      if(Iter->controlMode && control == target)
    continue;
 
      switch(Iter->type){
      case QKD::Hadamard: dl.applyHadamard(target, control);
    break;
 
      case QKD::NOT: dl.applyNOT(target, control);
    break;
 
      case QKD::Rotation: dl.applySU2(target, control, Iter->p, Iter->theta, Iter->psi);
    break;
 
      case QKD::Measure: dl.measure(target);
    break;
      }
    }
  }
 
  // now A measures key
  dl.measure(keyA);
 
  // B measures key
  dl.measure(keyB);
 
  // project to both users accepting (conditioning):
  dl.project(arA, 1);
  dl.project(arB, 1);
 
  // check that there is something here (always possible to "reject" with probability 1)
  if(dl.density.empty())
    return 0;  // both parties are always saying 'reject' so no key so key-rate = 0.
 
  atk->begin();
 
  quantum::DensityList saveDL = dl;
  double bestRate = 2;
 
  while(!atk->getNext(EVec[0], EVec[1], EVec[2], EVec[3])){
    dl = saveDL;
    double paccept = dl.trace(EVec, E);
    // compute H(A|B):
    
    double p00 = dl.calculatePr(keyA, 0, keyB, 0, EVec, E);
    double p01 = dl.calculatePr(keyA, 0, keyB, 1, EVec, E);
    double p10 = dl.calculatePr(keyA, 1, keyB, 0, EVec, E);
    double p11 = dl.calculatePr(keyA, 1, keyB, 1, EVec, E);
    
    double HAB = entropy(p00, p01, p10, p11);
    double HB = entropy(p00 + p10);
 
    // compute S(A|E):
    // trace out B's wires:
    for(int w=keyA+1; w<E; ++w)
      dl.trace(w);
 
    // trace out A's extra wires:
    //for(int w=keyA+1; w<=T; ++w)
    //  dl.trace(w);
 
    double SAE = dl.entropy(EVec, E);
    dl.trace(keyA);
    double SE = dl.entropy(EVec, E);
    double rate = 100;
 
    if(COMPUTE_ACTUAL_RATE)
      rate = (SAE - SE) - (HAB - HB);
    else
      rate = paccept * ( (SAE-SE) - (HAB-HB) );
 
    if(rate < bestRate)
      bestRate = rate;
  }
 
  return bestRate;
}
 
 
void testSimple()
{
  std::list <QKD::Gate> A, B;
  QKD::Gate g;
  g.type = QKD::NOT;
  g.target = 2;
  A.push_back(g);
  ComputeFitness(A,B);
}
 
void testBB84()
{
  std::list <QKD::Gate> A, B;
  QKD::Gate g;
  g.type = QKD::NOT;
  g.target = 1;
  g.controlMode = false;
 
  A.push_back(g); // g1
 
  g.type = QKD::Hadamard;
  g.target = 0;
  g.controlMode = false;
 
  A.push_back(g); // g2
 
  g.type = QKD::NOT;
  g.target = 2;
  g.controlMode = true;
  g.control = 0;
 
  A.push_back(g); // g3
 
 
  g.type = QKD::NOT;
  g.target = 3;
  g.control = 2;
  g.controlMode = true;
 
  B.push_back(g); // h1
 
  g.type = QKD::NOT;
  g.target = 4;
  g.controlMode = false;
 
  B.push_back(g); // h2
 
 
  std::cout << "Test 1: key-rate (should be 1) = " << ComputeFitness(A,B) << "\n\n";
 
}
 
void test()
{
  std::list <QKD::Gate> A, B;
  QKD::Gate g;
  g.type = 2;
  g.target = 0;
  g.control = 1;
  g.controlMode = false;
  A.push_back(g); // g1
 
  g.type = 2;
  g.target = 0;
  g.controlMode = true;
  g.control = 0;
  A.push_back(g); // g2
 
  g.type = 1;
  g.target = 2;
  g.controlMode = false;
  g.control = 1;
  A.push_back(g); // g3
 
 
  g.type = 1;
  g.target = 4;
  g.control = 4;
  g.controlMode = true;
  B.push_back(g); // h1
 
  g.type = 1;
  g.target = 4;
  g.controlMode = false;
  g.control = 3;
  B.push_back(g); // h2
 
 
  std::cout << "Test 1: key-rate = " << ComputeFitness(A,B) << "\n\n";
}
 
 
int main(int argc, char** argv)
{
  QKD::Stats stats;
 
  stats.symmetric(.01);  // Test EA with different values between .01 and .5.
 
  setupAttackVectors(stats);
 
  testBB84();
 
  std::cout << "Above value should be = " << stats.BB84Rate() << "\n";
 
  delete atk;
 
  return 0;
}