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_