Remapper.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _REMAPPER_H_
#define _REMAPPER_H_
 
#include "../Circuit/Circuit.h"
#include "../Circuit/Operations.h"
#include "../Circuit/Reset.h"
#include "../Network/Network.h"
 
namespace Distribution {

enum class RemapperType {
  kLayersRemapper, 
  kGreedyDirectRemapper 
};

template <typename Time = Types::time_type>
class IRemapper : public std::enable_shared_from_this<IRemapper<Time>> {
public:
  virtual ~IRemapper() = default;

  virtual std::shared_ptr<Circuits::Circuit<Time>>
  Remap(const std::shared_ptr<Network::INetwork<Time>> &network,
        const std::shared_ptr<Circuits::Circuit<Time>> &circuit) = 0;

  virtual unsigned int GetNumberOfOperationsForDistribution() const = 0;

  virtual unsigned int GetNumberOfDistributions() const = 0;

  std::shared_ptr<IRemapper<Time>> getptr() {
    return std::enable_shared_from_this<IRemapper<Time>>::shared_from_this();
  }

  virtual RemapperType GetType() const = 0;

  static bool
  IsNonLocalOperation(const std::shared_ptr<Circuits::IOperation<Time>> &op,
                      const std::shared_ptr<Network::INetwork<Time>> &network) {
    if (op->NeedsEntanglementForDistribution()) {
      auto qubits = op->AffectedQubits();
 
      if (qubits.size() >=
          2) // there should be no 3 qubit gates at this point, though
      {
        const size_t ctrlQubit = qubits[0];
        const size_t targetQubit = qubits[1];
 
        if (!network->AreQubitsOnSameHost(ctrlQubit, targetQubit))
          return true;
      }
    }
 
    return false;
  }

  virtual std::shared_ptr<Circuits::Circuit<Time>> SplitCompositeOperations(
      const std::shared_ptr<Network::INetwork<Time>> &network,
      const std::shared_ptr<Circuits::Circuit<Time>> &distCirc) const {
    // Measurement, RandomGen, ConditionalMeasurement, ConditionalRandomGen,
    // Reset... might involve qubits/classical bits that are on different hosts
    // - split them so they could be executed in any order independently on top
    // of that, conditional gates might need classical bits from different
    // hosts, handle that as well in the future such classical bits transfers
    // might be simulated using 'resources' involving queues or something like
    // that to simulate the classical network
 
    std::shared_ptr<Circuits::Circuit<Time>> newDistributedCircuit =
        std::make_shared<Circuits::Circuit<Time>>();
 
    for (const auto &op : distCirc->GetOperations()) {
      // the measurement, conditional measurement and reset are split based on
      // the qubits they operate on the others based on the classical bits
      // involved
 
      switch (op->GetType()) {
      case Circuits::OperationType::kMeasurement: {
        std::unordered_map<size_t,
                           std::vector<std::pair<Types::qubit_t, size_t>>>
            bits;
        const auto qbits = op->AffectedQubits();
        const auto cbits = op->AffectedBits();
 
        for (size_t q = 0; q < qbits.size(); ++q) {
          const size_t host = network->GetHostIdForAnyQubit(qbits[q]);
          bits[host].push_back({qbits[q], cbits[q]});
        }
 
        for (const auto &hostQubits : bits)
          newDistributedCircuit->AddOperation(
              std::make_shared<Circuits::MeasurementOperation<Time>>(
                  hostQubits.second));
      } break;
      case Circuits::OperationType::kConditionalMeasurement: {
        std::unordered_map<size_t,
                           std::vector<std::pair<Types::qubit_t, size_t>>>
            bits;
        auto condOp =
            std::static_pointer_cast<Circuits::ConditionalMeasurement<Time>>(
                op);
 
        const auto qbits = condOp->GetOperation()->AffectedQubits();
        const auto cbits = condOp->GetOperation()->AffectedBits();
 
        for (size_t q = 0; q < qbits.size(); ++q) {
          const size_t host = network->GetHostIdForAnyQubit(qbits[q]);
          bits[host].push_back({qbits[q], cbits[q]});
        }
 
        for (const auto &hostQubits : bits) {
          auto measOp = std::make_shared<Circuits::MeasurementOperation<Time>>(
              hostQubits.second);
          newDistributedCircuit->AddOperation(
              std::make_shared<Circuits::ConditionalMeasurement<Time>>(
                  measOp, condOp->GetCondition())); // condition stays the same
        }
      } break;
      case Circuits::OperationType::kReset: {
        std::unordered_map<size_t, Types::qubits_vector> bits;
        const auto qbits = op->AffectedQubits();
 
        for (const auto q : qbits) {
          const size_t host = network->GetHostIdForAnyQubit(q);
          bits[host].emplace_back(q);
        }
 
        for (const auto &hostQubits : bits)
          newDistributedCircuit->AddOperation(
              std::make_shared<Circuits::Reset<Time>>(hostQubits.second));
      } break;
      case Circuits::OperationType::kRandomGen: {
        std::unordered_map<size_t, std::vector<size_t>> bits;
        const std::vector<size_t> cbits = op->AffectedBits();
 
        for (const size_t c : cbits) {
          const size_t host = network->GetHostIdForClassicalBit(c);
          bits[host].emplace_back(c);
        }
 
        for (const auto &hostQubits : bits)
          newDistributedCircuit->AddOperation(
              std::make_shared<Circuits::Random<Time>>(hostQubits.second));
      } break;
      case Circuits::OperationType::kConditionalRandomGen: {
        std::unordered_map<size_t, std::vector<size_t>> bits;
        // split by operation (as in random gen), not by condition, that should
        // stay whole and be dealt with accordingly if classical network
        // simulation details are to be done
        auto condOp =
            std::static_pointer_cast<Circuits::ConditionalRandomGen<Time>>(op);
        const std::vector<size_t> cbits =
            condOp->GetOperation()->AffectedBits();
 
        for (const size_t c : cbits) {
          const size_t host = network->GetHostIdForClassicalBit(c);
          bits[host].emplace_back(c);
        }
 
        for (const auto &hostQubits : bits) {
          auto randomOp =
              std::make_shared<Circuits::Random<Time>>(hostQubits.second);
          newDistributedCircuit->AddOperation(
              std::make_shared<Circuits::ConditionalRandomGen<Time>>(
                  randomOp,
                  condOp->GetCondition())); // condition stays the same
        }
      } break;
      default:
        newDistributedCircuit->AddOperation(op);
        break;
      }
    }
 
    return newDistributedCircuit;
  }
};
 
} // namespace Distribution
 
#endif // !_REMAPPER_H_