QuestState.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _QUESTSTATE_H_
#define _QUESTSTATE_H_
 
#ifdef INCLUDED_BY_FACTORY
 
#include "QuestLibSim.h"
 
#include <random>
#include <unordered_map>
#include <vector>
 
#include "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 {
    // Quest only supports statevector, nothing to configure
  }

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

  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_