QuestState.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _QUESTSTATE_H_
#define _QUESTSTATE_H_
 
#ifdef INCLUDED_BY_FACTORY
 
#include "../../Utils/Sampling/Alias.h"
#include "QuestLibSim.h"
 
#include <random>
#include <unordered_map>
#include <vector>
 
#include "../Core/Configuration.h"
 
namespace Simulators
{
namespace Private
{
class QuestState : public ISimulator
{
  public:
    QuestState() : rng(std::random_device{}()), uniformZeroOne(0, 1)
    {
    }

    void Initialize() override
    {
        if (!questLib)
            questLib = SimulatorsFactory::GetQuestLibrary();
        if (nrQubits && questLib && questLib->IsValid())
        {
            simHandle = questLib->CreateSimulator(static_cast<int>(nrQubits));
            sim = questLib->GetSimulator(simHandle);
            if (!sim)
                throw std::runtime_error("QuestState::Initialize: Failed to create "
                                         "and initialize the statevector state.");
        }
    }

    void InitializeState(size_t num_qubits, std::vector<std::complex<double>> &amplitudes) override
    {
        throw std::runtime_error("QuestState::InitializeState: Not supported for Quest simulator.");
    }

#ifndef NO_QISKIT_AER
    void InitializeState(size_t num_qubits, AER::Vector<std::complex<double>> &amplitudes) override
    {
        throw std::runtime_error("QuestState::InitializeState: Not supported for Quest simulator.");
    }
#endif

    void InitializeState(size_t num_qubits, Eigen::VectorXcd &amplitudes) override
    {
        throw std::runtime_error("QuestState::InitializeState: Not supported for Quest simulator.");
    }

    void Reset() override
    {
        if (sim && questLib)
        {
            questLib->DestroySimulator(simHandle);
            simHandle = questLib->CreateSimulator(static_cast<int>(nrQubits));
            sim = questLib->GetSimulator(simHandle);
        }
    }

    void Configure(const char *key, const char *value) override
    {
        if (std::string("seed") == key)
        {
            const uint64_t seed = std::stoull(value);
            SeedAuxiliaryRng(seed);
            rng.seed(seed);
            configuration.SetConfiguration(key, value);
        }
    }

    std::string GetConfiguration(const char *key) const override
    {
        if (std::string("method") == key)
            return "statevector";
        return configuration.GetConfiguration(key);
    }

    size_t AllocateQubits(size_t num_qubits) override
    {
        if (sim)
            return 0;
 
        const size_t oldNrQubits = nrQubits;
        nrQubits += num_qubits;
 
        return oldNrQubits;
    }

    size_t GetNumberOfQubits() const override
    {
        return nrQubits;
    }

    void Clear() override
    {
        if (sim && questLib)
        {
            questLib->DestroySimulator(simHandle);
            sim = nullptr;
            simHandle = 0;
        }
        if (savedSim && questLib)
        {
            questLib->DestroySimulator(savedSimHandle);
            savedSim = nullptr;
            savedSimHandle = 0;
        }
        nrQubits = 0;
    }

    size_t Measure(const Types::qubits_vector &qubits) override
    {
        if (qubits.size() > sizeof(size_t) * 8)
            std::cerr << "Warning: The number of qubits to measure is larger than the "
                         "number of bits in the size_t type, the outcome will be undefined"
                      << std::endl;
 
        DontNotify();
 
        std::vector<int> qb(qubits.begin(), qubits.end());
        const size_t res = static_cast<size_t>(questLib->MeasureQubits(sim, qb.data(), static_cast<int>(qubits.size())));
 
        Notify();
        NotifyObservers(qubits);
 
        return res;
    }

    std::vector<bool> MeasureMany(const Types::qubits_vector &qubits) override
    {
        std::vector<bool> res(qubits.size(), false);
 
        DontNotify();
 
        std::vector<int> qb(qubits.begin(), qubits.end());
        const size_t resm = static_cast<size_t>(questLib->MeasureQubits(sim, qb.data(), static_cast<int>(qubits.size())));
 
        size_t mask = 1ULL;
        for (size_t i = 0; i < qubits.size(); ++i)
        {
            res[i] = (resm & mask) != 0;
            mask <<= 1;
        }
 
        Notify();
        NotifyObservers(qubits);
 
        return res;
    }

    void ApplyReset(const Types::qubits_vector &qubits) override
    {
        DontNotify();
        std::vector<int> qb(qubits.begin(), qubits.end());
        const size_t res = static_cast<size_t>(questLib->MeasureQubits(sim, qb.data(), static_cast<int>(qubits.size())));
        size_t mask = 1ULL;
        for (size_t i = 0; i < qubits.size(); ++i)
        {
            if (res & mask)
                questLib->ApplyX(sim, static_cast<int>(qubits[i]));
            mask <<= 1;
        }
 
        Notify();
        NotifyObservers(qubits);
    }

    double Probability(Types::qubit_t outcome) override
    {
        return questLib->GetOutcomeProbability(sim, static_cast<long long int>(outcome));
    }

    std::complex<double> Amplitude(Types::qubit_t outcome) override
    {
        std::complex<double> amplitude;
        if (questLib->GetAmplitude(sim, static_cast<long long int>(outcome), amplitude))
        {
            return amplitude;
        }
        return std::complex<double>(0.0, 0.0);
    }

    std::complex<double> ProjectOnZero() override
    {
        return Amplitude(0);
    }

    std::vector<double> AllProbabilities() override
    {
        if (nrQubits == 0)
            return {};
        const size_t numStates = 1ULL << nrQubits;
        std::vector<std::complex<double>> amplitudes(numStates);
        questLib->GetAmplitudes(sim, amplitudes);
 
        std::vector<double> result(numStates);
        for (size_t i = 0; i < numStates; ++i)
            result[i] = std::norm(amplitudes[i]);
        return result;
    }

    std::vector<double> Probabilities(const Types::qubits_vector &qubits) override
    {
        std::vector<double> result(qubits.size());
        for (size_t i = 0; i < qubits.size(); ++i)
            result[i] = questLib->GetOutcomeProbability(sim, static_cast<long long int>(qubits[i]));
        return result;
    }

    std::unordered_map<Types::qubit_t, Types::qubit_t> SampleCounts(const Types::qubits_vector &qubits, size_t shots = 1000) override
    {
        if (qubits.empty() || shots == 0)
            return {};
 
        if (qubits.size() > sizeof(Types::qubit_t) * 8)
            std::cerr << "Warning: The number of qubits to measure is larger than the "
                         "number of bits in the Types::qubit_t type, the outcome will be "
                         "undefined"
                      << std::endl;
 
        std::unordered_map<Types::qubit_t, Types::qubit_t> result;
 
        if (shots > 1)
        {
            const size_t numStates = 1ULL << nrQubits;
            std::vector<std::complex<double>> amplitudes(numStates);
            questLib->GetAmplitudes(sim, amplitudes);
 
            const Utils::Alias alias(amplitudes);
 
            for (size_t shot = 0; shot < shots; ++shot)
            {
                const double prob = 1. - uniformZeroOne(rng);
                const size_t measRaw = alias.Sample(prob);
 
                size_t meas = 0;
                size_t mask = 1ULL;
                for (auto q : qubits)
                {
                    const size_t qubitMask = 1ULL << q;
                    if ((measRaw & qubitMask) != 0)
                        meas |= mask;
                    mask <<= 1ULL;
                }
 
                ++result[meas];
            }
        }
        else
        {
            for (size_t shot = 0; shot < shots; ++shot)
            {
                const size_t measRaw = MeasureNoCollapse();
                size_t meas = 0;
                size_t mask = 1ULL;
 
                for (auto q : qubits)
                {
                    const size_t qubitMask = 1ULL << q;
                    if ((measRaw & qubitMask) != 0)
                        meas |= mask;
                    mask <<= 1ULL;
                }
 
                ++result[meas];
            }
        }
 
        Notify();
        NotifyObservers(qubits);
 
        return result;
    }

    std::unordered_map<std::vector<bool>, Types::qubit_t> SampleCountsMany(const Types::qubits_vector &qubits, size_t shots = 1000) override
    {
        if (qubits.empty() || shots == 0)
            return {};
 
        std::unordered_map<std::vector<bool>, Types::qubit_t> result;
 
        if (shots > 1)
        {
            const size_t numStates = 1ULL << nrQubits;
            std::vector<std::complex<double>> amplitudes(numStates);
            questLib->GetAmplitudes(sim, amplitudes);
 
            const Utils::Alias alias(amplitudes);
 
            for (size_t shot = 0; shot < shots; ++shot)
            {
                const double prob = 1. - uniformZeroOne(rng);
                const size_t measRaw = alias.Sample(prob);
 
                std::vector<bool> meas(qubits.size(), false);
 
                for (size_t i = 0; i < qubits.size(); ++i)
                    if (((measRaw >> qubits[i]) & 1) == 1)
                        meas[i] = true;
 
                ++result[meas];
            }
        }
        else
        {
            for (size_t shot = 0; shot < shots; ++shot)
            {
                const auto measRaw = MeasureNoCollapseMany();
                std::vector<bool> meas(qubits.size(), false);
 
                for (size_t i = 0; i < qubits.size(); ++i)
                    if (measRaw[qubits[i]])
                        meas[i] = true;
 
                ++result[meas];
            }
        }
 
        Notify();
        NotifyObservers(qubits);
 
        return result;
    }

    double ExpectationValue(const std::string &pauliString) override
    {
        return questLib->GetExpectationValue(sim, pauliString.c_str());
    }

    SimulatorType GetType() const override
    {
        return SimulatorType::kQuestSim;
    }

    SimulationType GetSimulationType() const override
    {
        return SimulationType::kStatevector;
    }

    void Flush() override
    {
    }

    void SaveStateToInternalDestructive() override
    {
        if (savedSim && questLib)
        {
            questLib->DestroySimulator(savedSimHandle);
            savedSim = nullptr;
            savedSimHandle = 0;
        }
        savedSimHandle = simHandle;
        simHandle = 0;
        savedSim = sim;
        sim = nullptr;
    }

    void RestoreInternalDestructiveSavedState() override
    {
        if (sim && questLib)
            questLib->DestroySimulator(simHandle);
        simHandle = savedSimHandle;
        sim = savedSim;
        savedSimHandle = 0;
        savedSim = nullptr;
    }

    void SaveState() override
    {
        if (savedSim && questLib)
        {
            questLib->DestroySimulator(savedSimHandle);
            savedSim = nullptr;
            savedSimHandle = 0;
        }
        savedSimHandle = questLib->CloneSimulator(sim);
        savedSim = questLib->GetSimulator(savedSimHandle);
    }

    void RestoreState() override
    {
        if (sim && questLib)
            questLib->DestroySimulator(simHandle);
        simHandle = questLib->CloneSimulator(savedSim);
        sim = questLib->GetSimulator(simHandle);
    }

    std::complex<double> AmplitudeRaw(Types::qubit_t outcome) override
    {
        return Amplitude(outcome);
    }

    void SetMultithreading(bool multithreading = true) override
    {
        // Quest manages its own threading
    }

    bool GetMultithreading() const override
    {
        return true;
    }

    bool IsQcsim() const override
    {
        return false;
    }

    Types::qubit_t MeasureNoCollapse() override
    {
        if (nrQubits > sizeof(Types::qubit_t) * 8)
            std::cerr << "Warning: The number of qubits to measure is larger than the "
                         "number of bits in the Types::qubit_t type, the outcome will be "
                         "undefined"
                      << std::endl;
 
        const size_t numStates = 1ULL << nrQubits;
        std::vector<std::complex<double>> amplitudes(numStates);
        questLib->GetAmplitudes(sim, amplitudes);
 
        std::vector<double> probs(numStates);
        for (size_t i = 0; i < numStates; ++i)
            probs[i] = std::norm(amplitudes[i]);
 
        std::discrete_distribution<Types::qubit_t> dist(probs.begin(), probs.end());
 
        return dist(rng);
    }

    std::vector<bool> MeasureNoCollapseMany() override
    {
        const auto meas = MeasureNoCollapse();
        std::vector<bool> result(nrQubits, false);
        for (size_t i = 0; i < nrQubits; ++i)
            result[i] = ((meas >> i) & 1) == 1;
        return result;
    }
 
    const Configuration &GetConfiguration() const
    {
        return configuration;
    }
 
    const std::unordered_map<std::string, std::string> &GetConfigMap() const override
    {
        return configuration.GetConfigMap();
    }
 
  protected:
    std::shared_ptr<QuestLibSim> questLib; 
    unsigned long int simHandle = 0;       
    void *sim = nullptr;                   
    size_t nrQubits = 0;                   
    unsigned long int savedSimHandle = 0;  
    void *savedSim = nullptr;              
    std::mt19937_64 rng;
    std::uniform_real_distribution<double> uniformZeroOne;
 
    Configuration configuration; 
};
} // namespace Private
} // namespace Simulators
 
#endif
 
#endif // _QUESTSTATE_H_