AerSimulator.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _AER_SIMULATOR_H_
#define _AER_SIMULATOR_H_
 
#ifndef NO_QISKIT_AER
 
#ifdef INCLUDED_BY_FACTORY
 
#include "AerState.h"
 
namespace Simulators {
// TODO: Maybe use the pimpl idiom
// https://en.cppreference.com/w/cpp/language/pimpl to hide the implementation
// for good but during development this should be good enough
namespace Private {

class AerSimulator : public AerState {
public:
  AerSimulator() = default;
  // allow no copy or assignment
  AerSimulator(const AerSimulator &) = delete;
  AerSimulator &operator=(const AerSimulator &) = delete;
 
  // but allow moving
  AerSimulator(AerSimulator &&other) = default;
  AerSimulator &operator=(AerSimulator &&other) = default;

  void ApplyP(Types::qubit_t qubit, double lambda) override {
    const Types::qubits_vector qubits = {qubit};
 
    const AER::cvector_t P = {{1, 0}, std::polar(1., lambda)};
    state->apply_diagonal_matrix(qubits, P);
 
    NotifyObservers(qubits);
  }

  void ApplyX(Types::qubit_t qubit) override {
    const Types::qubits_vector qubits = {qubit};
    state->apply_x(qubit);
    NotifyObservers(qubits);
  }

  void ApplyY(Types::qubit_t qubit) override {
    const Types::qubits_vector qubits = {qubit};
    state->apply_y(qubit);
    NotifyObservers(qubits);
  }

  void ApplyZ(Types::qubit_t qubit) override {
    const Types::qubits_vector qubits = {qubit};
    state->apply_z(qubit);
    NotifyObservers(qubits);
  }

  void ApplyH(Types::qubit_t qubit) override {
    const Types::qubits_vector qubits = {qubit};
    state->apply_h(qubit);
    NotifyObservers(qubits);
  }

  void ApplyS(Types::qubit_t qubit) override {
    const Types::qubits_vector qubits = {qubit};
 
    if (GetSimulationType() == SimulationType::kStabilizer) {
      AER::Operations::Op op;
      op.type = AER::Operations::OpType::gate;
      op.name = "s";
      op.qubits = AER::reg_t{qubit};
 
      state->buffer_op(std::move(op));
    } else {
      const AER::cvector_t S = {{1, 0}, complex_t(0.0, 1)};
      state->apply_diagonal_matrix(qubits, S);
    }
 
    NotifyObservers(qubits);
  }

  void ApplySDG(Types::qubit_t qubit) override {
    const Types::qubits_vector qubits = {qubit};
 
    if (GetSimulationType() == SimulationType::kStabilizer) {
      AER::Operations::Op op;
      op.type = AER::Operations::OpType::gate;
      op.name = "sdg";
      op.qubits = AER::reg_t{qubit};
 
      state->buffer_op(std::move(op));
    } else {
      const AER::cvector_t Sdg = {{1, 0}, complex_t(0.0, -1)};
      state->apply_diagonal_matrix(qubits, Sdg);
    }
 
    NotifyObservers(qubits);
  }

  void ApplyT(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error("T gate not supported in stabilizer simulation");
 
    const Types::qubits_vector qubits = {qubit};
    // state->apply_u(qubit, 0, 0, M_PI / 4.0);
 
    const AER::cvector_t T = {{1, 0}, std::polar<double>(1, M_PI / 4.)};
    state->apply_diagonal_matrix(qubits, T);
 
    NotifyObservers(qubits);
  }

  void ApplyTDG(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error(
          "TDG gate not supported in stabilizer simulation");
 
    const Types::qubits_vector qubits = {qubit};
    // state->apply_u(qubit, 0, 0, -M_PI / 4.0);
 
    const AER::cvector_t Tdg = {{1, 0}, std::polar<double>(1, -M_PI / 4.)};
    state->apply_diagonal_matrix(qubits, Tdg);
 
    NotifyObservers(qubits);
  }

  void ApplySx(Types::qubit_t qubit) override {
    const Types::qubits_vector qubits = {qubit};
 
    if (GetSimulationType() == SimulationType::kStabilizer) {
      AER::Operations::Op op;
      op.type = AER::Operations::OpType::gate;
      op.name = "sx";
      op.qubits = AER::reg_t{qubit};
 
      state->buffer_op(std::move(op));
    } else {
      // there is a difference in the global phase for this
      // changed to match qcsim behavior (and also the qiskit docs and
      // implementation - not the one exposed in 'contrib', though)
      // state->apply_mcrx({ qubit }, -M_PI / 4.0);
      state->apply_unitary(qubits, AER::Linalg::Matrix::SX);
    }
 
    NotifyObservers(qubits);
  }

  void ApplySxDAG(Types::qubit_t qubit) override {
    const Types::qubits_vector qubits = {qubit};
 
    if (GetSimulationType() == SimulationType::kStabilizer) {
      AER::Operations::Op op;
      op.type = AER::Operations::OpType::gate;
      op.name = "sxdg";
      op.qubits = AER::reg_t{qubit};
 
      state->buffer_op(std::move(op));
    } else
      state->apply_unitary(qubits, AER::Linalg::Matrix::SXDG);
 
    NotifyObservers(qubits);
  }

  void ApplyK(Types::qubit_t qubit) override {
    const Types::qubits_vector qubits = {qubit};
 
    if (GetSimulationType() == SimulationType::kStabilizer) {
      ApplyZ(qubit);
      ApplyS(qubit);
      ApplyH(qubit);
      ApplyS(qubit);
    } else {
      static const cmatrix_t K = AER::Utils::make_matrix<complex_t>(
          {{{1. / std::sqrt(2.), 0}, {0, -1. / std::sqrt(2.)}},
           {{0, 1. / std::sqrt(2.)}, {-1. / std::sqrt(2.), 0}}});
 
      state->apply_unitary(qubits, K);
    }
 
    NotifyObservers(qubits);
  }

  void ApplyRx(Types::qubit_t qubit, double theta) override {
    if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error(
          "Rx gate not supported in stabilizer simulation");
 
    const Types::qubits_vector qubits = {qubit};
    const cmatrix_t rx = AER::Linalg::Matrix::rx(theta);
 
    state->apply_unitary(qubits, rx);
 
    NotifyObservers(qubits);
  }

  void ApplyRy(Types::qubit_t qubit, double theta) override {
    if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error(
          "Ry gate not supported in stabilizer simulation");
 
    const Types::qubits_vector qubits = {qubit};
    const cmatrix_t ry = AER::Linalg::Matrix::ry(theta);
 
    state->apply_unitary(qubits, ry);
 
    NotifyObservers(qubits);
  }

  void ApplyRz(Types::qubit_t qubit, double theta) override {
    if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error(
          "Rz gate not supported in stabilizer simulation");
 
    const Types::qubits_vector qubits = {qubit};
    const cmatrix_t rz = AER::Linalg::Matrix::rz(theta);
 
    state->apply_unitary(qubits, rz);
 
    NotifyObservers(qubits);
  }

  void ApplyU(Types::qubit_t qubit, double theta, double phi, double lambda,
              double gamma) override {
    if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error("U gate not supported in stabilizer simulation");
 
    const Types::qubits_vector qubits = {qubit};
    const cmatrix_t u = AER::Linalg::Matrix::u4(theta, phi, lambda, gamma);
 
    state->apply_unitary(qubits, u);
 
    NotifyObservers(qubits);
  }

  void ApplyCX(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) override {
    const Types::qubits_vector qubits = {ctrl_qubit, tgt_qubit};
    state->apply_cx(qubits);
    NotifyObservers(qubits);
  }

  void ApplyCY(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) override {
    const Types::qubits_vector qubits = {ctrl_qubit, tgt_qubit};
    state->apply_cy(qubits);
    NotifyObservers(qubits);
  }

  void ApplyCZ(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) override {
    const Types::qubits_vector qubits = {ctrl_qubit, tgt_qubit};
    state->apply_cz(qubits);
    NotifyObservers(qubits);
  }

  void ApplyCP(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit,
               double lambda) override {
    if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error(
          "CP gate not supported in stabilizer simulation");
 
    const Types::qubits_vector qubits = {ctrl_qubit, tgt_qubit};
    const cmatrix_t CP = AER::Linalg::Matrix::cphase(lambda);
    // state->apply_mcphase(qubits, lambda);
    state->apply_unitary(qubits, CP);
 
    NotifyObservers(qubits);
  }

  void ApplyCRx(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit,
                double theta) override {
    if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error(
          "CRx gate not supported in stabilizer simulation");
 
    const Types::qubits_vector qubits = {ctrl_qubit, tgt_qubit};
 
    cmatrix_t mat(4, 4);
    mat(0, 0) = 1;
    mat(2, 2) = 1;
 
    const double t2 = theta * 0.5;
 
    const complex_t i(0., 1.);
    mat(1, 1) = std::cos(t2);
    mat(1, 3) = -i * std::sin(t2);
    mat(3, 1) = mat(1, 3);
    mat(3, 3) = mat(1, 1);
 
    // state->apply_mcrx(qubits, theta);
    state->apply_unitary(qubits, mat);
 
    NotifyObservers(qubits);
  }

  void ApplyCRy(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit,
                double theta) override {
    if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error(
          "CRy gate not supported in stabilizer simulation");
 
    const Types::qubits_vector qubits = {ctrl_qubit, tgt_qubit};
 
    cmatrix_t mat(4, 4);
    mat(0, 0) = 1;
    mat(2, 2) = 1;
 
    const double t2 = theta * 0.5;
 
    mat(1, 1) = std::complex<double>(cos(t2), 0);
    mat(1, 3) = std::complex<double>(-sin(t2), 0);
    mat(3, 1) = std::complex<double>(sin(t2), 0);
    mat(3, 3) = mat(1, 1);
 
    // state->apply_mcry(qubits, theta);
    state->apply_unitary(qubits, mat);
 
    NotifyObservers(qubits);
  }

  void ApplyCRz(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit,
                double theta) override {
    if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error(
          "CRz gate not supported in stabilizer simulation");
 
    const Types::qubits_vector qubits = {ctrl_qubit, tgt_qubit};
 
    const double t2 = theta * 0.5;
    AER::cvector_t v = {
        {1, 0}, std::polar(1., -t2), {1, 0}, std::polar(1., t2)};
 
    // state->apply_mcrz(qubits, theta);
    state->apply_diagonal_matrix(qubits, v);
 
    NotifyObservers(qubits);
  }

  void ApplyCH(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) override {
    if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error(
          "CH gate not supported in stabilizer simulation");
 
    const Types::qubits_vector qubits = {ctrl_qubit, tgt_qubit};
    const cmatrix_t CU = AER::Linalg::Matrix::cu(M_PI_2, 0, M_PI, 0);
    state->apply_unitary(qubits, CU);
    // state->apply_cu(qubits, M_PI_2, 0, M_PI, 0);
 
    NotifyObservers(qubits);
  }

  void ApplyCSx(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) override {
    if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error(
          "CSx gate not supported in stabilizer simulation");
 
    static const cmatrix_t CSX = AER::Utils::make_matrix<complex_t>(
        {{{1, 0}, {0, 0}, {0, 0}, {0, 0}},
         {{0, 0}, {0.5, 0.5}, {0, 0}, {0.5, -0.5}},
         {{0, 0}, {0, 0}, {1, 0}, {0, 0}},
         {{0, 0}, {0.5, -0.5}, {0, 0}, {0.5, 0.5}}});
 
    const Types::qubits_vector qubits = {ctrl_qubit, tgt_qubit};
    state->apply_unitary(qubits, CSX);
    NotifyObservers(qubits);
  }

  void ApplyCSxDAG(Types::qubit_t ctrl_qubit,
                   Types::qubit_t tgt_qubit) override {
    if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error(
          "CSxDAG gate not supported in stabilizer simulation");
 
    static const cmatrix_t CSXDG = AER::Utils::make_matrix<complex_t>(
        {{{1, 0}, {0, 0}, {0, 0}, {0, 0}},
         {{0, 0}, {0.5, -0.5}, {0, 0}, {0.5, 0.5}},
         {{0, 0}, {0, 0}, {1, 0}, {0, 0}},
         {{0, 0}, {0.5, 0.5}, {0, 0}, {0.5, -0.5}}});
 
    const Types::qubits_vector qubits = {ctrl_qubit, tgt_qubit};
    state->apply_unitary(qubits, CSXDG);
    NotifyObservers(qubits);
  }

  void ApplySwap(Types::qubit_t qubit0, Types::qubit_t qubit1) override {
    const Types::qubits_vector qubits = {qubit0, qubit1};
 
    if (GetSimulationType() == SimulationType::kStabilizer) {
      AER::Operations::Op op;
      op.type = AER::Operations::OpType::gate;
      op.name = "swap";
      op.qubits = AER::reg_t{qubit0, qubit1};
 
      state->buffer_op(std::move(op));
    } else
      // state->apply_mcswap(qubits);
      state->apply_unitary(qubits, AER::Linalg::Matrix::SWAP);
 
    NotifyObservers(qubits);
  }

  void ApplyCCX(Types::qubit_t qubit0, Types::qubit_t qubit1,
                Types::qubit_t qubit2) override {
    if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error(
          "CCX gate not supported in stabilizer simulation");
 
    const Types::qubits_vector qubits = {qubit0, qubit1, qubit2};
 
    static const cmatrix_t mat = AER::Utils::make_matrix<complex_t>(
        {{{1, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}},
         {{0, 0}, {1, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}},
         {{0, 0}, {0, 0}, {1, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}},
         {{0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {1, 0}},
         {{0, 0}, {0, 0}, {0, 0}, {0, 0}, {1, 0}, {0, 0}, {0, 0}, {0, 0}},
         {{0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {1, 0}, {0, 0}, {0, 0}},
         {{0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {1, 0}, {0, 0}},
         {{0, 0}, {0, 0}, {0, 0}, {1, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}}});
 
    // state->apply_mcx(qubits);
    state->apply_unitary(qubits, mat);
 
    NotifyObservers(qubits);
  }

  void ApplyCSwap(Types::qubit_t ctrl_qubit, Types::qubit_t qubit0,
                  Types::qubit_t qubit1) override {
    if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error(
          "CSwap gate not supported in stabilizer simulation");
 
    const Types::qubits_vector qubits = {ctrl_qubit, qubit0, qubit1};
 
    static const cmatrix_t mat = AER::Utils::make_matrix<complex_t>(
        {{{1, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}},
         {{0, 0}, {1, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}},
         {{0, 0}, {0, 0}, {1, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}},
         {{0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {1, 0}, {0, 0}, {0, 0}},
         {{0, 0}, {0, 0}, {0, 0}, {0, 0}, {1, 0}, {0, 0}, {0, 0}, {0, 0}},
         {{0, 0}, {0, 0}, {0, 0}, {1, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}},
         {{0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {1, 0}, {0, 0}},
         {{0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {1, 0}}});
 
    // state->apply_mcswap(qubits);
    state->apply_unitary(qubits, mat);
 
    NotifyObservers(qubits);
  }

  void ApplyCU(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit,
               double theta, double phi, double lambda, double gamma) override {
    if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error(
          "CU gate not supported in stabilizer simulation");
 
    const Types::qubits_vector qubits = {ctrl_qubit, tgt_qubit};
 
    const cmatrix_t CU = AER::Linalg::Matrix::cu(theta, phi, lambda, gamma);
    // state->apply_mcu(qubits, theta, phi, lambda, gamma);
    state->apply_unitary(qubits, CU);
 
    NotifyObservers(qubits);
  }

  void ApplyNop() override {
    AER::Operations::Op op;
    op.type =
        AER::Operations::OpType::barrier; // there is also 'nop' but that one
                                          // doesn't work with stabilizer
    state->buffer_op(std::move(op));
  }

  std::unique_ptr<ISimulator> Clone() override {
    auto sim = std::make_unique<AerSimulator>();
 
    // the tricky part is cloning the state
    if (simulationType == SimulationType::kMatrixProductState)
      sim->Configure("method", "matrix_product_state");
    else if (simulationType == SimulationType::kStabilizer)
      sim->Configure("method", "stabilizer");
    else if (simulationType == SimulationType::kTensorNetwork)
      sim->Configure("method", "tensor_network");
    else
      sim->Configure("method", "statevector");
 
    if (simulationType == SimulationType::kMatrixProductState) {
      if (limitSize)
        sim->Configure("matrix_product_state_max_bond_dimension",
                       std::to_string(chi).c_str());
      if (limitEntanglement)
        sim->Configure("matrix_product_state_truncation_threshold",
                       std::to_string(singularValueThreshold).c_str());
      sim->Configure("mps_sample_measure_algorithm", useMPSMeasureNoCollapse
                                                         ? "mps_probabilities"
                                                         : "mps_apply_measure");
    }
 
    sim->SetMultithreading(
        enableMultithreading); 
 
    AER::Vector<complex_t> localSavedAmplitudes =
        savedAmplitudes; 
    AER::Data localSavedState =
        savedState; 
 
    // now the tricky part
    if (state && state->is_initialized()) {
      SaveState(); // this also restores the state if it's destroyed in the
                   // saving process!
      // now the current state is saved in savedAmplitudes or savedState, so use
      // it to initialize the cloned state, like this
      sim->savedAmplitudes = std::move(savedAmplitudes);
      sim->savedState = std::move(savedState);
 
      sim->RestoreState(); // now the state is loaded in the cloned simulator
 
      // those saved previously can be an older state, so put them in the clone,
      // too
      sim->savedAmplitudes = localSavedAmplitudes;
      sim->savedState = localSavedState;
 
      // those saved previously can be an older state, so put them back
      savedAmplitudes = std::move(localSavedAmplitudes);
      savedState = std::move(localSavedState);
    } else {
      // std::cout << "Restored from non initialized state" << std::endl;
      sim->savedAmplitudes = std::move(localSavedAmplitudes);
      sim->savedState = std::move(localSavedState);
 
      sim->RestoreState(); // this might not be necessary, but sometimes, not
                           // very often, an exception is thrown about the state
                           // not being initialized, this might prevent that
    }
 
    return sim;
  }
};
 
} // namespace Private
} // namespace Simulators
 
#endif
 
#endif
 
#endif