class NoisyCPUImplQPU

Overview

QPU implementation by noisy CPU model. More…

#include <NoiseCPUImplQPU.h>

class NoisyCPUImplQPU: public QPUImpl
{
public:
    // fields

    vQParam qubit2stat;
    vQParam init_qubit2stat;

    // construction

    NoisyCPUImplQPU();
    NoisyCPUImplQPU(rapidjson::Document&);
    NoisyCPUImplQPU(NoisyQuantum& quantum_noise);

    // methods

    QGateParam& findgroup(size_t qn);
    void set_quantum_noise(const NoisyQuantum& quantum_noise);

    bool TensorProduct(
        QGateParam& qgroup0,
        QGateParam& qgroup1
        );

    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType);

    QError noisyUnitarySingleQubitGate(
        size_t qn,
        QStat& matrix,
        bool isConjugate,
        NoiseOp& noise
        );

    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType);

    QError noisyUnitaryDoubleQubitGate(
        size_t qn_0,
        size_t qn_1,
        QStat& matrix,
        bool isConjugate,
        NoiseOp& noise
        );

    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);

    virtual QError Hadamard(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError Hadamard(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError X(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError X(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError P0(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError P0(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError P1(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError P1(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError Y(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError Y(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError Z(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError Z(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError T(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError T(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError S(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError S(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError U1_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError RX_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError RX_GATE(
        size_t qn,
        double theta,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError RY_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError RY_GATE(
        size_t qn,
        double theta,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError RZ_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError RZ_GATE(
        size_t qn,
        double theta,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError CNOT(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    virtual QError CNOT(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError CR(
        size_t qn_0,
        size_t qn_1,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError CR(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError CZ(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    virtual QError CZ(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError SqiSWAP(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    virtual QError SqiSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError DiagonalGate(
        Qnum& vQubit,
        QStat& matrix,
        bool isConjugate,
        double error_rate
        );

    virtual QError controlDiagonalGate(
        Qnum& vQubit,
        QStat& matrix,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QStat getQState();
    virtual QError Reset(size_t qn);
    virtual bool qubitMeasure(size_t qn);

    QError pMeasure(
        Qnum& qnum,
        prob_tuple& mResult,
        int select_max = -1
        );

    virtual QError pMeasure(
        Qnum& qnum,
        prob_vec& mResult
        );

    virtual QError initState(
        size_t head_rank,
        size_t rank_size,
        size_t qubit_num
        );

    virtual QError initState(
        size_t qubit_num,
        const QStat& state = {}
        );

    QError unitary_noise_qubit_gate(
        const Qnum& qns,
        const QStat& matrix,
        bool is_conjugate,
        GateType type
        );

    QError unitary_noise_qubit_kraus(
        const Qnum& qns,
        const NoiseOp& ops,
        QStat& standard_matrix
        );

    QError unitary_qubit_gate_standard(
        size_t qn,
        QStat& matrix,
        bool is_conjugate
        );

    QError unitary_qubit_gate_standard(
        size_t qn0,
        size_t qn1,
        QStat& matrix,
        bool is_conjugate
        );

    QError reset_standard(size_t qn);
    bool measure_standard(size_t qn);

    bool readout(
        bool measure,
        size_t qn
        );

    void normlize(
        QStat& matrix,
        double p
        );

    double unitary_kraus(
        const Qnum& qns,
        const QStat& op
        );
};

Inherited Members

public:
    // methods

    virtual bool qubitMeasure(size_t qn) = 0;
    virtual QError pMeasure(Qnum& qnum, prob_vec& mResult) = 0;
    virtual QError initState(size_t head_rank, size_t rank_size, size_t qubit_num) = 0;
    virtual QError initState(size_t qubit_num, const QStat& state = {}) = 0;
    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QStat getQState() = 0;
    virtual void set_random_engine(RandomEngine* rng);
    virtual double get_random_double();
    virtual QError Reset(size_t qn) = 0;

Detailed Documentation

QPU implementation by noisy CPU model.

Methods

virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType)

unitary single qubit gate

Parameters:

size_t	qubit address
QStat&	matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError controlunitarySingleQubitGate(
    size_t qn,
    Qnum& qnum,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

controlunitary single qubit gate

Parameters:

size_t	qubit address
Qnum&	control qubit addresses
QStat	& matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError unitaryDoubleQubitGate(
    size_t qn_0,
    size_t qn_1,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

unitary double qubit gate

Parameters:

size_t	first qubit address
size_t	second qubit address
QStat&	matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError controlunitaryDoubleQubitGate(
    size_t qn_0,
    size_t qn_1,
    Qnum& qnum,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

controlunitary double qubit gate

Parameters:

size_t	first qubit address
size_t	second qubit address
Qnum&	control qubit addresses
QStat&	quantum states
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QStat getQState()

get quantum states

virtual QError Reset(size_t qn)

reset qubit

Parameters:

size_t

qubit address