QCSimSimulator.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _QCSIMSIMULATOR_H
#define _QCSIMSIMULATOR_H
 
#ifdef INCLUDED_BY_FACTORY
 
#include "QCSimState.h"
 
#define _USE_MATH_DEFINES
#include <math.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 IndividualSimulator;

class QCSimSimulator : public QCSimState {
  friend class IndividualSimulator;
 
public:
  QCSimSimulator() = default;
  // allow no copy or assignment
  QCSimSimulator(const QCSimSimulator &) = delete;
  QCSimSimulator &operator=(const QCSimSimulator &) = delete;
 
  // but allow moving
  QCSimSimulator(QCSimSimulator &&other) = default;
  QCSimSimulator &operator=(QCSimSimulator &&other) = default;

  void ApplyP(Types::qubit_t qubit, double lambda) override {
    pgate.SetPhaseShift(lambda);
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(pgate, static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer) {
      if (std::abs(lambda - M_PI_2) > 1e-10)
        throw std::runtime_error("QCSimSimulator::ApplyP: Invalid phase shift "
                                 "angle for a Clifford gate.");
      cliffordSimulator->ApplyS(static_cast<unsigned int>(qubit));
    } else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(pgate, static_cast<unsigned int>(qubit));
    else
      state->ApplyGate(pgate, static_cast<unsigned int>(qubit));
    NotifyObservers({qubit});
  }

  void ApplyX(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(xgate, static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      cliffordSimulator->ApplyX(static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(xgate, static_cast<unsigned int>(qubit));
    else
      state->ApplyGate(xgate, static_cast<unsigned int>(qubit));
    NotifyObservers({qubit});
  }

  void ApplyY(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(ygate, static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      cliffordSimulator->ApplyY(static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(ygate, static_cast<unsigned int>(qubit));
    else
      state->ApplyGate(ygate, static_cast<unsigned int>(qubit));
    NotifyObservers({qubit});
  }

  void ApplyZ(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(zgate, static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      cliffordSimulator->ApplyZ(static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(zgate, static_cast<unsigned int>(qubit));
    else
      state->ApplyGate(zgate, static_cast<unsigned int>(qubit));
    NotifyObservers({qubit});
  }

  void ApplyH(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(h, static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      cliffordSimulator->ApplyH(static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(h, static_cast<unsigned int>(qubit));
    else
      state->ApplyGate(h, static_cast<unsigned int>(qubit));
    NotifyObservers({qubit});
  }

  void ApplyS(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(sgate, static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      cliffordSimulator->ApplyS(static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(sgate, static_cast<unsigned int>(qubit));
    else
      state->ApplyGate(sgate, static_cast<unsigned int>(qubit));
    NotifyObservers({qubit});
  }

  void ApplySDG(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(sdggate, static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      cliffordSimulator->ApplySdg(static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(sdggate, static_cast<unsigned int>(qubit));
    else
      state->ApplyGate(sdggate, static_cast<unsigned int>(qubit));
    NotifyObservers({qubit});
  }

  void ApplyT(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(tgate, static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error(
          "QCSimSimulator::ApplyT: The stabilizer simulator does not support "
          "non-clifford gates.");
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(tgate, static_cast<unsigned int>(qubit));
    else
      state->ApplyGate(tgate, static_cast<unsigned int>(qubit));
    NotifyObservers({qubit});
  }

  void ApplyTDG(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(tdggate, static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error(
          "QCSimSimulator::ApplyTDG: The stabilizer simulator does not support "
          "non-clifford gates.");
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(tdggate, static_cast<unsigned int>(qubit));
    else
      state->ApplyGate(tdggate, static_cast<unsigned int>(qubit));
    NotifyObservers({qubit});
  }

  void ApplySx(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(sxgate, static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      cliffordSimulator->ApplySx(static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(sxgate, static_cast<unsigned int>(qubit));
    else
      state->ApplyGate(sxgate, static_cast<unsigned int>(qubit));
    NotifyObservers({qubit});
  }

  void ApplySxDAG(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(sxdaggate, static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      cliffordSimulator->ApplySxDag(static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(sxdaggate, static_cast<unsigned int>(qubit));
    else
      state->ApplyGate(sxdaggate, static_cast<unsigned int>(qubit));
    NotifyObservers({qubit});
  }

  void ApplyK(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(k, static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      cliffordSimulator->ApplyK(static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(k, static_cast<unsigned int>(qubit));
    else
      state->ApplyGate(k, static_cast<unsigned int>(qubit));
    NotifyObservers({qubit});
  }

  void ApplyRx(Types::qubit_t qubit, double theta) override {
    rxgate.SetTheta(theta);
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(rxgate, static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error("QCSimSimulator::ApplyRx: The stabilizer "
                               "simulator does not support the Rx gate.");
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(rxgate, static_cast<unsigned int>(qubit));
    else
      state->ApplyGate(rxgate, static_cast<unsigned int>(qubit));
    NotifyObservers({qubit});
  }

  void ApplyRy(Types::qubit_t qubit, double theta) override {
    rygate.SetTheta(theta);
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(rygate, static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error("QCSimSimulator::ApplyRy: The stabilizer "
                               "simulator does not support the Ry gate.");
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(rygate, static_cast<unsigned int>(qubit));
    else
      state->ApplyGate(rygate, static_cast<unsigned int>(qubit));
    NotifyObservers({qubit});
  }

  void ApplyRz(Types::qubit_t qubit, double theta) override {
    rzgate.SetTheta(theta);
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(rzgate, static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error("QCSimSimulator::ApplyRz: The stabilizer "
                               "simulator does not support the Rz gate.");
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(rzgate, static_cast<unsigned int>(qubit));
    else
      state->ApplyGate(rzgate, static_cast<unsigned int>(qubit));
    NotifyObservers({qubit});
  }

  void ApplyU(Types::qubit_t qubit, double theta, double phi, double lambda,
              double gamma) override {
    ugate.SetParams(theta, phi, lambda, gamma);
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(ugate, static_cast<unsigned int>(qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error("QCSimSimulator::ApplyU: The stabilizer "
                               "simulator does not support the U gate.");
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(ugate, static_cast<unsigned int>(qubit));
    else
      state->ApplyGate(ugate, static_cast<unsigned int>(qubit));
    NotifyObservers({qubit});
  }

  void ApplyCX(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(cxgate, static_cast<unsigned int>(tgt_qubit),
                              static_cast<unsigned int>(ctrl_qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      cliffordSimulator->ApplyCX(static_cast<unsigned int>(tgt_qubit),
                                 static_cast<unsigned int>(ctrl_qubit));
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(cxgate, static_cast<unsigned int>(ctrl_qubit),
                             static_cast<unsigned int>(tgt_qubit));
    else
      state->ApplyGate(cxgate, static_cast<unsigned int>(tgt_qubit),
                       static_cast<unsigned int>(ctrl_qubit));
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCY(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(cygate, static_cast<unsigned int>(tgt_qubit),
                              static_cast<unsigned int>(ctrl_qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      cliffordSimulator->ApplyCY(static_cast<unsigned int>(tgt_qubit),
                                 static_cast<unsigned int>(ctrl_qubit));
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(cygate, static_cast<unsigned int>(ctrl_qubit),
                             static_cast<unsigned int>(tgt_qubit));
    else
      state->ApplyGate(cygate, static_cast<unsigned int>(tgt_qubit),
                       static_cast<unsigned int>(ctrl_qubit));
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCZ(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(czgate, static_cast<unsigned int>(tgt_qubit),
                              static_cast<unsigned int>(ctrl_qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      cliffordSimulator->ApplyCZ(static_cast<unsigned int>(tgt_qubit),
                                 static_cast<unsigned int>(ctrl_qubit));
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(czgate, static_cast<unsigned int>(ctrl_qubit),
                             static_cast<unsigned int>(tgt_qubit));
    else
      state->ApplyGate(czgate, static_cast<unsigned int>(tgt_qubit),
                       static_cast<unsigned int>(ctrl_qubit));
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCP(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit,
               double lambda) override {
    cpgate.SetPhaseShift(lambda);
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(cpgate, static_cast<unsigned int>(tgt_qubit),
                              static_cast<unsigned int>(ctrl_qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error("QCSimSimulator::ApplyCP: The stabilizer "
                               "simulator does not support the CP gate.");
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(cpgate, static_cast<unsigned int>(ctrl_qubit),
                             static_cast<unsigned int>(tgt_qubit));
    else
      state->ApplyGate(cpgate, static_cast<unsigned int>(tgt_qubit),
                       static_cast<unsigned int>(ctrl_qubit));
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCRx(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit,
                double theta) override {
    crxgate.SetTheta(theta);
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(crxgate, static_cast<unsigned int>(tgt_qubit),
                              static_cast<unsigned int>(ctrl_qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error("QCSimSimulator::ApplyCRx: The stabilizer "
                               "simulator does not support the CRx gate.");
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(crxgate, static_cast<unsigned int>(ctrl_qubit),
                             static_cast<unsigned int>(tgt_qubit));
    else
      state->ApplyGate(crxgate, static_cast<unsigned int>(tgt_qubit),
                       static_cast<unsigned int>(ctrl_qubit));
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCRy(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit,
                double theta) override {
    crygate.SetTheta(theta);
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(crygate, static_cast<unsigned int>(tgt_qubit),
                              static_cast<unsigned int>(ctrl_qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error("QCSimSimulator::ApplyCRy: The stabilizer "
                               "simulator does not support the CRy gate.");
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(crygate, static_cast<unsigned int>(ctrl_qubit),
                             static_cast<unsigned int>(tgt_qubit));
    else
      state->ApplyGate(crygate, static_cast<unsigned int>(tgt_qubit),
                       static_cast<unsigned int>(ctrl_qubit));
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCRz(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit,
                double theta) override {
    crzgate.SetTheta(theta);
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(crzgate, static_cast<unsigned int>(tgt_qubit),
                              static_cast<unsigned int>(ctrl_qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error("QCSimSimulator::ApplyCRz: The stabilizer "
                               "simulator does not support the CRz gate.");
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(crzgate, static_cast<unsigned int>(ctrl_qubit),
                             static_cast<unsigned int>(tgt_qubit));
    else
      state->ApplyGate(crzgate, static_cast<unsigned int>(tgt_qubit),
                       static_cast<unsigned int>(ctrl_qubit));
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCH(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(ch, static_cast<unsigned int>(tgt_qubit),
                              static_cast<unsigned int>(ctrl_qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error("QCSimSimulator::ApplyCH: The stabilizer "
                               "simulator does not support the CH gate.");
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(ch, static_cast<unsigned int>(ctrl_qubit),
                             static_cast<unsigned int>(tgt_qubit));
    else
      state->ApplyGate(ch, static_cast<unsigned int>(tgt_qubit),
                       static_cast<unsigned int>(ctrl_qubit));
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCSx(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(csx, static_cast<unsigned int>(tgt_qubit),
                              static_cast<unsigned int>(ctrl_qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error("QCSimSimulator::ApplyCSx: The stabilizer "
                               "simulator does not support the CSx gate.");
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(csx, static_cast<unsigned int>(ctrl_qubit),
                             static_cast<unsigned int>(tgt_qubit));
    else
      state->ApplyGate(csx, static_cast<unsigned int>(tgt_qubit),
                       static_cast<unsigned int>(ctrl_qubit));
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCSxDAG(Types::qubit_t ctrl_qubit,
                   Types::qubit_t tgt_qubit) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(csxdag, static_cast<unsigned int>(tgt_qubit),
                              static_cast<unsigned int>(ctrl_qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error("QCSimSimulator::ApplyCSxDAG: The stabilizer "
                               "simulator does not support the CSxDag gate.");
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(csxdag, static_cast<unsigned int>(ctrl_qubit),
                             static_cast<unsigned int>(tgt_qubit));
    else
      state->ApplyGate(csxdag, static_cast<unsigned int>(tgt_qubit),
                       static_cast<unsigned int>(ctrl_qubit));
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplySwap(Types::qubit_t qubit0, Types::qubit_t qubit1) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(swapgate, static_cast<unsigned int>(qubit1),
                              static_cast<unsigned int>(qubit0));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      cliffordSimulator->ApplySwap(static_cast<unsigned int>(qubit1),
                                   static_cast<unsigned int>(qubit0));
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(swapgate, static_cast<unsigned int>(qubit0),
                             static_cast<unsigned int>(qubit1));
    else
      state->ApplyGate(swapgate, static_cast<unsigned int>(qubit1),
                       static_cast<unsigned int>(qubit0));
    NotifyObservers({qubit1, qubit0});
  }

  void ApplyCCX(Types::qubit_t qubit0, Types::qubit_t qubit1,
                Types::qubit_t qubit2) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState) {
      const size_t q1 = qubit0; // control 1
      const size_t q2 = qubit1; // control 2
      const size_t q3 = qubit2; // target
 
      // Sleator-Weinfurter decomposition
      mpsSimulator->ApplyGate(csx, static_cast<unsigned int>(q3),
                              static_cast<unsigned int>(q2));
      mpsSimulator->ApplyGate(cxgate, static_cast<unsigned int>(q2),
                              static_cast<unsigned int>(q1));
      mpsSimulator->ApplyGate(csxdag, static_cast<unsigned int>(q3),
                              static_cast<unsigned int>(q2));
      mpsSimulator->ApplyGate(cxgate, static_cast<unsigned int>(q2),
                              static_cast<unsigned int>(q1));
      mpsSimulator->ApplyGate(csx, static_cast<unsigned int>(q3),
                              static_cast<unsigned int>(q1));
    } else if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error("QCSimSimulator::ApplyCCX: The stabilizer "
                               "simulator does not support the CCX gate.");
    else if (GetSimulationType() == SimulationType::kTensorNetwork) {
      const size_t q1 = qubit0; // control 1
      const size_t q2 = qubit1; // control 2
      const size_t q3 = qubit2; // target
 
      // Sleator-Weinfurter decomposition
      tensorNetwork->AddGate(csx, static_cast<unsigned int>(q2),
                             static_cast<unsigned int>(q3));
      tensorNetwork->AddGate(cxgate, static_cast<unsigned int>(q1),
                             static_cast<unsigned int>(q2));
      tensorNetwork->AddGate(csxdag, static_cast<unsigned int>(q2),
                             static_cast<unsigned int>(q3));
      tensorNetwork->AddGate(cxgate, static_cast<unsigned int>(q1),
                             static_cast<unsigned int>(q2));
      tensorNetwork->AddGate(csx, static_cast<unsigned int>(q1),
                             static_cast<unsigned int>(q3));
    } else
      state->ApplyGate(ccxgate, static_cast<unsigned int>(qubit2),
                       static_cast<unsigned int>(qubit1),
                       static_cast<unsigned int>(qubit0));
    NotifyObservers({qubit2, qubit1, qubit0});
  }

  void ApplyCSwap(Types::qubit_t ctrl_qubit, Types::qubit_t qubit0,
                  Types::qubit_t qubit1) override {
    if (GetSimulationType() == SimulationType::kMatrixProductState) {
      const size_t q1 = ctrl_qubit; // control
      const size_t q2 = qubit0;
      const size_t q3 = qubit1;
 
      // TODO: find a better decomposition
      // this one I've got with the qiskit transpiler
      mpsSimulator->ApplyGate(cxgate, static_cast<unsigned int>(q2),
                              static_cast<unsigned int>(q3));
      mpsSimulator->ApplyGate(csx, static_cast<unsigned int>(q3),
                              static_cast<unsigned int>(q2));
      mpsSimulator->ApplyGate(cxgate, static_cast<unsigned int>(q2),
                              static_cast<unsigned int>(q1));
 
      pgate.SetPhaseShift(M_PI);
      mpsSimulator->ApplyGate(pgate, static_cast<unsigned int>(q3));
      pgate.SetPhaseShift(-M_PI_2);
      mpsSimulator->ApplyGate(pgate, static_cast<unsigned int>(q2));
 
      mpsSimulator->ApplyGate(csx, static_cast<unsigned int>(q3),
                              static_cast<unsigned int>(q2));
      mpsSimulator->ApplyGate(cxgate, static_cast<unsigned int>(q2),
                              static_cast<unsigned int>(q1));
 
      pgate.SetPhaseShift(M_PI);
      mpsSimulator->ApplyGate(pgate, static_cast<unsigned int>(q3));
 
      mpsSimulator->ApplyGate(csx, static_cast<unsigned int>(q3),
                              static_cast<unsigned int>(q1));
      mpsSimulator->ApplyGate(cxgate, static_cast<unsigned int>(q2),
                              static_cast<unsigned int>(q3));
    } else if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error("QCSimSimulator::ApplyCSwap: The stabilizer "
                               "simulator does not support the CSwap gate.");
    else if (GetSimulationType() == SimulationType::kTensorNetwork) {
      const size_t q1 = ctrl_qubit; // control
      const size_t q2 = qubit0;
      const size_t q3 = qubit1;
 
      // TODO: find a better decomposition
      // this one I've got with the qiskit transpiler
      tensorNetwork->AddGate(cxgate, static_cast<unsigned int>(q3),
                             static_cast<unsigned int>(q2));
      tensorNetwork->AddGate(csx, static_cast<unsigned int>(q2),
                             static_cast<unsigned int>(q3));
      tensorNetwork->AddGate(cxgate, static_cast<unsigned int>(q1),
                             static_cast<unsigned int>(q2));
 
      pgate.SetPhaseShift(M_PI);
      tensorNetwork->AddGate(pgate, static_cast<unsigned int>(q3));
      pgate.SetPhaseShift(-M_PI_2);
      tensorNetwork->AddGate(pgate, static_cast<unsigned int>(q2));
 
      tensorNetwork->AddGate(csx, static_cast<unsigned int>(q2),
                             static_cast<unsigned int>(q3));
      tensorNetwork->AddGate(cxgate, static_cast<unsigned int>(q1),
                             static_cast<unsigned int>(q2));
 
      pgate.SetPhaseShift(M_PI);
      tensorNetwork->AddGate(pgate, static_cast<unsigned int>(q3));
 
      tensorNetwork->AddGate(csx, static_cast<unsigned int>(q1),
                             static_cast<unsigned int>(q3));
      tensorNetwork->AddGate(cxgate, static_cast<unsigned int>(q3),
                             static_cast<unsigned int>(q2));
    } else
      state->ApplyGate(cswapgate, static_cast<unsigned int>(qubit1),
                       static_cast<unsigned int>(qubit0),
                       static_cast<unsigned int>(ctrl_qubit));
    NotifyObservers({qubit1, qubit0, ctrl_qubit});
  }

  void ApplyCU(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit,
               double theta, double phi, double lambda, double gamma) override {
    cugate.SetParams(theta, phi, lambda, gamma);
    if (GetSimulationType() == SimulationType::kMatrixProductState)
      mpsSimulator->ApplyGate(cugate, static_cast<unsigned int>(tgt_qubit),
                              static_cast<unsigned int>(ctrl_qubit));
    else if (GetSimulationType() == SimulationType::kStabilizer)
      throw std::runtime_error("QCSimSimulator::ApplyCU: The stabilizer "
                               "simulator does not support the CU gate.");
    else if (GetSimulationType() == SimulationType::kTensorNetwork)
      tensorNetwork->AddGate(cugate, static_cast<unsigned int>(ctrl_qubit),
                             static_cast<unsigned int>(tgt_qubit));
    else
      state->ApplyGate(cugate, static_cast<unsigned int>(tgt_qubit),
                       static_cast<unsigned int>(ctrl_qubit));
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyNop() override {
    // do nothing
  }

  std::unique_ptr<ISimulator> Clone() override {
    auto cloned = std::make_unique<QCSimSimulator>();
 
    cloned->simulationType = simulationType;
    cloned->nrQubits = nrQubits;
 
    cloned->limitSize = limitSize;
    cloned->limitEntanglement = limitEntanglement;
    cloned->chi = chi;
    cloned->singularValueThreshold = singularValueThreshold;
 
    cloned->enableMultithreading = enableMultithreading;
    cloned->useMPSMeasureNoCollapse = useMPSMeasureNoCollapse;
 
    if (state)
      cloned->state = state->Clone();
 
    if (mpsSimulator) {
      cloned->mpsSimulator = mpsSimulator->Clone();
 
      if (limitEntanglement && singularValueThreshold > 0.)
        cloned->mpsSimulator->setLimitEntanglement(singularValueThreshold);
      if (limitSize && chi > 0)
        cloned->mpsSimulator->setLimitBondDimension(chi);
    }
 
    if (cliffordSimulator)
      cloned->cliffordSimulator = cliffordSimulator->Clone();
 
    if (tensorNetwork)
      cloned->tensorNetwork = tensorNetwork->Clone();
 
    return cloned;
  }
 
private:
  QC::Gates::PhaseShiftGate<> pgate;
  QC::Gates::PauliXGate<> xgate;
  QC::Gates::PauliYGate<> ygate;
  QC::Gates::PauliZGate<> zgate;
  QC::Gates::HadamardGate<> h;
  // QC::Gates::UGate<> ugate;
  QC::Gates::SGate<> sgate;
  QC::Gates::SDGGate<> sdggate;
  QC::Gates::TGate<> tgate;
  QC::Gates::TDGGate<> tdggate;
  QC::Gates::SquareRootNOTGate<> sxgate;
  QC::Gates::SquareRootNOTDagGate<> sxdaggate;
  QC::Gates::HyGate<> k;
  QC::Gates::RxGate<> rxgate;
  QC::Gates::RyGate<> rygate;
  QC::Gates::RzGate<> rzgate;
  QC::Gates::UGate<> ugate;
  QC::Gates::CNOTGate<> cxgate;
  QC::Gates::ControlledYGate<> cygate;
  QC::Gates::ControlledZGate<> czgate;
  QC::Gates::ControlledPhaseShiftGate<> cpgate;
  QC::Gates::ControlledRxGate<> crxgate;
  QC::Gates::ControlledRyGate<> crygate;
  QC::Gates::ControlledRzGate<> crzgate;
  QC::Gates::ControlledHadamardGate<> ch;
  QC::Gates::ControlledSquareRootNOTGate<> csx;
  QC::Gates::ControlledSquareRootNOTDagGate<> csxdag;
  QC::Gates::SwapGate<> swapgate;
  QC::Gates::ToffoliGate<> ccxgate;
  QC::Gates::FredkinGate<> cswapgate;
  QC::Gates::ControlledUGate<> cugate;
};
 
} // namespace Private
} // namespace Simulators
 
#endif
 
#endif // !_QCSIMSIMULATOR_H