class QPanda::MPSImplQPU

Overview

QPU implementation by MPS model. More…

#include <MPSImplQPU.h>

class MPSImplQPU: public QPUImpl
{
public:
    // fields

    std::vector<MPS_Tensor> m_qubits_tensor;
    std::vector<rvector_t> m_lambdas;

    // methods

    size_t get_qubit_num();
    virtual bool qubitMeasure(size_t qn);

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

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

    void initState(const MPSImplQPU& other);

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

    void initState_from_matrix(size_t num_qubits, const cmatrix_t& mat);
    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType);
    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);
    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);
    virtual QStat getQState();
    virtual QError Reset(size_t qn);
    size_t get_qubit_index(size_t index) const;
    void change_qubits_location(size_t src, size_t dst);
    void swap_qubits_location(size_t index_A, size_t index_B);
    bool measure_one_collapsing(size_t qubit);
    std::vector<std::vector<size_t>> measure_all_noncollapsing(Qnum measure_qubits, int shots);
    cmatrix_t mul_v_by_s(const cmatrix_t& mat, const rvector_t& lambda);
    MPS_Tensor convert_qstate_to_mps_form(size_t first_index, size_t last_index);
    void centralize_and_sort_qubits(const Qnum& qubits, Qnum& sorted_indices, Qnum& centralized_qubits);
    void move_all_qubits_to_sorted_ordering();
    void move_qubits_to_right_end(const Qnum& qubits, Qnum& target_qubits, Qnum& actual_indices);
    void execute_one_qubit_gate(size_t qn, const cmatrix_t& mat);
    void execute_two_qubit_gate(size_t qn_0, size_t qn_1, const cmatrix_t& mat);
    void execute_multi_qubit_gate(const Qnum& qubits, const cmatrix_t& mat);
    qcomplex_t expectation_value_pauli(const Qnum& qubits);

    qcomplex_t expectation_value_pauli_internal(
        const Qnum& qubits,
        const std::vector<GateType>& matrices,
        size_t first_index,
        size_t last_index,
        size_t num_Is
        );

    bool apply_measure(size_t qubit);
    Qnum apply_measure(Qnum qubits);
    cmatrix_t density_matrix(const Qnum& qubits);

    double expectation_value(
        const Qnum& qubits,
        const cmatrix_t& matrix
        );

    double single_expectation_value(
        const Qnum& qubits,
        const cmatrix_t& matrix
        );

    double double_expectation_value(
        const Qnum& qubits,
        const cmatrix_t& matrix
        );

    void unitaryQubitGate(
        Qnum qubits,
        QStat matrix,
        bool isConjugate
        );

    qcomplex_t pmeasure_bin_index(std::string str);
    qcomplex_t pmeasure_dec_index(std::string str);
    QStat pmeasure_bin_subset(const std::vector<std::string>& bin_strs);
    QStat pmeasure_dec_subset(const std::vector<std::string>& dec_strs);
};

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 MPS model.

Fields

std::vector<MPS_Tensor> m_qubits_tensor

the tensor of qubits.

std::vector<rvector_t> m_lambdas

lambdas between tensors.

Methods

void initState_from_matrix(size_t num_qubits, const cmatrix_t& mat)

init state from matrix

Parameters:

size_t	number of qubits
cmatrix_t	matrix

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

Returns:

QStat quantum states

virtual QError Reset(size_t qn)

reset qubit

Parameters:

size_t

qubit address

size_t get_qubit_index(size_t index) const

gets the position of the qubits in MPS form

Parameters:

size_t

qubits index

Returns:

size_t the position on m_qubits_location

void change_qubits_location(size_t src, size_t dst)

change two qubits

Parameters:

size_t	src qubit location
size_t	dst qubit location

void swap_qubits_location(size_t index_A, size_t index_B)

execute SWAP gate, the state of swapping two qubits

Parameters:

size_t	A qubit index
size_t	B qubit index

bool measure_one_collapsing(size_t qubit)

measure one qubit collapsing

Parameters:

size_t

the qubit position of the measurement

Returns:

bool the measurement results

std::vector<std::vector<size_t>> measure_all_noncollapsing(
    Qnum measure_qubits,
    int shots
    )

measure all qubits collapsing

Parameters:

size_t

the qubit position of the measurement

Returns:

std::vector<std::vector<size_t>> the measurement results

cmatrix_t mul_v_by_s(const cmatrix_t& mat, const rvector_t& lambda)

after the SVD decomposition , The product of S and V

Parameters:

cmatrix_t	V matrix
rvector_t	S vector

Returns:

cmatrix_t product

MPS_Tensor convert_qstate_to_mps_form(size_t first_index, size_t last_index)

convert to MPS form

Parameters:

size_t	starting position
size_t	end position

Returns:

MPS_Tensor MPS form tensor

void centralize_and_sort_qubits(
    const Qnum& qubits,
    Qnum& sorted_indices,
    Qnum& centralized_qubits
    )

sort qubits location, and centralize qubits locations

Parameters:

Qnum	original qubits location
Qnum	sorted indices
Qnum	centralized qubits location

void move_all_qubits_to_sorted_ordering()

move all qubits to sorted ordering

void move_qubits_to_right_end(const Qnum& qubits, Qnum& target_qubits, Qnum& actual_indices)

move qubits to right_end location

Parameters:

Qnum	original qubits location
Qnum	target qubits location
actual	indices

void execute_one_qubit_gate(size_t qn, const cmatrix_t& mat)

execute one qubit gate

Parameters:

size_t	target qubit
cmatrix_t	gate matrix

void execute_two_qubit_gate(size_t qn_0, size_t qn_1, const cmatrix_t& mat)

execute two qubits gate

Parameters:

size_t	control qubit
size_t	target qubit
cmatrix_t	gate matrix

void execute_multi_qubit_gate(const Qnum& qubits, const cmatrix_t& mat)

execute multi qubits gate

Parameters:

size_t	control and target qubits, target qubit in the tail
cmatrix_t	gate matrix