Decomposition_Base.h

Go to the documentation of this file.

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

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

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 DECOMPOSITION_BASE_H
#define DECOMPOSITION_BASE_H


#include "qgd/Operation_block.h"
#include "qgd/CNOT.h"
#include "qgd/U3.h"
#include <map>
#include <cstdlib>
#include <time.h>
#include <ctime>
#include "gsl/gsl_multimin.h"
#include "gsl/gsl_statistics.h"


typedef enum guess_type {ZEROS, RANDOM, CLOSE_TO_ZERO} guess_type;



class Decomposition_Base : public Operation_block {


public:
    bool verbose;

    int optimization_block;

    static std::map<int,int> max_layer_num_def;

    double optimization_tolerance;

protected:

    std::map<int,int> max_layer_num;

    std::map<int,int> iteration_loops;

    Matrix Umtx;

    double* optimized_parameters;

    bool decomposition_finalized;

    double decomposition_error;

    int finalizing_operations_num;

    int finalizing_parameter_num;

    double current_minimum;

    double global_target_minimum;

    bool optimization_problem_solved;

    int max_iterations;

    guess_type initial_guess;

    int num_threads;

public:

Decomposition_Base( Matrix Umtx_in, int qbit_num_in, guess_type initial_guess_in);

virtual ~Decomposition_Base();


void set_optimization_blocks( int optimization_block_in );

void set_max_iteration( int max_iterations_in);


void finalize_decomposition();


void list_operations( int start_index );

Matrix get_finalizing_operations( Matrix& mtx, Operation_block* finalizing_operations, double* finalizing_parameters);


void solve_optimization_problem( double* solution_guess, int solution_guess_num );

virtual void solve_layer_optimization_problem( int num_of_parameters, gsl_vector *solution_guess_gsl);



virtual double optimization_problem( const double* parameters );

bool check_optimization_solution();


std::vector<Matrix, tbb::cache_aligned_allocator<Matrix>> get_operation_products(double* parameters, std::vector<Operation*>::iterator operations_it, int num_of_operations);


Matrix get_Umtx();

int get_Umtx_size();

double* get_optimized_parameters();

void get_optimized_parameters( double* ret );

Matrix get_transformed_matrix( const double* parameters, std::vector<Operation*>::iterator operations_it, int num_of_operations );



Matrix get_transformed_matrix( const double* parameters, std::vector<Operation*>::iterator operations_it, int num_of_operations, Matrix& initial_matrix );


Matrix get_decomposed_matrix();


Matrix apply_operation( Matrix& operation_mtx, Matrix& input_matrix );

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

int set_max_layer_num( int n, int max_layer_num_in );

int set_max_layer_num( std::map<int, int> max_layer_num_in );


int set_iteration_loops( int n, int iteration_loops_in );

int set_iteration_loops( std::map<int, int> iteration_loops_in );


static void Init_max_layer_num();


void prepare_operations_to_export();

std::vector<Operation*> prepare_operations_to_export( std::vector<Operation*> ops, const double* parameters );



std::vector<Operation*> prepare_operations_to_export( Operation_block* block_op, const double* parameters );

int get_operation( unsigned int n, operation_type &type, int &target_qbit, int &control_qbit, double* parameters );


void set_verbose( bool verbose_in );


double get_decomposition_error( );



};

#endif //DECOMPOSITION_BASE