N_Qubit_Decomposition_Cost_Function.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 N_Qubit_Decomposition_Cost_Function_H
#define N_Qubit_Decomposition_Cost_Function_H

#include "common.h"
#include "matrix_real.h"
#include "matrix_real_float.h"
#include "matrix_float.h"
#include <tbb/combinable.h>
#include "logging.h"


double get_cost_function(const Matrix& matrix, int trace_offset=0);
double get_cost_function(const Matrix_float& matrix, int trace_offset=0);


Matrix_real get_cost_function_with_correction(const Matrix& matrix, int qbit_num, int trace_offset=0);
Matrix_real_float get_cost_function_with_correction(const Matrix_float& matrix, int qbit_num, int trace_offset=0);


Matrix_real get_cost_function_with_correction2(const Matrix& matrix, int qbit_num, int trace_offset=0);
Matrix_real_float get_cost_function_with_correction2(const Matrix_float& matrix, int qbit_num, int trace_offset=0);

double get_cost_function_sum_of_squares(Matrix& matrix);
Matrix get_deriv_sum_of_squares(Matrix& matrix);

QGD_Complex16 get_trace(Matrix& matrix);
QGD_Complex16 get_trace(Matrix_float& matrix);


double get_hilbert_schmidt_test(Matrix& matrix);
double get_hilbert_schmidt_test(Matrix_float& matrix);

double get_infidelity(Matrix& matrix);
double get_infidelity(Matrix_float& matrix);

Matrix get_trace_with_correction(Matrix& matrix, int qbit_num);


Matrix get_trace_with_correction2(Matrix& matrix, int qbit_num);

class functor_cost_fnc : public logging {

protected:

    Matrix matrix;
    QGD_Complex16* data;
    tbb::combinable<double>* partial_cost_functions;

public:

functor_cost_fnc( Matrix matrix_in,  tbb::combinable<double>* partial_cost_functions_in );

void operator()( tbb::blocked_range<int> r ) const;

};


std::pair<int, double> operator_schmidt_rank(const Matrix& U, int n,
                          const std::vector<int>& A_qubits,
                          double Fnorm, double tol = 1e-10);
std::pair<int, double> operator_schmidt_rank(const Matrix_float& U, int n,
                          const std::vector<int>& A_qubits,
                          double Fnorm, double tol = 1e-10);
std::vector<std::vector<int>> unique_cuts(int n);
double get_osr_entanglement_test(Matrix& matrix, std::vector<std::vector<int>> &use_cuts, int rank=-1, bool use_softmax=false);
double get_osr_entanglement_test(Matrix_float& matrix, std::vector<std::vector<int>> &use_cuts, int rank=-1, bool use_softmax=false);
Matrix get_deriv_osr_entanglement(Matrix &matrix, std::vector<std::vector<int>> &use_cuts, int rank=-1, bool use_softmax=false);
Matrix_float get_deriv_osr_entanglement(Matrix_float &matrix, std::vector<std::vector<int>> &use_cuts, int rank=-1, bool use_softmax=false);
double real_trace_conj_dot(Matrix& A, Matrix& B);
double real_trace_conj_dot(Matrix_float& A, Matrix_float& B);

#endif