header.h

Go to the documentation of this file.

/*! \file header.h
    \brief Main header file which specifies arguments for the program

 *  Numerical State Tomography
 *  Using GSL -> www.gnu.org/software/gsl
 *  Copyright (C) 2007  Max S Kaznady
 *
 *  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;
 *
 *  AUTHOR
 *     Max S Kaznady,  [EMAIL PROTECTED]
 *     max.kaznady@gmail.com
 *     Summer, 2007
 *
 *  This header file is used to specify all the parameters for the program
 *  instead of using command line arguments. This is not a very good
 *  software practice but saved a lot of time while developing the code.
 *
 ******************************************************************************/


/*! \def NQ
 *  \brief Number of Qubits
 *
 *  This is the main control used to specify the number of qubits.
 *  The amount of memory on a regular PC (2 GB) should handle
 *  1-15 qubits with this setting. Going over 15 qubits may result in memory
 *  overflow, as the density matrix itself would become a problem.
 */

/*! \def DATA
 *  \brief Output location for the matrices produced by the program
 *
 *  Valid directory with sufficient space and write permissions is a must
 *  for this setting. All the simulation data would be outputted there as
 *  ASCII files.
 */

/*! \def NUMTRIALS
 *  \brief Number of times tomography is repeated.
 *
 *  Used to define how many times tomography is performed  on an identical
 *  state and has many uses in the code.
 */

/*! \def MILLION
 *  \brief Defines the numerical value of one million - do not alter.
 */

/*! \def MAXCHAR
 *  \brief Defines the numerical value of a character - do not alter.
 */

/*! \def STATE
 *  \brief Main control which selects what kind of tomography will be perfomred.
 *
 *  The numerical value of this variable selects the type of tomography: \n
 *   1  - GHZ state -- obsolete: it's just state 5 \n
     2  - tau = 0, S_l = 0 \n
     3  - Werner state, epsilon ~= 0 (low tau, high S) \n
     4  - Werner state, epsilon ~= 0.5-0.0123 (middle) \n
     5  - Werner state, epsilon ~= 1 (high tau, low S) \n
     6  - MEMS State - only available for 2 QB \n
     7  - tau = 0; S_l = 1 \n
     8  - W state \n
     9  - completely random state \n
     10 - Werner state, epsilon is being adjusted from 0 to 1 each time \n
     11 - not really a state - for 2 qubits, this is used to fill the
          tangle/entropy plane - only defined for 2 qubits \n
     12 - cycle through all tangle values for a pure state (S_l = 0) and
          and apply a different Quick and Dirty routine \n
     13 - not a state - vary experimental error for many pure states, see how
          this scales with the number of qubits \n
     14 - middle tangle value, pure state \n
     15 - determine value for N which results in 90% Fidelity for pure states \n
     16 - W state density matrix \n
 */

/*! \def EPS
 *  \brief Experimental State Error value.
 *
    Used to adjust the "coherence" of the state
    rho_out = (1-EPS)*rho_state + EPS*rho_random
    do not set equal to zero
 *
 */

/*! \def VERBOSE
 *  \brief Boolean extra verboseness level toggle.
 */

/*! \def WRITE_DENSITY
 *  \brief Boolean toggle for density matrices to be written to disc.
 */

/*! \def MAX_FIDELITY
 *  \brief Max fidelity cutoff point. If fidelity is over this value, simulations stops.
 */

/*! \def KEEP_GOING
 *  \brief Boolean to cutoff MLE based on MAX_FIDELITY.
 *
 *  For MLE Optimisation routine \n
    if 0, then will stop iterating as soon as fidelity will start to decrease \n
    if 1, then will keep iterating until either MLE Objective function stops
    decreasing, or gradient is close to zero, or some other GSL-induced condition.
 *
 *
 */

/*! \def MAXITER
 *  \brief Maximum number of iterations of MLE function, an integer.
 */

/*! \def CUT_ITER
 *  \brief Boolean to stop iteration if MLE function starts to decrease by some very small amount.
 *
 *
 */

/*! \def DO_MLE
 *  \brief Boolean to specify whether MLE should be performed.
 */



/*! \fn void kron(gsl_matrix_complex *a, gsl_matrix_complex *b, gsl_matrix_complex *c);
 *  \brief Performs tensor product on matrices A and B storing the output into pre-allocated matrix C.
 */

/*! \fn gsl_complex trace(gsl_matrix_complex *m);
 *  \brief Computes trace of a complex matrix and returns a complex number.
 */

/*! \fn void matrix_complex_random_init(gsl_matrix_complex *random);
 *  \brief Fills a pre-allocated matrix with random values sampled from U(-1,1).
 */


/*! \fn void outer_product(gsl_vector_complex *a, gsl_matrix_complex *outp);
 *  \brief Performs outer product |a><a| into pre-allocated output matrix.
 */

/*! \fn void base_4_rep_inc(int counter[], int n);
 *  \brief Input array has base-4 rep of n-1, it's incremented to n.
 */

/*! \fn void mu_tensor(gsl_matrix_complex *mu_cell[], gsl_matrix_complex *mu_array[], int mu_counter[], int counter[]);
 *  \brief Shortcut algorithm for tensoring on additional mu matrices to save computation time.
 *
 *  Mu_cell contains pointers to gsl mu matrices that make up the final mu
 *  matrix which corresponds to base-4 representation in mu_counter. The
 *  function corrects mu_cell to represent "counter" base-4 representation
 *  by location the index of the mu matrix in mu_cell starting from which
 *  new matrices need to be tensored on from mu_array.
 *
 *  Basically this is an update function which computes the final mu_matrix
 *  corresponding to the correct base-4 representation in counter without
 *  recomputing everything from scratch.
 *
 */

/*! \fn void sig_tensor(gsl_matrix_complex *sigma_cell[], gsl_matrix_complex *sig_array[], int mu_counter[], int counter[]);
 *  \brief Shortcut algorithm for tensoring on additional sigma matrices to save computation time, see mu_tensor function description.
 *
 */

/*! \fn int write_data(char *name, gsl_matrix_complex *data);
 *  \brief Writes complex matrix data into ASCII file specified by name, standard return codes for write.
 *
 */

/*! \fn int Fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
 *  \brief Wrapper function for fwrite to handle return codes.
 */

/*! \fn void display_matrix(gsl_matrix_complex *data);
 *  \brief Prints complex matrix to screen.
 */

/*! \fn void display_matrix_real(gsl_matrix *data);
 *  \brief Prints real matrix to screen.
 */

/*! \fn void make_T(const gsl_vector *t, gsl_matrix_complex *T);
 *  \brief Seeds in values from vector t into Cholesky lower-diagonal matrix T, like described in the paper.
 */

/*! \fn int write_vector_real(char *name, gsl_vector *data);
 *  \brief Writes real vector into ASCII file specified by name char string.
 */

/*! \fn int read_vector_real(char *fname, gsl_vector *data);
 *  \brief Reads in real valued vector into \e data from ASCII file \e fname.
 */

/*! \fn  void display_vector_real(gsl_vector *data);
 *  \brief Prints real-valued vector to screen.
 */

/*! \fn void sqrtm(gsl_matrix_complex *matrix);
 *  \brief Computes square root of complex \e matrix, stores output in originally pre-allocated matrix.
 */

/*! \fn double fidelity(gsl_matrix_complex *m1, gsl_matrix_complex *m2);
 *  \brief Returns fidelity between two density matrices \e m1 and \e m2.
 */

/*! \fn double entropy_linear(gsl_matrix_complex *matrix);
 *  \brief Returns entropy of the input complex-valued density matrix.
 */

/*! \fn double concurrence(gsl_matrix_complex *matrix);
 *  \brief Returns concurrence of the input density matrix.
 */

/*! \fn void gsl_vector_add_element(gsl_vector *vector, double element);
 *  \brief Adds \e element as last element in \e vector, after re-allocating size of \e vector.
 */

/*! \fn void random_density_matrix(gsl_matrix_complex *density_random);
 *  \brief Creates a random density matrix out of a pre-allocated complex matrix.
 */

/*! \fn void PSI_matrix(gsl_matrix_complex *psi, double theta);
 *  \brief Adjusts the density matrix \e psi to fall on the Werner state line by using the paramter \e theta, which is \e delta in the paper.
 */

/*! \fn void rho_MEMS(gsl_matrix_complex *rho_mems, double gamma);
 *  \brief Density matrix \e rho_mems fall on MEMS line by varying parameter \e gamma, as described in the paper.
 */

/*! \fn  int write_matrix_real(char *name, gsl_matrix *data);
 *  \brief Writes real matrix \e data into ASCII file \e name.
 */

/*! \fn double abs_val(gsl_vector *vec);
 *  \brief Returns absolute value (length) of vector \e vec.
 */

/*! \fn void W_state(gsl_matrix_complex *density);
 *  \brief Creates a W state density matrix.
 */

/*! \var gsl_matrix_complex *mu_array[4];
 *  \brief Stores the Stokes measurement basis matrices.
 */

/*! \var gsl_matrix_complex *sig_array[4];
 *  \brief Stores the 4 Pauli matrices.
 */

/*! \var gsl_matrix_complex *mu_cell[NQ]
 *  \brief Stores tensored \e mu matrices to compute the projection operators for >1 qubits, as described in the paper.
 */

/*! \var  gsl_matrix_complex *sigma_cell[NQ];
 *  \brief Stores tensored \e sigma matrices to compute the Pauli operators for >1 qubits, as described in the paper.
 */

/*! \var gsl_complex zero;
 *  \brief Computational constant.
 */

/*! \var gsl_complex one;
 *  \brief Computational constant.
 */

/*! \var gsl_matrix_complex *ones;
 *  \brief Matrix full of ones.
 */

/*! \var double Werner_handle;
 *  \brief State handle used to adjust the Werner state.
 */

/*! \var double theta_handle;
 *  \brief Used to adjust the tangle value.
 */

/*! \var double N;
 *  \brief Specifies the simulated number of times an experiment is performed, i.e. the number of times projection measurements were taken.
 */

#ifndef header_h
#define header_h

// typedef struct gsl_matrix_complex_float Matrix;
// typedef struct gsl_matrix_complex_float_alloc Matrix_alloc;
// typedef struct gsl_matrix_complex_float_set Matrix_set;
// typedef struct gsl_matrix_complex_float_get Matrix_get;

//don't forget to also set DATA to point to correct NQ location
#define NQ 2
//finish the line below with a forward slash
#define DATA "/home/max/Desktop/2/"

//number of times we will perform tomography - used to obtain averages
#define NUMTRIALS 1
#define MILLION 1000000
//#define N 10000
#define MAXCHAR 512
//state 1  - GHZ state -- obsolete: it's just state 5
//state 2  - tau = 0, S_l = 0
//state 3  - Werner state, epsilon ~= 0 (low tau, high S)
//state 4  - Werner state, epsilon ~= 0.5-0.0123 (middle)
//state 5  - Werner state, epsilon ~= 1 (high tau, low S)
//state 6  - MEMS State - only available for 2 QB
//state 7  - tau = 0; S_l = 1
//state 8  - W state
//state 9  - completely random state
//state 10 - Werner state, epsilon is being adjusted from 0 to 1 each time
//state 11 - not really a state - for 2 qubits, this is used to fill the
//           tangle/entropy plane - only defined for 2 qubits
//state 12 - cycle through all tangle values for a pure state (S_l = 0) and
//           and apply a different Quick and Dirty routine
//state 13 - not a state - vary eperimental error for many pure states, see how
//           this scales with the number of qubits
//state 14 - middle tangle value, pure state
//state 15 - determine value for N which results in 90% Fidelity for pure states
//state 16 - W state density matrix
#define STATE 5

//used to adjust the "coherence" of the state
//rho_out = (1-EPS)*rho_state + EPS*rho_random
//do not set equal to zero
#define EPS 0.05

//make script be more verbose - good for debugging
//set to 1 for verboseness, 0 otherwise
#define VERBOSE 1

//define how much data to write to disc
//if we write too much, this will slow down runs
//for a large number of trials
#define WRITE_DENSITY 1

//define the maximum number of fidelity that one can go to
#define MAX_FIDELITY 0.90

//For MLE Optimization routine
//if 0, then will stop iterating as soon as fidelity will start to decrease
//if 1, then will keep iterating until either MLE Objective function stops
//decreasing, or gradient is close to zero, or some other GSL-induced condition.
#define KEEP_GOING 1

//Maximum number of iterations of MLE function
#define MAXITER 100

//stops the iteration if function difference is less than a certain number
#define CUT_ITER 1

//specify whether or not MLE should be performed
#define DO_MLE 1

//extern int M2 = pow(2, NQ);
//extern int M4 = pow(4, NQ);

void
kron(gsl_matrix_complex *a, gsl_matrix_complex *b, gsl_matrix_complex *c);

gsl_complex
trace(gsl_matrix_complex *m);

void
matrix_complex_random_init(gsl_matrix_complex *random);

void
outer_product(gsl_vector_complex *a, gsl_matrix_complex *outp);

void
base_4_rep_inc(int counter[], int n);

void
mu_tensor(gsl_matrix_complex *mu_cell[], gsl_matrix_complex *mu_array[], int mu_counter[], int counter[]);

void
sig_tensor(gsl_matrix_complex *sigma_cell[], gsl_matrix_complex *sig_array[], int mu_counter[], int counter[]);

int
write_data(char *name, gsl_matrix_complex *data);

int
Fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

void
display_matrix(gsl_matrix_complex *data);

void
display_matrix_real(gsl_matrix *data);

void
make_T(const gsl_vector *t, gsl_matrix_complex *T);

int
write_vector_real(char *name, gsl_vector *data);

int
read_vector_real(char *fname, gsl_vector *data);

void
display_vector_real(gsl_vector *data);

void
sqrtm(gsl_matrix_complex *matrix);

double
fidelity(gsl_matrix_complex *m1, gsl_matrix_complex *m2);

double
entropy_linear(gsl_matrix_complex *matrix);

double
concurrence(gsl_matrix_complex *matrix);

void
gsl_vector_add_element(gsl_vector *vector, double element);

void
random_density_matrix(gsl_matrix_complex *density_random);

void
PSI_matrix(gsl_matrix_complex *psi, double theta);

void
rho_MEMS(gsl_matrix_complex *rho_mems, double gamma);

int
write_matrix_real(char *name, gsl_matrix *data);

double
abs_val(gsl_vector *vec);

void
W_state(gsl_matrix_complex *density);

//public variables
//Stokes measurement basis
gsl_matrix_complex *mu_array[4];
//Pauli matrices
gsl_matrix_complex *sig_array[4];
//stores tensored measurement operators
gsl_matrix_complex *mu_cell[NQ];
//stores tensored measurement Pauli matrices
gsl_matrix_complex *sigma_cell[NQ];
//computation constants
gsl_complex zero, one;
//matrix full of ones
gsl_matrix_complex *ones;
//Werner state handle
double Werner_handle;
//Tangle handle
double theta_handle;
//! Specifies the simulated number of times an experiment is performed
double N;

// int
// write_data_binary(char *name, gsl_matrix_complex *data);

#endif

---