Gates_block.h

Go to the documentation of this file.

/*
Created on Fri Jun 26 14:13:26 2020
Copyright 2020 Peter Rakyta, Ph.D.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

@author: Peter Rakyta, Ph.D.
*/
#ifndef GATES_BLOCK_H
#define GATES_BLOCK_H

#include <vector>
#include <map>
#include <tbb/spin_mutex.h>
#include "common.h"
#include "matrix_real.h"
#include "matrix_real_any.h"
#include "matrix_any.h"
#include "CROT.h"
#include "Gate.h"
#include "utils.hpp"

#ifdef __DFE__
#include "common_DFE.h"
#endif

class Gates_block :  public Gate {


protected:
    std::vector<Gate*> gates;
    int layer_num;
    
    
    int min_fusion;
    SmartAtomicPtr<Gates_block> fusion_block;
    mutable bool involved_qubits_cache_valid;
    mutable bool involved_target_qubits_cache_valid;
    mutable std::vector<int> involved_qubits_cache;
    mutable std::vector<int> involved_target_qubits_cache;
    mutable std::shared_ptr<tbb::spin_mutex> involved_qubits_cache_mutex;

    void invalidate_structure_cache();

public:

Gates_block();

Gates_block(int qbit_num_in);


~Gates_block() override;

void release_gates();

void release_gate( int idx);

Matrix get_matrix( Matrix_real& parameters ) override;

Matrix get_matrix( Matrix_real& parameters, int parallel ) override;

Matrix_float get_matrix( Matrix_real_float& parameters );

Matrix_float get_matrix( Matrix_real_float& parameters, int parallel ) override;


void apply_to_list( Matrix_real& parameters, std::vector<Matrix>& inputs, int parallel ) override;

void apply_to_list( Matrix_real_float& parameters, std::vector<Matrix_float>& inputs, int parallel ) override;

virtual void apply_to( Matrix_real& parameters_mtx, Matrix& input, int parallel=0 ) override;

virtual void apply_to_inner( Matrix_real& parameters_mtx, const Matrix_real& precomputed_sincos, Matrix& input, int parallel=0 ) override;

virtual void apply_to( Matrix_float& input, int parallel=0 ) override;

virtual void apply_to( Matrix_real_float& parameters_mtx, Matrix_float& input, int parallel=0 ) override;

virtual void apply_to_inner( Matrix_real_float& parameters_mtx, const Matrix_real_float& precomputed_sincos, Matrix_float& input, int parallel=0 ) override;

virtual void apply_to( Matrix_real_any& parameters_mtx, Matrix_any& input, int parallel=0 );




virtual void apply_from_right( Matrix_real& parameters_mtx, Matrix& input ) override;

virtual void apply_from_right_inner( Matrix_real& parameters_mtx, const Matrix_real& precomputed_sincos, Matrix& input ) override;

virtual void apply_from_right( Matrix_real_float& parameters_mtx, Matrix_float& input ) override;

virtual void apply_from_right_inner( Matrix_real_float& parameters_mtx, const Matrix_real_float& precomputed_sincos, Matrix_float& input ) override;


virtual std::vector<Matrix> apply_derivate_to( Matrix_real& parameters_mtx, Matrix& input, int parallel ) override;

virtual void apply_derivate_to( Matrix_real& parameters_mtx, Matrix& input, int parallel, std::vector<Matrix>& output ) override;

void apply_derivate_to( Matrix_real& parameters_mtx, Matrix& input, int parallel, std::vector<Matrix>& output, size_t output_offset, bool resize_output );

virtual std::vector<Matrix_float> apply_derivate_to( Matrix_real_float& parameters_mtx, Matrix_float& input, int parallel ) override;

virtual void apply_derivate_to( Matrix_real_float& parameters_mtx, Matrix_float& input, int parallel, std::vector<Matrix_float>& output ) override;

void apply_derivate_to( Matrix_real_float& parameters_mtx, Matrix_float& input, int parallel, std::vector<Matrix_float>& output, size_t output_offset, bool resize_output );

virtual std::vector<Matrix> apply_to_combined( Matrix_real& parameters_mtx, Matrix& input, int parallel ) override;

virtual void apply_to_combined( Matrix_real& parameters_mtx, Matrix& input, int parallel, std::vector<Matrix>& output ) override;

virtual std::vector<Matrix> apply_to_combined_inner( Matrix_real& parameters_mtx, const Matrix_real& precomputed_sincos, Matrix& input, int parallel ) override;

virtual void apply_to_combined_inner( Matrix_real& parameters_mtx, const Matrix_real& precomputed_sincos, Matrix& input, int parallel, std::vector<Matrix>& output ) override;

virtual std::vector<Matrix_float> apply_to_combined( Matrix_real_float& parameters_mtx, Matrix_float& input, int parallel ) override;

virtual void apply_to_combined( Matrix_real_float& parameters_mtx, Matrix_float& input, int parallel, std::vector<Matrix_float>& output ) override;

virtual std::vector<Matrix_float> apply_to_combined_inner( Matrix_real_float& parameters_mtx, const Matrix_real_float& precomputed_sincos, Matrix_float& input, int parallel ) override;

virtual void apply_to_combined_inner( Matrix_real_float& parameters_mtx, const Matrix_real_float& precomputed_sincos, Matrix_float& input, int parallel, std::vector<Matrix_float>& output ) override;

void add_u1(int target_qbit);

void add_u1_to_front(int target_qbit);

void add_u2(int target_qbit);

void add_u2_to_front(int target_qbit);

void add_u3(int target_qbit);

void add_u3_to_front(int target_qbit);

void add_rx(int target_qbit);

void add_rx_to_front(int target_qbit);

void add_rxx(std::vector<int> target_qbits);

void add_rxx_to_front(std::vector<int> target_qbits);

void add_ryy(std::vector<int> target_qbits);

void add_ryy_to_front(std::vector<int> target_qbits);

void add_rzz(std::vector<int> target_qbits);

void add_rzz_to_front(std::vector<int> target_qbits);
void add_r(int target_qbit);

void add_r_to_front(int target_qbit);

void add_ry(int target_qbit);

void add_ry_to_front(int target_qbit);




void add_cry(int target_qbit, int control_qbit);

void add_cry_to_front(int target_qbit, int control_qbit);

void add_crx(int target_qbit, int control_qbit);

void add_crx_to_front(int target_qbit, int control_qbit);

void add_crz(int target_qbit, int control_qbit);

void add_crz_to_front(int target_qbit, int control_qbit);

void add_cp(int target_qbit, int control_qbit);

void add_cp_to_front(int target_qbit, int control_qbit);


void add_cr(int target_qbit, int control_qbit);

void add_cr_to_front(int target_qbit, int control_qbit);

void add_rz(int target_qbit);

void add_rz_to_front(int target_qbit);




void add_cnot( int target_qbit, int control_qbit);



void add_cnot_to_front( int target_qbit, int control_qbit );


void add_crot( int target_qbit, int control_qbit);



void add_crot_to_front( int target_qbit, int control_qbit );

void add_cz( int target_qbit, int control_qbit);



void add_cz_to_front( int target_qbit, int control_qbit );


void add_ch( int target_qbit, int control_qbit);



void add_ch_to_front( int target_qbit, int control_qbit );

void add_cu( int target_qbit, int control_qbit);



void add_cu_to_front( int target_qbit, int control_qbit );

void add_ccx( int target_qbit, const std::vector<int>& control_qbits);

void add_ccx_to_front( int target_qbit, const std::vector<int>& control_qbits );

void add_swap( const std::vector<int>& target_qbits);

void add_swap_to_front( const std::vector<int>& target_qbits );

void add_cswap( const std::vector<int>& target_qbits, const std::vector<int>& control_qbits);

void add_cswap_to_front( const std::vector<int>& target_qbits, const std::vector<int>& control_qbits );

void add_h(int target_qbit);

void add_h_to_front(int target_qbit);


void add_x(int target_qbit);

void add_x_to_front(int target_qbit);


void add_y(int target_qbit);

void add_y_to_front(int target_qbit);


void add_z(int target_qbit);

void add_z_to_front(int target_qbit);


void add_s(int target_qbit);

void add_s_to_front(int target_qbit);


void add_sdg(int target_qbit);

void add_sdg_to_front(int target_qbit);


void add_t(int target_qbit);

void add_t_to_front(int target_qbit);


void add_tdg(int target_qbit);

void add_tdg_to_front(int target_qbit);


void add_sx(int target_qbit);

void add_sx_to_front(int target_qbit);

void add_sxdg(int target_qbit);

void add_sxdg_to_front(int target_qbit);

void add_syc( int target_qbit, int control_qbit);



void add_syc_to_front( int target_qbit, int control_qbit );




void add_adaptive(int target_qbit, int control_qbit);

void add_adaptive_to_front(int target_qbit, int control_qbit);


void add_gates( std::vector<Gate*> gates_in );


void add_gates_to_front( std::vector<Gate*> gates_in );


void add_gate( Gate* gate );

void add_general_operation(
    const Matrix& operation_mtx,
    const std::vector<int>& target_qbits = std::vector<int>(),
    const std::vector<int>& control_qbits = std::vector<int>()
);

void add_gate_to_front( Gate* gate );


void insert_gate( Gate* gate, int idx );


void add_gate_nums( std::map<std::string, int>& gate_nums );


std::map<std::string, int> get_gate_nums();


int get_parameter_num() override;



int get_gate_num();


void list_gates( const Matrix_real &parameters, int start_index );


Gates_block* create_remapped_circuit( const std::map<int, int>& qbit_map );


Gates_block* create_remapped_circuit( const std::map<int, int>& qbit_map, const int qbit_num_ );


virtual void reorder_qubits( std::vector<int> qbit_list ) override;


std::vector<int> get_involved_qubits(bool only_target=false) override;

std::vector<Gate*> get_gates();


Gate* get_gate(int idx);

void combine(Gates_block* op_block);



void set_min_fusion( int min_fusion );

virtual void set_qbit_num( int qbit_num_in ) override;


virtual Gates_block* clone() override;

int extract_gates( Gates_block* op_block );



bool contains_adaptive_gate();

bool contains_adaptive_gate(int idx);



Matrix get_reduced_density_matrix( Matrix_real& parameters_mtx, Matrix& input_state, matrix_base<int>& qbit_list_subset );



double get_second_Renyi_entropy( Matrix_real& parameters_mtx, Matrix& input_state, matrix_base<int>& qbit_list );



void determine_parents( Gate* gate );


void determine_children( Gate* gate );




void fragment_circuit();
void get_parameter_max(Matrix_real &range_max);


#ifdef __DFE__

DFEgate_kernel_type* convert_to_DFE_gates_with_derivates( Matrix_real& parameters_mtx, int& gatesNum, int& gateSetNum, int& redundantGateSets, bool only_derivates=false );

void adjust_parameters_for_derivation( DFEgate_kernel_type* DFEgates, const int  gatesNum, int& gate_idx, int& gate_set_index );

DFEgate_kernel_type* convert_to_batched_DFE_gates( std::vector<Matrix_real>& parameters_mtx_vec, int& gatesNum, int& gateSetNum, int& redundantGateSets );



DFEgate_kernel_type* convert_to_DFE_gates( Matrix_real& parameters_mtx, int& gatesNum );

void convert_to_DFE_gates( const Matrix_real& parameters_mtx, DFEgate_kernel_type* DFEgates, int& start_index );

#endif


#ifdef __GROQ__

void extract_gate_kernels_target_and_control_qubits(std::vector<Matrix> &u3_qbit, std::vector<int> &target_qbit, std::vector<int> &control_qbit, Matrix_real& parameters_mtx);

#endif


void reset_parameter_start_indices();



void reset_dependency_graph();


Gates_block* get_flat_circuit();


virtual Matrix_real extract_parameters( Matrix_real& parameters ) override;

};



void export_gate_list_to_binary(Matrix_real& parameters, Gates_block* gates_block, const std::string& filename, int verbosity=3);

void export_gate_list_to_binary(Matrix_real& parameters, Gates_block* gates_block, FILE* pFile, int verbosity=3);


Gates_block* import_gate_list_from_binary(Matrix_real& parameters, const std::string& filename, int verbosity=3);


Gates_block* import_gate_list_from_binary(Matrix_real& parameters, FILE* pFile, int verbosity=3);

bool is_qbit_present(std::vector<int> involved_qbits, int new_qbit, int num_of_qbits);



Matrix_real reverse_parameters( const Matrix_real& v_in, std::vector<Gate*>::iterator gates_it, int num_of_gates );


Matrix_real inverse_reverse_parameters( const Matrix_real& v_in, std::vector<Gate*>::iterator gates_it, int num_of_gates );

#endif //GATES_BLOCK,