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 "common.h"
#include "matrix_real.h"
#include "CROT.h"
#include "Gate.h"

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


class Gates_block :  public Gate {


protected:
    std::vector<Gate*> gates;
    int layer_num;
    
    
    
    bool fragmented;
    int fragmentation_type;
    int max_fusion;
    std::vector< std::vector<int>> involved_qbits;
    std::vector<int> block_end;
    std::vector<int> block_type;

public:

Gates_block();

Gates_block(int qbit_num_in);


virtual ~Gates_block();

void release_gates();

void release_gate( int idx);

Matrix get_matrix( Matrix_real& parameters );

Matrix get_matrix( Matrix_real& parameters, int parallel );


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

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




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


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

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_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_cz_nu(int target_qbit, int control_qbit);



void add_cz_nu_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, crot_type subtype_in);



void add_crot_to_front( int target_qbit, int control_qbit, crot_type subtype_in );

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_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_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_syc( int target_qbit, int control_qbit);



void add_syc_to_front( int target_qbit, int control_qbit );




void add_un();

void add_un_to_front();


void add_on();

void add_on_to_front();


void add_composite();

void add_composite_to_front();


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_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();



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 );


std::vector<int> get_involved_qubits();

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


Gate* get_gate(int idx);

void combine(Gates_block* op_block);


virtual void set_qbit_num( int qbit_num_in );


virtual Gates_block* clone();

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 );

};



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,