N_Qubit_Decomposition_adaptive.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.

You should have received a copy of the GNU General Public License
along with this program.  If not, see http://www.gnu.org/licenses/.

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

#include "Optimization_Interface.h"

#ifdef __cplusplus
extern "C" 
{
#endif

int LAPACKE_zggev   (    int       matrix_layout,
          char      jobvl,
          char      jobvr,
          int       n,
          QGD_Complex16 *     a,
          int       lda,
          QGD_Complex16 *     b,
          int       ldb,
          QGD_Complex16 *     alpha,
          QGD_Complex16 *     beta,
          QGD_Complex16 *     vl,
          int       ldvl,
          QGD_Complex16 *     vr,
          int       ldvr 
     );   

#ifdef __cplusplus
}
#endif


class N_Qubit_Decomposition_adaptive : public Optimization_Interface {


public:

protected:


    int level_limit;
    int level_limit_min;
    std::vector<matrix_base<int>> topology;
    bool randomized_adaptive_layers;
    
    

public:

N_Qubit_Decomposition_adaptive();


N_Qubit_Decomposition_adaptive( Matrix Umtx_in, int qbit_num_in, int level_limit_in, int level_limit_min_in, std::map<std::string, Config_Element>& config, int accelerator_num=0 );


N_Qubit_Decomposition_adaptive( Matrix Umtx_in, int qbit_num_in, int level_limit_in, int level_limit_min_in, std::vector<matrix_base<int>> topology_in, std::map<std::string, Config_Element>& config, int accelerator_num=0 );



virtual ~N_Qubit_Decomposition_adaptive();


virtual void start_decomposition();

virtual void get_initial_circuit();

virtual void compress_circuit();

virtual void finalize_circuit();

Gates_block* optimize_imported_gate_structure(Matrix_real& optimized_parameters_mtx_loc);


Gates_block* determine_initial_gate_structure(Matrix_real& optimized_parameters_mtx);



Gates_block* compress_gate_structure( Gates_block* gate_structure, int uncompressed_iter_num );

Gates_block* compress_gate_structure( Gates_block* gate_structure, int layer_idx, Matrix_real& optimized_parameters, double& currnt_minimum_loc, int& iteration_num );

Gates_block* replace_trivial_CRY_gates( Gates_block* gate_structure, Matrix_real& optimized_parameters );

virtual unsigned int get_panelty( Gates_block* gate_structure, Matrix_real& optimized_parameters );


virtual Gates_block* remove_trivial_gates( Gates_block* gate_structure, Matrix_real& optimized_parameters, double& currnt_minimum_loc );

Matrix_real create_reduced_parameters( Gates_block* gate_structure, Matrix_real& optimized_parameters, int layer_idx );


void add_adaptive_layers();

void add_adaptive_layers( Gates_block* gate_structure );

Gates_block* construct_adaptive_gate_layers();


void add_finalyzing_layer();


void add_finalyzing_layer( Gates_block* gate_structure );



void set_adaptive_gate_structure( std::string filename );
 
 
 void set_unitary_from_file( std::string filename );


 void set_unitary( Matrix& Umtx_new ) ;

void add_adaptive_gate_structure( std::string filename );

void apply_imported_gate_structure();


void add_layer_to_imported_gate_structure();

double extract_theta_from_layer( Gates_block* gate_structure, int layer_idx, Matrix_real& optimized_parameters);

};






#endif