Program Listing for File general_quantum_operator.hpp

↰ Return to documentation for file (/home/docs/checkouts/readthedocs.org/user_builds/qulacs-rtd/checkouts/latest/src/cppsim/general_quantum_operator.hpp)

#pragma once

#include <cstdio>
#include <iostream>
#include <string>
#include <utility>
#include <vector>

#include "exception.hpp"
#include "type.hpp"
#include "utility.hpp"
class SinglePauliOperator;
class PauliOperator;
class QuantumStateBase;

class DllExport GeneralQuantumOperator {
private:
    std::vector<PauliOperator*> _operator_list;
    UINT _qubit_count;
    bool _is_hermitian;
    Random random;

protected:
    void _apply_pauli_to_state(std::vector<UINT> pauli_id_list,
        std::vector<UINT> target_index_list, QuantumStateBase* state) const;

    void _apply_pauli_to_state_single_thread(std::vector<UINT> pauli_id_list,
        std::vector<UINT> target_index_list, QuantumStateBase* state) const;

public:
    explicit GeneralQuantumOperator(const UINT qubit_count);

    GeneralQuantumOperator(const GeneralQuantumOperator& obj);
    virtual ~GeneralQuantumOperator();

    virtual bool is_hermitian() const { return _is_hermitian; }

    virtual void add_operator(const PauliOperator* mpt);

    virtual void add_operator_move(PauliOperator* mpt);

    virtual void add_operator_copy(const PauliOperator* mpt);

    virtual void add_operator(const CPPCTYPE coef, std::string pauli_string);

    virtual void add_operator(const std::vector<UINT>& target_qubit_index_list,
        const std::vector<UINT>& target_qubit_pauli_list, CPPCTYPE coef);

    virtual UINT get_qubit_count() const { return _qubit_count; }

    virtual ITYPE get_state_dim() const { return (1ULL) << _qubit_count; }

    virtual UINT get_term_count() const { return (UINT)_operator_list.size(); }

    virtual const PauliOperator* get_term(UINT index) const {
        if (index >= _operator_list.size()) {
            throw OperatorIndexOutOfRangeException(
                "Error: GeneralQuantumOperator::get_term(UINT): index out "
                "of range");
        }
        return _operator_list[index];
    }

    virtual std::vector<PauliOperator*> get_terms() const {
        return _operator_list;
    }

    virtual GeneralQuantumOperator* get_dagger() const;

    virtual std::string to_string() const;

    virtual CPPCTYPE get_expectation_value(const QuantumStateBase* state) const;
    virtual CPPCTYPE get_expectation_value_single_thread(
        const QuantumStateBase* state) const;

    virtual CPPCTYPE get_transition_amplitude(const QuantumStateBase* state_bra,
        const QuantumStateBase* state_ket) const;

    void add_random_operator(const UINT operator_count);
    void add_random_operator(const UINT operator_count, UINT seed);

    virtual CPPCTYPE solve_ground_state_eigenvalue_by_arnoldi_method(
        QuantumStateBase* state, const UINT iter_count,
        const CPPCTYPE mu = 0.0) const;

    virtual CPPCTYPE solve_ground_state_eigenvalue_by_power_method(
        QuantumStateBase* state, const UINT iter_count,
        const CPPCTYPE mu = 0.0) const;

    void apply_to_state(QuantumStateBase* work_state,
        const QuantumStateBase& state_to_be_multiplied,
        QuantumStateBase* dst_state) const;

    void apply_to_state(
        QuantumStateBase* state, QuantumStateBase* dst_state) const;

    void apply_to_state_single_thread(
        QuantumStateBase* state, QuantumStateBase* dst_state) const;

    virtual GeneralQuantumOperator* copy() const;

    SparseComplexMatrixRowMajor get_matrix() const;

    virtual boost::property_tree::ptree to_ptree() const;

    GeneralQuantumOperator operator+(
        const GeneralQuantumOperator& target) const;

    GeneralQuantumOperator operator+(const PauliOperator& target) const;

    GeneralQuantumOperator& operator+=(const GeneralQuantumOperator& target);

    GeneralQuantumOperator& operator+=(const PauliOperator& target);

    GeneralQuantumOperator operator-(
        const GeneralQuantumOperator& target) const;

    GeneralQuantumOperator operator-(const PauliOperator& target) const;

    GeneralQuantumOperator& operator-=(const GeneralQuantumOperator& target);

    GeneralQuantumOperator& operator-=(const PauliOperator& target);
    GeneralQuantumOperator operator*(
        const GeneralQuantumOperator& target) const;

    GeneralQuantumOperator operator*(const PauliOperator& target) const;

    GeneralQuantumOperator operator*(CPPCTYPE target) const;

    GeneralQuantumOperator& operator*=(const GeneralQuantumOperator& target);

    GeneralQuantumOperator& operator*=(const PauliOperator& target);

    GeneralQuantumOperator& operator*=(CPPCTYPE target);

protected:
    CPPCTYPE calculate_default_mu() const;
};

namespace quantum_operator {
DllExport GeneralQuantumOperator*
create_general_quantum_operator_from_openfermion_file(std::string file_path);

DllExport GeneralQuantumOperator*
create_general_quantum_operator_from_openfermion_text(std::string text);

DllExport std::pair<GeneralQuantumOperator*, GeneralQuantumOperator*>
create_split_general_quantum_operator(std::string file_path);

DllExport SinglePauliOperator* single_pauli_operator_from_ptree(
    const boost::property_tree::ptree& pt);

DllExport PauliOperator* pauli_operator_from_ptree(
    const boost::property_tree::ptree& pt);

DllExport GeneralQuantumOperator* from_ptree(
    const boost::property_tree::ptree& pt);
}  // namespace quantum_operator

bool check_Pauli_operator(const GeneralQuantumOperator* quantum_operator,
    const PauliOperator* pauli_operator);

SparseComplexMatrixRowMajor _tensor_product(
    const std::vector<SparseComplexMatrixRowMajor>& _obs);