Remapper.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _REMAPPER_H_
#define _REMAPPER_H_
 
#include "../Circuit/Circuit.h"
#include "../Circuit/Operations/Operations.h"
#include "../Circuit/Operations/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();
                const auto measurement = std::static_pointer_cast<Circuits::MeasurementOperation<Time>>(op);
                std::unordered_map<size_t, std::vector<Circuits::ReadoutRates>> rates;
 
                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]});
                    if (measurement->HasReadout())
                        rates[host].push_back(measurement->GetReadout()[q]);
                }
 
                for (const auto &hostQubits : bits)
                {
                    auto split = std::make_shared<Circuits::MeasurementOperation<Time>>(hostQubits.second);
                    if (measurement->HasReadout())
                        split->SetReadout(std::move(rates[hostQubits.first]));
                    newDistributedCircuit->AddOperation(split);
                }
            }
            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();
                const auto measurement = std::static_pointer_cast<Circuits::MeasurementOperation<Time>>(condOp->GetOperation());
                std::unordered_map<size_t, std::vector<Circuits::ReadoutRates>> rates;
 
                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]});
                    if (measurement->HasReadout())
                        rates[host].push_back(measurement->GetReadout()[q]);
                }
 
                for (const auto &hostQubits : bits)
                {
                    auto measOp = std::make_shared<Circuits::MeasurementOperation<Time>>(hostQubits.second);
                    if (measurement->HasReadout())
                        measOp->SetReadout(std::move(rates[hostQubits.first]));
                    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();
                const auto reset = std::static_pointer_cast<Circuits::Reset<Time>>(op);
                const auto &resetTargets = reset->GetResetTargets();
                std::unordered_map<size_t, std::vector<bool>> targets;
 
                for (size_t q = 0; q < qbits.size(); ++q)
                {
                    const size_t host = network->GetHostIdForAnyQubit(qbits[q]);
                    bits[host].emplace_back(qbits[q]);
                    if (!resetTargets.empty())
                        targets[host].push_back(q < resetTargets.size() && resetTargets[q]);
                }
 
                for (const auto &hostQubits : bits)
                    newDistributedCircuit->AddOperation(
                        std::make_shared<Circuits::Reset<Time>>(hostQubits.second, reset->GetDelay(), targets[hostQubits.first]));
            }
            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_