QuantumGates.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _QUANTUM_GATES_H_
#define _QUANTUM_GATES_H_
 
#include "Operations.h"
#include "QuantumGate.h"
 
namespace Circuits {

enum class QuantumGateType : int {
  kPhaseGateType = 0,
  kXGateType,
  kYGateType,
  kZGateType,
  kHadamardGateType,
  kSGateType,
  kSdgGateType,
  kTGateType,
  kTdgGateType,
  kSxGateType,
  kSxDagGateType,
  kKGateType,
  kRxGateType,
  kRyGateType,
  kRzGateType,
  kUGateType,
  kSwapGateType,
  kCXGateType,
  kCYGateType,
  kCZGateType,
  kCPGateType,
  kCRxGateType,
  kCRyGateType,
  kCRzGateType,
  kCHGateType,
  kCSxGateType,
  kCSxDagGateType,
  kCUGateType,
  kCSwapGateType,
  kCCXGateType,
  kNone
};

template <typename Time = Types::time_type>
class IQuantumGate : public IGateOperation<Time> {
 public:
  IQuantumGate(Time delay = 0) : IGateOperation<Time>(delay) {}

  virtual QuantumGateType GetGateType() const = 0;

  virtual std::vector<double> GetParams() const { return {}; }

  virtual Eigen::MatrixXcd GetMatrix() const = 0;
};

template <typename Time = Types::time_type>
class SingleQubitGate : public IQuantumGate<Time> {
 public:
  SingleQubitGate(Types::qubit_t qubit = 0, Time delay = 0)
      : IQuantumGate<Time>(delay), qubit(qubit) {}

  virtual ~SingleQubitGate() {}

  unsigned int GetNumQubits() const override { return 1; }

  void SetQubit(Types::qubit_t q, unsigned long index = 0) override {
    qubit = q;
  }

  Types::qubit_t GetQubit(unsigned int index = 0) const override {
    return qubit;
  }

  Types::qubits_vector AffectedQubits() const override { return {qubit}; }

  std::shared_ptr<IOperation<Time>> Remap(
      const std::unordered_map<Types::qubit_t, Types::qubit_t> &qubitsMap,
      const std::unordered_map<Types::qubit_t, Types::qubit_t> &bitsMap = {})
      const override {
    auto newGate = this->Clone();
 
    const auto qubitit = qubitsMap.find(qubit);
    if (qubitit != qubitsMap.end())
      std::static_pointer_cast<SingleQubitGate<Time>>(newGate)->SetQubit(
          qubitit->second);
    // else throw std::invalid_argument("Qubit not found in qubits map to remap
    // the gate.");
 
    return newGate;
  }
 
 private:
  Types::qubit_t qubit; 
};

template <typename Time = Types::time_type>
class TwoQubitsGate : public IQuantumGate<Time> {
 public:
  TwoQubitsGate(Types::qubit_t qubit1 = 0, Types::qubit_t qubit2 = 0,
                Time delay = 0)
      : IQuantumGate<Time>(delay), qubit1(qubit1), qubit2(qubit2) {}

  virtual ~TwoQubitsGate() {}

  unsigned int GetNumQubits() const override { return 2; }

  void SetQubit(Types::qubit_t q, unsigned long index = 0) override {
    if (index == 0)
      qubit1 = q;
    else if (index == 1)
      qubit2 = q;
  }

  Types::qubit_t GetQubit(unsigned int index = 0) const override {
    if (index == 0)
      return qubit1;
    else if (index == 1)
      return qubit2;
 
    return UINT_MAX;
  }

  Types::qubits_vector AffectedQubits() const override {
    return {qubit1, qubit2};
  }

  std::shared_ptr<IOperation<Time>> Remap(
      const std::unordered_map<Types::qubit_t, Types::qubit_t> &qubitsMap,
      const std::unordered_map<Types::qubit_t, Types::qubit_t> &bitsMap = {})
      const override {
    auto newGate = this->Clone();
 
    const auto qubitit1 = qubitsMap.find(qubit1);
    if (qubitit1 != qubitsMap.end())
      std::static_pointer_cast<TwoQubitsGate<Time>>(newGate)->SetQubit(
          qubitit1->second, 0);
 
    const auto qubitit2 = qubitsMap.find(qubit2);
    if (qubitit2 != qubitsMap.end())
      std::static_pointer_cast<TwoQubitsGate<Time>>(newGate)->SetQubit(
          qubitit2->second, 1);
 
    return newGate;
  }
 
 private:
  Types::qubit_t qubit1; 
  Types::qubit_t
      qubit2; 
};

template <typename Time = Types::time_type>
class ThreeQubitsGate : public IQuantumGate<Time> {
 public:
  ThreeQubitsGate(Types::qubit_t qubit1 = 0, Types::qubit_t qubit2 = 0,
                  Types::qubit_t qubit3 = 0, Time delay = 0)
      : IQuantumGate<Time>(delay),
        qubit1(qubit1),
        qubit2(qubit2),
        qubit3(qubit3) {}

  virtual ~ThreeQubitsGate() {}

  unsigned int GetNumQubits() const override { return 3; }

  void SetQubit(Types::qubit_t q, unsigned long index = 0) override {
    if (index == 0)
      qubit1 = q;
    else if (index == 1)
      qubit2 = q;
    else if (index == 2)
      qubit3 = q;
  }

  Types::qubit_t GetQubit(unsigned int index = 0) const override {
    if (index == 0)
      return qubit1;
    else if (index == 1)
      return qubit2;
    else if (index == 2)
      return qubit3;
 
    return UINT_MAX;
  }

  Types::qubits_vector AffectedQubits() const override {
    return {qubit1, qubit2, qubit3};
  }

  std::shared_ptr<IOperation<Time>> Remap(
      const std::unordered_map<Types::qubit_t, Types::qubit_t> &qubitsMap,
      const std::unordered_map<Types::qubit_t, Types::qubit_t> &bitsMap = {})
      const override {
    auto newGate = this->Clone();
 
    const auto qubitit1 = qubitsMap.find(qubit1);
    if (qubitit1 != qubitsMap.end())
      std::static_pointer_cast<ThreeQubitsGate<Time>>(newGate)->SetQubit(
          qubitit1->second, 0);
 
    const auto qubitit2 = qubitsMap.find(qubit2);
    if (qubitit2 != qubitsMap.end())
      std::static_pointer_cast<ThreeQubitsGate<Time>>(newGate)->SetQubit(
          qubitit2->second, 1);
 
    const auto qubitit3 = qubitsMap.find(qubit3);
    if (qubitit3 != qubitsMap.end())
      std::static_pointer_cast<ThreeQubitsGate<Time>>(newGate)->SetQubit(
          qubitit3->second, 2);
 
    return newGate;
  }
 
 private:
  Types::qubit_t qubit1; 
  Types::qubit_t
      qubit2; 
  Types::qubit_t qubit3; 
};
 
//**********************************************************************************************
// Single Qubit Gates
//**********************************************************************************************

template <typename Time = Types::time_type>
class PhaseGate : public SingleQubitGate<Time> {
 public:
  PhaseGate(Types::qubit_t qubit = 0, double lambda = 0, Time delay = 0)
      : SingleQubitGate<Time>(qubit, delay), lambda(lambda) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyP(SingleQubitGate<Time>::GetQubit(), lambda);
  }

  void SetLambda(double l) { lambda = l; }

  double GetLambda() const { return lambda; }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kPhaseGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<PhaseGate<Time>>(SingleQubitGate<Time>::GetQubit(),
                                             lambda,
                                             IOperation<Time>::GetDelay());
  }

  std::vector<double> GetParams() const override { return {lambda}; }

  bool IsClifford() const override {
    if (std::abs(lambda - M_PI_2) > 1e-10) return false;
 
    return true;
  }

  Eigen::MatrixXcd GetMatrix() const override {
    const QC::Gates::PhaseShiftGate<> pgate(lambda);
    
    return pgate.getRawOperatorMatrix();
  }
 
 private:
  double lambda;
};

template <typename Time = Types::time_type>
class XGate : public SingleQubitGate<Time> {
 public:
  XGate(Types::qubit_t qubit = 0, Time delay = 0)
      : SingleQubitGate<Time>(qubit, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyX(SingleQubitGate<Time>::GetQubit());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kXGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<XGate<Time>>(SingleQubitGate<Time>::GetQubit(),
                                         IOperation<Time>::GetDelay());
  }

  bool IsClifford() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::PauliXGate<> xgate;
 
    return xgate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class YGate : public SingleQubitGate<Time> {
 public:
  YGate(Types::qubit_t qubit = 0, Time delay = 0)
      : SingleQubitGate<Time>(qubit, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyY(SingleQubitGate<Time>::GetQubit());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kYGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<YGate<Time>>(SingleQubitGate<Time>::GetQubit(),
                                         IOperation<Time>::GetDelay());
  }

  bool IsClifford() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::PauliYGate<> ygate;
 
    return ygate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class ZGate : public SingleQubitGate<Time> {
 public:
  ZGate(Types::qubit_t qubit = 0, Time delay = 0)
      : SingleQubitGate<Time>(qubit, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyZ(SingleQubitGate<Time>::GetQubit());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kZGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<ZGate<Time>>(SingleQubitGate<Time>::GetQubit(),
                                         IOperation<Time>::GetDelay());
  }

  bool IsClifford() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::PauliZGate<> zgate;
 
    return zgate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class HadamardGate : public SingleQubitGate<Time> {
 public:
  HadamardGate(Types::qubit_t qubit = 0, Time delay = 0)
      : SingleQubitGate<Time>(qubit, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyH(SingleQubitGate<Time>::GetQubit());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kHadamardGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<HadamardGate<Time>>(
        SingleQubitGate<Time>::GetQubit(), IOperation<Time>::GetDelay());
  }

  bool IsClifford() const override { return true; }

  bool IsBranching() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::HadamardGate<> hgate;
 
    return hgate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class SGate : public SingleQubitGate<Time> {
 public:
  SGate(Types::qubit_t qubit = 0, Time delay = 0)
      : SingleQubitGate<Time>(qubit, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyS(SingleQubitGate<Time>::GetQubit());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kSGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<SGate<Time>>(SingleQubitGate<Time>::GetQubit(),
                                         IOperation<Time>::GetDelay());
  }

  bool IsClifford() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::SGate<> sgate;
 
    return sgate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class SdgGate : public SingleQubitGate<Time> {
 public:
  SdgGate(Types::qubit_t qubit = 0, Time delay = 0)
      : SingleQubitGate<Time>(qubit, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplySDG(SingleQubitGate<Time>::GetQubit());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kSdgGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<SdgGate<Time>>(SingleQubitGate<Time>::GetQubit(),
                                           IOperation<Time>::GetDelay());
  }

  bool IsClifford() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::SDGGate<> sdggate;
 
    return sdggate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class TGate : public SingleQubitGate<Time> {
 public:
  TGate(Types::qubit_t qubit = 0, Time delay = 0)
      : SingleQubitGate<Time>(qubit, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyT(SingleQubitGate<Time>::GetQubit());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kTGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<TGate<Time>>(SingleQubitGate<Time>::GetQubit(),
                                         IOperation<Time>::GetDelay());
  }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::TGate<> tgate;
 
    return tgate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class TdgGate : public SingleQubitGate<Time> {
 public:
  TdgGate(Types::qubit_t qubit = 0, Time delay = 0)
      : SingleQubitGate<Time>(qubit, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyTDG(SingleQubitGate<Time>::GetQubit());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kTdgGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<TdgGate<Time>>(SingleQubitGate<Time>::GetQubit(),
                                           IOperation<Time>::GetDelay());
  }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::TDGGate<> tdggate;
 
    return tdggate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class SxGate : public SingleQubitGate<Time> {
 public:
  SxGate(Types::qubit_t qubit = 0, Time delay = 0)
      : SingleQubitGate<Time>(qubit, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplySx(SingleQubitGate<Time>::GetQubit());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kSxGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<SxGate<Time>>(SingleQubitGate<Time>::GetQubit(),
                                          IOperation<Time>::GetDelay());
  }

  bool IsClifford() const override { return true; }

  bool IsBranching() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::SquareRootNOTGate<> sxgate;
    return sxgate.getRawOperatorMatrix();
  }
  };

template <typename Time = Types::time_type>
class SxDagGate : public SingleQubitGate<Time> {
 public:
  SxDagGate(Types::qubit_t qubit = 0, Time delay = 0)
      : SingleQubitGate<Time>(qubit, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplySxDAG(SingleQubitGate<Time>::GetQubit());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kSxDagGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<SxDagGate<Time>>(SingleQubitGate<Time>::GetQubit(),
                                             IOperation<Time>::GetDelay());
  }

  bool IsClifford() const override { return true; }

  bool IsBranching() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::SquareRootNOTDagGate<> sxdggate;
    return sxdggate.getRawOperatorMatrix();
  }
  };

template <typename Time = Types::time_type>
class KGate : public SingleQubitGate<Time> {
 public:
  KGate(Types::qubit_t qubit = 0, Time delay = 0)
      : SingleQubitGate<Time>(qubit, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyK(SingleQubitGate<Time>::GetQubit());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kKGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<KGate<Time>>(SingleQubitGate<Time>::GetQubit(),
                                         IOperation<Time>::GetDelay());
  }

  bool IsClifford() const override { return true; }

  bool IsBranching() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::HyGate<> hygate;
    return hygate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class RotationGate : public SingleQubitGate<Time> {
 public:
  RotationGate(Types::qubit_t qubit = 0, double theta = 0, Time delay = 0)
      : SingleQubitGate<Time>(qubit, delay), theta(theta) {}

  void SetTheta(double t) { theta = t; }

  double GetTheta() const { return theta; }

  std::vector<double> GetParams() const override { return {theta}; }
 
 private:
  double theta; 
};

template <typename Time = Types::time_type>
class RxGate : public RotationGate<Time> {
 public:
  RxGate(Types::qubit_t qubit = 0, double theta = 0, Time delay = 0)
      : RotationGate<Time>(qubit, theta, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyRx(SingleQubitGate<Time>::GetQubit(),
                 RotationGate<Time>::GetTheta());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kRxGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<RxGate<Time>>(SingleQubitGate<Time>::GetQubit(),
                                          RotationGate<Time>::GetTheta(),
                                          IOperation<Time>::GetDelay());
  }

  bool IsBranching() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    const QC::Gates::RxGate<> rxgate(RotationGate<Time>::GetTheta());
    return rxgate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class RyGate : public RotationGate<Time> {
 public:
  RyGate(Types::qubit_t qubit = 0, double theta = 0, Time delay = 0)
      : RotationGate<Time>(qubit, theta, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyRy(SingleQubitGate<Time>::GetQubit(),
                 RotationGate<Time>::GetTheta());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kRyGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<RyGate<Time>>(SingleQubitGate<Time>::GetQubit(),
                                          RotationGate<Time>::GetTheta(),
                                          IOperation<Time>::GetDelay());
  }

  bool IsBranching() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    const QC::Gates::RyGate<> rygate(RotationGate<Time>::GetTheta());
    return rygate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class RzGate : public RotationGate<Time> {
 public:
  RzGate(Types::qubit_t qubit = 0, double theta = 0, Time delay = 0)
      : RotationGate<Time>(qubit, theta, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyRz(SingleQubitGate<Time>::GetQubit(),
                 RotationGate<Time>::GetTheta());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kRzGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<RzGate<Time>>(SingleQubitGate<Time>::GetQubit(),
                                          RotationGate<Time>::GetTheta(),
                                          IOperation<Time>::GetDelay());
  }

  Eigen::MatrixXcd GetMatrix() const override {
    const QC::Gates::RzGate<> rzgate(RotationGate<Time>::GetTheta());
    return rzgate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class UGate : public SingleQubitGate<Time> {
 public:
  UGate(Types::qubit_t qubit = 0, double theta = 0, double phi = 0,
        double lambda = 0, double gamma = 0, Time delay = 0)
      : SingleQubitGate<Time>(qubit, delay),
        theta(theta),
        phi(phi),
        lambda(lambda),
        gamma(gamma) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyU(SingleQubitGate<Time>::GetQubit(), theta, phi, lambda, gamma);
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kUGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<UGate<Time>>(
        SingleQubitGate<Time>::GetQubit(), GetTheta(), GetPhi(), GetLambda(),
        GetGamma(), IOperation<Time>::GetDelay());
  }

  void SetTheta(double t) { theta = t; }

  double GetTheta() const { return theta; }

  void SetPhi(double p) { phi = p; }

  double GetPhi() const { return phi; }

  void SetLambda(double l) { lambda = l; }

  double GetLambda() const { return lambda; }

  void SetGamma(double g) { gamma = g; }

  double GetGamma() const { return gamma; }

  std::vector<double> GetParams() const override {
    return {theta, phi, lambda, gamma};
  }

  bool IsClifford() const override { return false; }

  bool IsBranching() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    const QC::Gates::UGate<> ugate(theta, phi, lambda, gamma);
    return ugate.getRawOperatorMatrix();
  }
 
 private:
  double theta;  
  double phi;    
  double lambda; 
  double gamma;  
};
 
//**********************************************************************************************
// Two Qubit Gates
//**********************************************************************************************
 
// this one should be replaced - for example with three qnots - to be able to
// distribute it

template <typename Time = Types::time_type>
class SwapGate : public TwoQubitsGate<Time> {
 public:
  SwapGate(Types::qubit_t qubit1 = 0, Types::qubit_t qubit2 = 1, Time delay = 0)
      : TwoQubitsGate<Time>(qubit1, qubit2, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplySwap(TwoQubitsGate<Time>::GetQubit(0),
                   TwoQubitsGate<Time>::GetQubit(1));
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kSwapGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<SwapGate<Time>>(TwoQubitsGate<Time>::GetQubit(0),
                                            TwoQubitsGate<Time>::GetQubit(1),
                                            IOperation<Time>::GetDelay());
  }

  bool IsClifford() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::SwapGate<> swapgate;
    return swapgate.getRawOperatorMatrix();
  }
};
 
// the others are all controlled gates

template <typename Time = Types::time_type>
class CXGate : public TwoQubitsGate<Time> {
 public:
  CXGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, Time delay = 0)
      : TwoQubitsGate<Time>(ctrl, target, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyCX(TwoQubitsGate<Time>::GetQubit(0),
                 TwoQubitsGate<Time>::GetQubit(1));
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kCXGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<CXGate<Time>>(TwoQubitsGate<Time>::GetQubit(0),
                                          TwoQubitsGate<Time>::GetQubit(1),
                                          IOperation<Time>::GetDelay());
  }

  bool IsClifford() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::CNOTGate<> cnotgate;
    return cnotgate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class CYGate : public TwoQubitsGate<Time> {
 public:
  CYGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, Time delay = 0)
      : TwoQubitsGate<Time>(ctrl, target, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyCY(TwoQubitsGate<Time>::GetQubit(0),
                 TwoQubitsGate<Time>::GetQubit(1));
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kCYGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<CYGate<Time>>(TwoQubitsGate<Time>::GetQubit(0),
                                          TwoQubitsGate<Time>::GetQubit(1),
                                          IOperation<Time>::GetDelay());
  }

  bool IsClifford() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::ControlledYGate<> cygate;
    return cygate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class CZGate : public TwoQubitsGate<Time> {
 public:
  CZGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, Time delay = 0)
      : TwoQubitsGate<Time>(ctrl, target, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyCZ(TwoQubitsGate<Time>::GetQubit(0),
                 TwoQubitsGate<Time>::GetQubit(1));
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kCZGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<CZGate<Time>>(TwoQubitsGate<Time>::GetQubit(0),
                                          TwoQubitsGate<Time>::GetQubit(1),
                                          IOperation<Time>::GetDelay());
  }

  bool IsClifford() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::ControlledZGate<> czgate;
    return czgate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class CPGate : public TwoQubitsGate<Time> {
 public:
  CPGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, double lambda = 0,
         Time delay = 0)
      : TwoQubitsGate<Time>(ctrl, target, delay), lambda(lambda) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyCP(TwoQubitsGate<Time>::GetQubit(0),
                 TwoQubitsGate<Time>::GetQubit(1), GetLambda());
  }

  void SetLambda(double l) { lambda = l; }

  double GetLambda() const { return lambda; }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kCPGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<CPGate<Time>>(
        TwoQubitsGate<Time>::GetQubit(0), TwoQubitsGate<Time>::GetQubit(1),
        GetLambda(), IOperation<Time>::GetDelay());
  }

  std::vector<double> GetParams() const override { return {lambda}; }

  Eigen::MatrixXcd GetMatrix() const override {
    const QC::Gates::ControlledPhaseShiftGate<> cpgate(lambda);
    return cpgate.getRawOperatorMatrix();
  }
 
 private:
  double lambda; 
};

template <typename Time = Types::time_type>
class ControlledRotationGate : public TwoQubitsGate<Time> {
 public:
  ControlledRotationGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1,
                         double theta = 0, Time delay = 0)
      : TwoQubitsGate<Time>(ctrl, target, delay), theta(theta) {}

  void SetTheta(double t) { theta = t; }

  double GetTheta() const { return theta; }

  std::vector<double> GetParams() const override { return {theta}; }
 
 private:
  double theta; 
};

template <typename Time = Types::time_type>
class CRxGate : public ControlledRotationGate<Time> {
 public:
  CRxGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, double theta = 0,
          Time delay = 0)
      : ControlledRotationGate<Time>(ctrl, target, theta, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyCRx(TwoQubitsGate<Time>::GetQubit(0),
                  TwoQubitsGate<Time>::GetQubit(1),
                  ControlledRotationGate<Time>::GetTheta());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kCRxGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<CRxGate<Time>>(
        TwoQubitsGate<Time>::GetQubit(0), TwoQubitsGate<Time>::GetQubit(1),
        ControlledRotationGate<Time>::GetTheta(), IOperation<Time>::GetDelay());
  }

  bool IsBranching() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    const QC::Gates::ControlledRxGate<> crxgate(ControlledRotationGate<Time>::GetTheta());
    return crxgate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class CRyGate : public ControlledRotationGate<Time> {
 public:
  CRyGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, double theta = 0,
          Time delay = 0)
      : ControlledRotationGate<Time>(ctrl, target, theta, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyCRy(TwoQubitsGate<Time>::GetQubit(0),
                  TwoQubitsGate<Time>::GetQubit(1),
                  ControlledRotationGate<Time>::GetTheta());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kCRyGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<CRyGate<Time>>(
        TwoQubitsGate<Time>::GetQubit(0), TwoQubitsGate<Time>::GetQubit(1),
        ControlledRotationGate<Time>::GetTheta(), IOperation<Time>::GetDelay());
  }

  bool IsBranching() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    const QC::Gates::ControlledRyGate<> crygate(ControlledRotationGate<Time>::GetTheta());
    return crygate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class CRzGate : public ControlledRotationGate<Time> {
 public:
  CRzGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, double theta = 0,
          Time delay = 0)
      : ControlledRotationGate<Time>(ctrl, target, theta, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyCRz(TwoQubitsGate<Time>::GetQubit(0),
                  TwoQubitsGate<Time>::GetQubit(1),
                  ControlledRotationGate<Time>::GetTheta());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kCRzGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<CRzGate<Time>>(
        TwoQubitsGate<Time>::GetQubit(0), TwoQubitsGate<Time>::GetQubit(1),
        ControlledRotationGate<Time>::GetTheta(), IOperation<Time>::GetDelay());
  }

  Eigen::MatrixXcd GetMatrix() const override {
    const QC::Gates::ControlledRzGate<> crzgate(ControlledRotationGate<Time>::GetTheta());
    return crzgate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class CHGate : public TwoQubitsGate<Time> {
 public:
  CHGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, Time delay = 0)
      : TwoQubitsGate<Time>(ctrl, target, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyCH(TwoQubitsGate<Time>::GetQubit(0),
                 TwoQubitsGate<Time>::GetQubit(1));
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kCHGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<CHGate<Time>>(TwoQubitsGate<Time>::GetQubit(0),
                                          TwoQubitsGate<Time>::GetQubit(1),
                                          IOperation<Time>::GetDelay());
  }

  bool IsBranching() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::ControlledHadamardGate<> chgate;
    return chgate.getRawOperatorMatrix();
  }
  };

template <typename Time = Types::time_type>
class CSxGate : public TwoQubitsGate<Time> {
 public:
  CSxGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, Time delay = 0)
      : TwoQubitsGate<Time>(ctrl, target, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyCSx(TwoQubitsGate<Time>::GetQubit(0),
                  TwoQubitsGate<Time>::GetQubit(1));
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kCSxGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<CSxGate<Time>>(TwoQubitsGate<Time>::GetQubit(0),
                                           TwoQubitsGate<Time>::GetQubit(1),
                                           IOperation<Time>::GetDelay());
  }

  bool IsBranching() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::ControlledSquareRootNOTGate<> csxgate;
    return csxgate.getRawOperatorMatrix();
  }
  };

template <typename Time = Types::time_type>
class CSxDagGate : public TwoQubitsGate<Time> {
 public:
  CSxDagGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, Time delay = 0)
      : TwoQubitsGate<Time>(ctrl, target, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyCSxDAG(TwoQubitsGate<Time>::GetQubit(0),
                     TwoQubitsGate<Time>::GetQubit(1));
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kCSxDagGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<CSxDagGate<Time>>(TwoQubitsGate<Time>::GetQubit(0),
                                              TwoQubitsGate<Time>::GetQubit(1),
                                              IOperation<Time>::GetDelay());
  }

  bool IsBranching() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::ControlledSquareRootNOTDagGate<> csxdaggate;
    return csxdaggate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class CUGate : public TwoQubitsGate<Time> {
 public:
  CUGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, double theta = 0,
         double phi = 0, double lambda = 0, double gamma = 0, Time delay = 0)
      : TwoQubitsGate<Time>(ctrl, target, delay),
        theta(theta),
        phi(phi),
        lambda(lambda),
        gamma(gamma) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyCU(TwoQubitsGate<Time>::GetQubit(0),
                 TwoQubitsGate<Time>::GetQubit(1), GetTheta(), GetPhi(),
                 GetLambda(), GetGamma());
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kCUGateType;
  }

  void SetTheta(double t) { theta = t; }

  double GetTheta() const { return theta; }

  void SetPhi(double p) { phi = p; }

  double GetPhi() const { return phi; }

  void SetLambda(double l) { lambda = l; }

  double GetLambda() const { return lambda; }

  void SetGamma(double g) { gamma = g; }

  double GetGamma() const { return gamma; }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<CUGate<Time>>(
        TwoQubitsGate<Time>::GetQubit(0), TwoQubitsGate<Time>::GetQubit(1),
        GetTheta(), GetPhi(), GetLambda(), GetGamma(),
        IOperation<Time>::GetDelay());
  }

  std::vector<double> GetParams() const override {
    return {theta, phi, lambda, gamma};
  }

  bool IsBranching() const override { return true; }

  Eigen::MatrixXcd GetMatrix() const override {
    const QC::Gates::ControlledUGate<> cugate(theta, phi, lambda, gamma);
    return cugate.getRawOperatorMatrix();
  }
 
 private:
  double theta;  
  double phi;    
  double lambda; 
  double gamma;  
};
 
//**********************************************************************************************
// Three Qubit Gates
// those should be replaced by sets of gates with less qubits, to be able to
// distribute them
//**********************************************************************************************

template <typename Time = Types::time_type>
class CCXGate : public ThreeQubitsGate<Time> {
 public:
  CCXGate(Types::qubit_t ctrl1 = 0, Types::qubit_t ctrl2 = 1,
          Types::qubit_t target = 2, Time delay = 0)
      : ThreeQubitsGate<Time>(ctrl1, ctrl2, target, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyCCX(ThreeQubitsGate<Time>::GetQubit(0),
                  ThreeQubitsGate<Time>::GetQubit(1),
                  ThreeQubitsGate<Time>::GetQubit(2));
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kCCXGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<CCXGate<Time>>(
        ThreeQubitsGate<Time>::GetQubit(0), ThreeQubitsGate<Time>::GetQubit(1),
        ThreeQubitsGate<Time>::GetQubit(2), IOperation<Time>::GetDelay());
  }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::ToffoliGate<> ccxaggate;
    return ccxaggate.getRawOperatorMatrix();
  }
};

template <typename Time = Types::time_type>
class CSwapGate : public ThreeQubitsGate<Time> {
 public:
  CSwapGate(Types::qubit_t ctrl = 0, Types::qubit_t target1 = 1,
            Types::qubit_t target2 = 2, Time delay = 0)
      : ThreeQubitsGate<Time>(ctrl, target1, target2, delay) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    sim->ApplyCSwap(ThreeQubitsGate<Time>::GetQubit(0),
                    ThreeQubitsGate<Time>::GetQubit(1),
                    ThreeQubitsGate<Time>::GetQubit(2));
  }

  QuantumGateType GetGateType() const override {
    return QuantumGateType::kCSwapGateType;
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<CSwapGate<Time>>(
        ThreeQubitsGate<Time>::GetQubit(0), ThreeQubitsGate<Time>::GetQubit(1),
        ThreeQubitsGate<Time>::GetQubit(2), IOperation<Time>::GetDelay());
  }

  Eigen::MatrixXcd GetMatrix() const override {
    static const QC::Gates::FredkinGate<> cswapgate;
    return cswapgate.getRawOperatorMatrix();
  }
};
 
}  // namespace Circuits
 
#endif  // !_QUANTUM_GATES_H_