with open('pickled_objs/' + name + '.pkl', 'rb') as f:
return pickle.load(f)
load_prev = False
if load_prev == True:
print("loading previously computed results for " + str(num_qubits) + " qubits")
result_fname = None #fill this up
theoretical_curves_fname = None # fill this up
result_fname = str(num_qubits)+"_qubits_results"
theoretical_curves_fname = str(num_qubits)+"_qubits_theoretical_curves"
# observable_expectation_results, theoretical_expectation_values, fidelity_results = load_obj(result_fname)
results = load_obj(result_fname)
theoretical_curves = load_obj(theoretical_curves_fname)
else:
observable_one = hcp.generate_arbitary_observable(num_qubits, [1], ["1" + "0"*(num_qubits-1)])
observable_two = hcp.generate_arbitary_observable(num_qubits, [1], ["2" + "0"*(num_qubits-1)])
observable_three = hcp.generate_arbitary_observable(num_qubits, [1], ["3" + "0"*(num_qubits-1)])
observables_list = [observable_one, observable_two, observable_three]
# observable_expectation_results, theoretical_expectation_values, fidelity_results = big_ass_loop(g, observables_list)
delta_vals = [0,0.125,0.25,0.375, 0.5,0.625,0.75,0.875, 1.0, 1.5, 2.0]
#g_vals = [0.5]
results = {delta:big_ass_loop(delta,Gamma=Gamma,mu=mu,observable_obj_list= observables_list) for delta in delta_vals}
theoretical_curves = plot_theoretical_expectation_curves(min(delta_vals), max(delta_vals),Gamma,mu, observables_list)
if use_qiskit == True:
fname_append = str(num_qubits) + "_qubits" + "_sim=" + str(sim) + "_"
else:
print('SDP failed for this run, probably due to not high enough K')
else:
IQAE_instance.check_if_valid_density_matrix()
#print(all_energies)
#print(all_states)
print('The ground state energy is\n', groundstateenergy)
#print('The density matrix is\n',density_mat)
denmat_values, denmat_vects = scp.linalg.eig(density_mat)
denmat_values = np.real(np.round(denmat_values, 6))
#print(np.imag(denmat_values))
print("the sorted density matrix (beta matrix) eigenvalues are\n",
np.sort(denmat_values))
#print("the density matrix eigenvectors are\n",denmat_vects)
##########Calculate Observables##########
observable = hcp.generate_arbitary_observable(
num_qubits, [1], ["3" + (num_qubits - 1) * "0"]) #here its 3 0 0 0 0
observableresults = plotp.getdata_forbetamatrix_observable(
num_qubits,
ansatzlist,
whatKs,
observable,
initial_state,
betamatrixlist,
evalmethod='matrix_multiplication')
for i in range(len(whatKs)):
print('The result of the observable for K = ' + str(whatKs[i]) + ' is: ' +
str(observableresults[i]))
#%%
#testing for the feasibility routine
'''NOTES FOR SELF: Right now matlab functionality is not built into this. So, first time you run, this python file will generate the D, E, R, and F matrices. Ignore everything else. Then, go to matlab and run sdp.m .
result = QAS_instance.get_results()
#Update ansatz with the new alphas
ansatz.update_alphas(result)
#Update final results with this
finalresults.append(ansatz)
#Now, finalresults is a list of Ansatzes, each Ansatz basically stores the results for that run
#Example, Final results might look like this [Ansatz_0,Ansatz_1,Ansatz_2,Ansatz_3]
#Where Ansatz_1 is an Ansatz class, which was used for the K=1 run, and contains the final results for that run
#plot the results for the final k-moment
ansatz = finalresults[-1]
times = QAS_instance.get_times()
observable = hcp.generate_arbitary_observable(num_qubits, [1], ["300"])
O_matrix_uneval = mcp.unevaluatedmatrix(num_qubits, ansatz, observable, "O")
O_mat_evaluated = O_matrix_uneval.evaluate_matrix_by_matrix_multiplicaton(
initial_state)
result_pauli_string, result_alphas = ansatz.get_alphas()
result_alphas = list(zip(*result_alphas))
observable_vals = []
for time_idx in range(len(times)):
time = times[time_idx]
alpha = result_alphas[time_idx]
alpha = np.array(alpha)
observable_value = alpha.conj().T @ O_mat_evaluated @ alpha
observable_value = observable_value.real
observable_vals.append(observable_value)