Simulator.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _SIMULATOR_INTERFACE_H_
#define _SIMULATOR_INTERFACE_H_
 
#include "State.h"
 
namespace Simulators
{
struct GateFusionStatistics
{
    uint64_t submittedGates = 0;
    uint64_t backendGates = 0;
    uint64_t fusedBlocks = 0;
};

class ISimulator : public IState, std::enable_shared_from_this<ISimulator>
{
  public:
    using Matrix8cd = Eigen::Matrix<std::complex<double>, 8, 8>;
 
    // Opt in to Maestro fusion; immediate implementations keep the default.
    virtual unsigned GetGateFusionMaxQubits() const
    {
        return 0;
    }
 
    virtual bool IsGateFusionEnabled() const
    {
        return false;
    }
 
    virtual GateFusionStatistics GetGateFusionStatistics() const
    {
        return {};
    }
 
    // Emits gates held back for fusion without waiting for the backend to
    // execute them. Flush() also waits; reads of the state flush on their own.
    virtual void FlushPendingGates()
    {
    }
 
    virtual void ApplyGenericThreeQubitGate(Types::qubit_t, Types::qubit_t, Types::qubit_t, const Matrix8cd &)
    {
        throw std::runtime_error("Generic three-qubit gates are unsupported");
    }
 
    // Native CUDA device, or -1 for CPU/uninitialized simulators.
    virtual int GetGpuDevice() const
    {
        return -1;
    }

    virtual void ApplyGenericOneQubitGate(Types::qubit_t qubit, const Eigen::Matrix2cd &gate) = 0;

    virtual void ApplyGenericTwoQubitGate(Types::qubit_t qubit0, Types::qubit_t qubit1, const Eigen::Matrix4cd &gate) = 0;

    virtual void ApplyP(Types::qubit_t qubit, double lambda) = 0;

    virtual void ApplyX(Types::qubit_t qubit) = 0;

    virtual void ApplyY(Types::qubit_t qubit) = 0;

    virtual void ApplyZ(Types::qubit_t qubit) = 0;

    virtual void ApplyH(Types::qubit_t qubit) = 0;

    virtual void ApplyS(Types::qubit_t qubit) = 0;

    virtual void ApplySDG(Types::qubit_t qubit) = 0;

    virtual void ApplyT(Types::qubit_t qubit) = 0;

    virtual void ApplyTDG(Types::qubit_t qubit) = 0;

    virtual void ApplySx(Types::qubit_t qubit) = 0;

    virtual void ApplySxDAG(Types::qubit_t qubit) = 0;

    virtual void ApplyK(Types::qubit_t qubit) = 0;

    virtual void ApplyRx(Types::qubit_t qubit, double theta) = 0;

    virtual void ApplyRy(Types::qubit_t qubit, double theta) = 0;

    virtual void ApplyRz(Types::qubit_t qubit, double theta) = 0;

    virtual void ApplyU(Types::qubit_t qubit, double theta, double phi, double lambda, double gamma) = 0;

    virtual void ApplyCX(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) = 0;

    virtual void ApplyCY(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) = 0;

    virtual void ApplyCZ(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) = 0;

    virtual void ApplyCP(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit, double lambda) = 0;

    virtual void ApplyCRx(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit, double theta) = 0;

    virtual void ApplyCRy(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit, double theta) = 0;

    virtual void ApplyCRz(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit, double theta) = 0;

    virtual void ApplyCH(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) = 0;

    virtual void ApplyCSx(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) = 0;

    virtual void ApplyCSxDAG(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) = 0;

    virtual void ApplySwap(Types::qubit_t qubit0, Types::qubit_t qubit1) = 0;

    virtual void ApplyCCX(Types::qubit_t qubit0, Types::qubit_t qubit1, Types::qubit_t qubit2) = 0;

    virtual void ApplyCSwap(Types::qubit_t ctrl_qubit, Types::qubit_t qubit0, Types::qubit_t qubit1) = 0;

    virtual void ApplyCU(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit, double theta, double phi, double lambda, double gamma) = 0;

    virtual void ApplyNop() = 0;

    void InitializeToBasisState(size_t num_qubits, Types::qubit_t basisState) override
    {
        if (num_qubits == 0)
            return;
        Clear();
        AllocateQubits(num_qubits);
        Initialize();
        for (size_t q = 0; q < num_qubits; ++q)
            if ((basisState >> q) & 1ULL)
                ApplyX(static_cast<Types::qubit_t>(q));
    }

    void InitializeToBasisState(size_t num_qubits, const std::vector<bool> &basisState) override
    {
        if (num_qubits == 0)
            return;
        Clear();
        AllocateQubits(num_qubits);
        Initialize();
        for (size_t q = 0; q < num_qubits && q < basisState.size(); ++q)
            if (basisState[q])
                ApplyX(static_cast<Types::qubit_t>(q));
    }

    virtual std::unique_ptr<ISimulator> Clone() = 0;
 
    // A logical execution stream is assigned before jobs enter the worker pool.
    // Backends can copy state without consuming their ordinary clone ordinal.
    virtual std::unique_ptr<ISimulator> CloneForExecution(uint64_t seed)
    {
        auto clone = Clone();
        clone->SetSeed(seed);
        return clone;
    }

    std::shared_ptr<ISimulator> getptr()
    {
        return shared_from_this();
    }
};
} // namespace Simulators
 
#endif // !_SIMULATOR_INTERFACE_H_