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 <template <typename> class Gate, template <typename> class Base, typename Time> class CloneableGate : public Base<Time>
{
  public:
    using Base<Time>::Base;

    std::shared_ptr<IOperation<Time>> Clone() const override
    {
        return std::make_shared<Gate<Time>>(static_cast<const Gate<Time> &>(*this));
    }
};

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 CloneableGate<PhaseGate, SingleQubitGate, Time>
{
  public:
    PhaseGate(Types::qubit_t qubit = 0, double lambda = 0, Time delay = 0)
        : CloneableGate<PhaseGate, Circuits::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::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 CloneableGate<XGate, SingleQubitGate, Time>
{
  public:
    XGate(Types::qubit_t qubit = 0, Time delay = 0) : CloneableGate<XGate, Circuits::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;
    }

    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 CloneableGate<YGate, SingleQubitGate, Time>
{
  public:
    YGate(Types::qubit_t qubit = 0, Time delay = 0) : CloneableGate<YGate, Circuits::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;
    }

    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 CloneableGate<ZGate, SingleQubitGate, Time>
{
  public:
    ZGate(Types::qubit_t qubit = 0, Time delay = 0) : CloneableGate<ZGate, Circuits::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;
    }

    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 CloneableGate<HadamardGate, SingleQubitGate, Time>
{
  public:
    HadamardGate(Types::qubit_t qubit = 0, Time delay = 0) : CloneableGate<HadamardGate, Circuits::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;
    }

    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 CloneableGate<SGate, SingleQubitGate, Time>
{
  public:
    SGate(Types::qubit_t qubit = 0, Time delay = 0) : CloneableGate<SGate, Circuits::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;
    }

    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 CloneableGate<SdgGate, SingleQubitGate, Time>
{
  public:
    SdgGate(Types::qubit_t qubit = 0, Time delay = 0) : CloneableGate<SdgGate, Circuits::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;
    }

    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 CloneableGate<TGate, SingleQubitGate, Time>
{
  public:
    TGate(Types::qubit_t qubit = 0, Time delay = 0) : CloneableGate<TGate, Circuits::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;
    }

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

template <typename Time = Types::time_type> class TdgGate : public CloneableGate<TdgGate, SingleQubitGate, Time>
{
  public:
    TdgGate(Types::qubit_t qubit = 0, Time delay = 0) : CloneableGate<TdgGate, Circuits::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;
    }

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

template <typename Time = Types::time_type> class SxGate : public CloneableGate<SxGate, SingleQubitGate, Time>
{
  public:
    SxGate(Types::qubit_t qubit = 0, Time delay = 0) : CloneableGate<SxGate, Circuits::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;
    }

    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 CloneableGate<SxDagGate, SingleQubitGate, Time>
{
  public:
    SxDagGate(Types::qubit_t qubit = 0, Time delay = 0) : CloneableGate<SxDagGate, Circuits::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;
    }

    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 CloneableGate<KGate, SingleQubitGate, Time>
{
  public:
    KGate(Types::qubit_t qubit = 0, Time delay = 0) : CloneableGate<KGate, Circuits::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;
    }

    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 CloneableGate<RxGate, RotationGate, Time>
{
  public:
    RxGate(Types::qubit_t qubit = 0, double theta = 0, Time delay = 0) : CloneableGate<RxGate, Circuits::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;
    }

    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 CloneableGate<RyGate, RotationGate, Time>
{
  public:
    RyGate(Types::qubit_t qubit = 0, double theta = 0, Time delay = 0) : CloneableGate<RyGate, Circuits::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;
    }

    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 CloneableGate<RzGate, RotationGate, Time>
{
  public:
    RzGate(Types::qubit_t qubit = 0, double theta = 0, Time delay = 0) : CloneableGate<RzGate, Circuits::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;
    }

    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 CloneableGate<UGate, SingleQubitGate, Time>
{
  public:
    UGate(Types::qubit_t qubit = 0, double theta = 0, double phi = 0, double lambda = 0, double gamma = 0, Time delay = 0)
        : CloneableGate<UGate, Circuits::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;
    }

    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 CloneableGate<SwapGate, TwoQubitsGate, Time>
{
  public:
    SwapGate(Types::qubit_t qubit1 = 0, Types::qubit_t qubit2 = 1, Time delay = 0)
        : CloneableGate<SwapGate, Circuits::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;
    }

    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 CloneableGate<CXGate, TwoQubitsGate, Time>
{
  public:
    CXGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, Time delay = 0) : CloneableGate<CXGate, Circuits::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;
    }

    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 CloneableGate<CYGate, TwoQubitsGate, Time>
{
  public:
    CYGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, Time delay = 0) : CloneableGate<CYGate, Circuits::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;
    }

    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 CloneableGate<CZGate, TwoQubitsGate, Time>
{
  public:
    CZGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, Time delay = 0) : CloneableGate<CZGate, Circuits::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;
    }

    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 CloneableGate<CPGate, TwoQubitsGate, Time>
{
  public:
    CPGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, double lambda = 0, Time delay = 0)
        : CloneableGate<CPGate, Circuits::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::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 CloneableGate<CRxGate, ControlledRotationGate, Time>
{
  public:
    CRxGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, double theta = 0, Time delay = 0)
        : CloneableGate<CRxGate, Circuits::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;
    }

    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 CloneableGate<CRyGate, ControlledRotationGate, Time>
{
  public:
    CRyGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, double theta = 0, Time delay = 0)
        : CloneableGate<CRyGate, Circuits::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;
    }

    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 CloneableGate<CRzGate, ControlledRotationGate, Time>
{
  public:
    CRzGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, double theta = 0, Time delay = 0)
        : CloneableGate<CRzGate, Circuits::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;
    }

    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 CloneableGate<CHGate, TwoQubitsGate, Time>
{
  public:
    CHGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, Time delay = 0) : CloneableGate<CHGate, Circuits::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;
    }

    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 CloneableGate<CSxGate, TwoQubitsGate, Time>
{
  public:
    CSxGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, Time delay = 0) : CloneableGate<CSxGate, Circuits::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;
    }

    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 CloneableGate<CSxDagGate, TwoQubitsGate, Time>
{
  public:
    CSxDagGate(Types::qubit_t ctrl = 0, Types::qubit_t target = 1, Time delay = 0)
        : CloneableGate<CSxDagGate, Circuits::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;
    }

    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 CloneableGate<CUGate, 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)
        : CloneableGate<CUGate, Circuits::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::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 CloneableGate<CCXGate, ThreeQubitsGate, Time>
{
  public:
    CCXGate(Types::qubit_t ctrl1 = 0, Types::qubit_t ctrl2 = 1, Types::qubit_t target = 2, Time delay = 0)
        : CloneableGate<CCXGate, Circuits::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;
    }

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

template <typename Time = Types::time_type> class CSwapGate : public CloneableGate<CSwapGate, ThreeQubitsGate, Time>
{
  public:
    CSwapGate(Types::qubit_t ctrl = 0, Types::qubit_t target1 = 1, Types::qubit_t target2 = 2, Time delay = 0)
        : CloneableGate<CSwapGate, Circuits::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;
    }

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