Program Listing for File circuit.hpp

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

#pragma once

#include <string>
#include <vector>

#include "exception.hpp"
#include "type.hpp"
#include "utility.hpp"

class QuantumStateBase;
class QuantumGateBase;
class PauliOperator;
class HermitianQuantumOperator;
using Observable = HermitianQuantumOperator;

class DllExport QuantumCircuit {
protected:
    std::vector<QuantumGateBase*> _gate_list;
    UINT _qubit_count;

    // prohibit shallow copy
    QuantumCircuit(const QuantumCircuit& obj);
    QuantumCircuit& operator=(const QuantumCircuit&) = delete;

public:
    const UINT& qubit_count;
    const std::vector<QuantumGateBase*>&
        gate_list;
    explicit QuantumCircuit(UINT qubit_count);

    QuantumCircuit* copy() const;

    virtual ~QuantumCircuit();


    virtual void add_gate(QuantumGateBase* gate);

    virtual void add_gate(QuantumGateBase* gate, UINT index);

    virtual void add_gate_copy(const QuantumGateBase* gate);

    virtual void add_gate_copy(const QuantumGateBase* gate, UINT index);

    virtual void add_noise_gate(
        QuantumGateBase* gate, std::string noise_type, double noise_prob);
    void add_noise_gate_copy(
        QuantumGateBase* gate, std::string noise_type, double noise_prob);
    virtual void remove_gate(UINT index);
    virtual void move_gate(UINT from_index, UINT to_index);
    void merge_circuit(const QuantumCircuit* circuit) {
        for (auto gate : circuit->gate_list) {
            this->add_gate_copy(gate);
        }
        return;
    }

    void update_quantum_state(QuantumStateBase* state);

    void update_quantum_state(
        QuantumStateBase* state, UINT start_index, UINT end_index);

    void update_quantum_state(QuantumStateBase* state, UINT seed);

    void update_quantum_state(
        QuantumStateBase* state, UINT start_index, UINT end_index, UINT seed);


    bool is_Clifford() const;

    bool is_Gaussian() const;

    UINT calculate_depth() const;

    virtual std::string to_string() const;

    friend DllExport std::ostream& operator<<(
        std::ostream& os, const QuantumCircuit&);

    friend DllExport std::ostream& operator<<(
        std::ostream& os, const QuantumCircuit* gate);

    virtual void add_X_gate(UINT target_index);

    virtual void add_Y_gate(UINT target_index);

    virtual void add_Z_gate(UINT target_index);

    virtual void add_H_gate(UINT target_index);

    virtual void add_S_gate(UINT target_index);

    virtual void add_Sdag_gate(UINT target_index);

    virtual void add_T_gate(UINT target_index);

    virtual void add_Tdag_gate(UINT target_index);

    virtual void add_sqrtX_gate(UINT target_index);

    virtual void add_sqrtXdag_gate(UINT target_index);

    virtual void add_sqrtY_gate(UINT target_index);

    virtual void add_sqrtYdag_gate(UINT target_index);

    virtual void add_P0_gate(UINT target_index);

    virtual void add_P1_gate(UINT target_index);

    virtual void add_CNOT_gate(UINT control_index, UINT target_index);

    virtual void add_CZ_gate(UINT control_index, UINT target_index);

    virtual void add_SWAP_gate(UINT target_index1, UINT target_index2);

    virtual void add_FusedSWAP_gate(
        UINT target_index1, UINT target_index2, UINT block_size);

    virtual void add_RX_gate(UINT target_index, double angle);

    virtual void add_RY_gate(UINT target_index, double angle);

    virtual void add_RZ_gate(UINT target_index, double angle);

    virtual void add_RotInvX_gate(UINT target_index, double angle);

    virtual void add_RotInvY_gate(UINT target_index, double angle);

    virtual void add_RotInvZ_gate(UINT target_index, double angle);

    virtual void add_RotX_gate(UINT target_index, double angle);

    virtual void add_RotY_gate(UINT target_index, double angle);

    virtual void add_RotZ_gate(UINT target_index, double angle);

    virtual void add_U1_gate(UINT target_index, double phi);

    virtual void add_U2_gate(UINT target_index, double phi, double psi);

    virtual void add_U3_gate(
        UINT target_index, double phi, double psi, double lambda);

    virtual void add_multi_Pauli_gate(
        std::vector<UINT> target_index_list, std::vector<UINT> pauli_id_list);

    virtual void add_multi_Pauli_gate(const PauliOperator& pauli_operator);

    virtual void add_multi_Pauli_rotation_gate(
        std::vector<UINT> target_index_list, std::vector<UINT> pauli_id_list,
        double angle);

    virtual void add_multi_Pauli_rotation_gate(
        const PauliOperator& pauli_operator);

    virtual void add_diagonal_observable_rotation_gate(
        const Observable& observable, double angle);

    virtual void add_observable_rotation_gate(
        const Observable& observable, double angle, UINT num_repeats = 0);
    virtual void add_dense_matrix_gate(
        UINT target_index, const ComplexMatrix& matrix);

    virtual void add_dense_matrix_gate(
        std::vector<UINT> target_index_list, const ComplexMatrix& matrix);

    virtual void add_random_unitary_gate(std::vector<UINT> target_index_list);
    virtual void add_random_unitary_gate(
        std::vector<UINT> target_index_list, UINT seed);

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

    virtual QuantumCircuit* get_inverse(void);
};

namespace circuit {
QuantumCircuit* from_ptree(const boost::property_tree::ptree& pt);
}  // namespace circuit