Source code for qubiter.SEO_MatrixProduct

from qubiter.SEO_simulator import *
from qubiter.StateVec import *
# from Controls import *

[docs]class SEO_simulator_mp(SEO_simulator): """ This class is a mp (matrix product) child of class SEO_simulator. An object of this class is created inside class SEO_MatrixProduct. The purpose of this class is to override the use_MEAS() function of its parent class SEO_simulator. The new use_MEAS() returns an error message if an English file with a MEAS line is being read. """
[docs] def use_MEAS(self, tar_bit_pos, kind): """ Returns an error message if an English file with a MEAS line is being read. Parameters ---------- tar_bit_pos : int kind : int|bool Returns ------- None """ assert False, "this lightweight class cannot handle MEAS"\ "or its concomitant branches"
[docs] def use_PRINT(self, style, line_num): """ If circuit has any PRINT statements, skip them. Parameters ---------- style : str line_num : int Returns ------- None """ pass
[docs]class SEO_MatrixProduct: """ The class SEO_simulator has an initial state vector as an input, and it calculates the evolution of that state vector after each line of an English file. This class, on the other hand, has no input (initial) nor output (evolved) state vectors. Instead, the class calculates the product of the matrices corresponding to each line (gate) of an English file. In order to accomplish this goal, this class calls SEO_simulalor_mp repeatedly using as initial state vector all the standard basis vectors (2^num_qbits of them). Then the class assembles the product matrix that we seek by stacking on top of each other all the 2^num_qbits final evolved state vectors. Admittedly, this is a very slow, inefficient way of finding the sought for matrix product. However, it works fine for a small number of qubits. It can be used to check that gate expansions agree with what they are supposed to be an expansion of. Though slow, the strategy used by this class has the advantages that it was very easy to code, and that every time it is shown to work, SEO_simulator is shown to work too, 2^num_bit times. This strategy is also easier to parallelize if the need for that arises at some later date. Attributes ---------- prod_arr : np.ndarray the product matrix obtained by multiplying each line of the input English file. """
[docs] def __init__(self, file_prefix, num_qbits): """ Constructor Parameters ---------- file_prefix : str Prefix of English file being read num_qbits : int number of bits in English file begin read. Returns ------- """ self.prod_arr = None num_comps = 1 << num_qbits fin_list = [] for s in range(num_comps): spin_dir_list = [(s >> bpos) & 1 for bpos in reversed(range(num_qbits))] init_st_vec = StateVec.get_standard_basis_st_vec( spin_dir_list, ZL=True) # print("---", spin_dir_list) # print(init_st_vec) sim = SEO_simulator_mp(file_prefix, num_qbits, init_st_vec=init_st_vec) fin_st_vec = sim.cur_st_vec_dict["pure"] fin = StateVec.get_traditional_st_vec fin_list.append(fin) # print(fin_st_vec) # print(fin) self.prod_arr = np.vstack(fin_list).transpose()
# print(self.prod_arr) if __name__ == "__main__": from qubiter.FouSEO_writer import * def main(): num_qbits = 3 emb = CktEmbedder(num_qbits, num_qbits) file_prefix = 'matrix_prod_test' wr = FouSEO_writer(True, file_prefix, emb) wr.close_files() mp = SEO_MatrixProduct(file_prefix, num_qbits) prod = mp.prod_arr exact = FouSEO_writer.fourier_trans_mat(1 << num_qbits) # print(prod) # print(exact) err = np.linalg.norm(prod - exact) print("error=", err) main()