def test_sparse_matrix(self): from qulacs import QuantumState from qulacs.gate import SparseMatrix from scipy.sparse import lil_matrix n = 5 state = QuantumState(n) matrix = lil_matrix((4, 4), dtype=np.complex128) matrix[0, 0] = 1 + 1.j matrix[1, 1] = 1. + 1.j gate = SparseMatrix([0, 1], matrix) gate.update_quantum_state(state) del gate del state
def apply_circuit(self, x, theta): """ Apply unitary gates U(x) and U(theta) to |0> Argument: x: dx1 numpy array (vector), the sample vector to be encoded. theta: n_qubitsx(3*D) numpy array, the decision variables. Return: circuit: quantum state after applying the circuit with the given theta. """ state = QuantumState(self.n_qubits) state.set_zero_state() # Construct a circuit circuit = QuantumCircuit(self.n_qubits) circuit = self.unitary_x(circuit, x) circuit = self.unitary_theta(circuit, theta) # apply the circuit to the zero state circuit.update_quantum_state(state) return state
def cost_uhf_sample(Quket, print_level, qulacs_hamiltonian, qulacs_s2, kappa_list, samplelist): """Function: Sample Hamiltonian and S**2 expectation values with UHF. Write out the statistics in csv files. Author(s): Takashi Tsuchimochi """ noa = Quket.noa nob = Quket.nob nva = Quket.nva nvb = Quket.nvb n_electrons = Quket.n_electrons n_qubit_system = n_qubits n_qubits = Quket.n_qubits + 1 anc = n_qubit_system ncyc = 13 opt = f"0{n_qubit_system}b" prints("", filepath="./log.txt", opentype="w") for i_sample in samplelist: sampleEn = np.zeros((ncyc, 1)) sampleS2 = np.zeros((ncyc, 1)) for icyc in range(ncyc): prints(f"n_sample = {i_sample} ({icyc:3d} / {ncyc})", filepath="./log.txt") state = QuantumState(n_qubit_system) circuit_rhf = set_circuit_rhf(n_qubit_system, n_electrons) circuit_rhf.update_quantum_state(state) circuit = set_circuit_uhf(n_qubit_system, noa, nob, nva, nvb, kappa_list) circuit.update_quantum_state(state) Euhf = sample_observable(state, qulacs_hamiltonian, i_sample).real #S2 = sample_observable(state, qulacs_s2, i_sample).real #Euhf = adaptive_sample_observable(state, # qulacs_hamiltonian, # i_sample).real #S2 = adaptive_sample_observable(state, qulacs_s2, i_sample).real sampleEn[icyc, 0] = Euhf #sampleS2[icyc,0] = S2 S2 = 0 with open(f"./UEn_{i_sample}.csv", "w") as fEn: writer = csv.writer(fEn) writer.writerows(sampleEn) #with open('./US2_%d.csv' % i_sample, 'w') as fS2: # writer = csv.writer(fS2) # writer.writerows(sampleS2) return Euhf, S2
def test_state_reflection(self): from qulacs import QuantumState from qulacs.gate import StateReflection n = 5 s1 = QuantumState(n) def gen_gate(): s2 = QuantumState(n) gate = StateReflection(s2) del s2 return gate gate = gen_gate() gate.update_quantum_state(s1) del gate del s1
def test_ibm_gateset() -> None: state = QuantumState(3) state.set_zero_state() circ = Circuit(3) circ.add_gate(OpType.U1, 0.19, [0]) circ.add_gate(OpType.U2, [0.19, 0.24], [1]) circ.add_gate(OpType.U3, [0.19, 0.24, 0.32], [2]) qulacs_circ = tk_to_qulacs(circ) qulacs_circ.update_quantum_state(state) state1 = QuantumState(3) state1.set_zero_state() qulacs_circ1 = QuantumCircuit(3) qulacs_circ1.add_U1_gate(0, 0.19 * np.pi) qulacs_circ1.add_U2_gate(1, 0.19 * np.pi, 0.24 * np.pi) qulacs_circ1.add_U3_gate(2, 0.19 * np.pi, 0.24 * np.pi, 0.32 * np.pi) qulacs_circ1.update_quantum_state(state1) overlap = inner_product(state1, state) assert np.isclose(1, overlap)
def test_copied_parametric_gate(self): from qulacs import ParametricQuantumCircuit, QuantumState from qulacs.gate import ParametricRX def f(): circuit = ParametricQuantumCircuit(1) gate = ParametricRX(0, 0.1) circuit.add_parametric_gate(gate) circuit.add_parametric_gate(gate) circuit.add_gate(gate) gate.set_parameter_value(0.2) circuit.add_parametric_gate(gate) circuit.add_parametric_RX_gate(0, 0.3) gate2 = gate.copy() gate2.set_parameter_value(0.4) gate.set_parameter_value(1.0) del gate circuit.add_parametric_gate(gate2) circuit.remove_gate(1) del gate2 return circuit c = f() for gc in range(c.get_parameter_count()): val = c.get_parameter(gc) c.set_parameter(gc, val + 1.0) self.assertAlmostEqual(val, gc * 0.1 + 0.1, msg="check vector size") d = c.copy() del c for gc in range(d.get_parameter_count()): val = d.get_parameter(gc) d.set_parameter(gc, val + 10) val = d.get_parameter(gc) self.assertAlmostEqual(val, 11.1 + gc * 0.1, msg="check vector size") qs = QuantumState(1) d.update_quantum_state(qs) del d del qs
def cost_uccd(Quket, print_level, kappa_list, theta_list, threshold=1e-2): """Function: Energy functional of UCCD !!!!! Not maintained and thus may fail !!!!! Author(s): Takashi Tsuchimochi """ from .hflib import set_circuit_rhf t1 = time.time() rho = Quket.rho noa = Quket.noa nob = Quket.nob nva = Quket.nva nvb = Quket.nvb n_qubits = Quket.n_qubits n_electrons = Quket.n_electrons ndim = Quket.ndim state = QuantumState(n_qubits) set_circuit = set_circuit_rhf(n_qubits, n_electrons) set_circuit.update_quantum_state(state) circuit = set_circuit_uccd(n_qubits, noa, nob, nva, nvb, theta_list) for i in range(rho): circuit.update_quantum_state(state) Euccd = Quket.qulacs.Hamiltonian.get_expectation_value(state) S2 = Quket.qulacs.S2.get_expectation_value(state) t2 = time.time() cput = t2 - t1 if print_level > 0: cf.icyc += 1 prints(f"{cf.icyc:5d}: E[UCCD] = {Euccd:.12f} <S**2> = {S2:17.15f} " f"CPU Time = {cput:2.5f}") SaveTheta(ndim, theta_list, cf.tmp) if print_level > 1: prints("\n(UCCD state)") print_state(state) # Store UCCD wave function Quket.state = state return Euccd, S2
def qite_anti(Quket, id_set, size): ### Parameter setting ansatz = Quket.ansatz n = Quket.n_qubits db = Quket.dt qbit = Quket.det ntime = Quket.maxiter observable = Quket.qulacs.Hamiltonian S2_observable = Quket.qulacs.S2 threshold = Quket.ftol S2 = 0 prints(f"QITE: Pauli operator group size = {size}") if ansatz != "cite": sigma_list, sigma_ij_index, sigma_ij_coef = qite_s_operators(id_set, n) len_list = len(sigma_list) prints(f" Unique sigma list = {len_list}") index = np.arange(n) delta = QuantumState(n) first_state = QuantumState(n) first_state.set_computational_basis(qbit) energy = [] psi_dash = first_state.copy() t1 = time.time() cf.t_old = t1 En = observable.get_expectation_value(psi_dash) energy.append(En) if S2_observable is not None: S2 = S2_observable.get_expectation_value(psi_dash) dE = 100 for t in range(ntime): t2 = time.time() cput = t2 - cf.t_old cf.t_old = t2 if cf.debug: print_state(psi_dash) prints(f"{t*db:6.2f}: E = {En:.12f} <S**2> = {S2:17.15f} " f"CPU Time = {cput: 5.2f}") if abs(dE) < threshold: break if t == 0: xv = np.zeros(size) T0 = time.time() delta = calc_delta(psi_dash, observable, n, db) T1 = time.time() if ansatz == "cite": delta.add_state(psi_dash) psi_dash = delta.copy() else: #for i in range(size): # pauli_id = id_set[i] # circuit_i = make_gate(n, index, pauli_id) # state_i = psi_dash.copy() # circuit_i.update_quantum_state(state_i) # print(i) # for j in range(i+1): # pauli_id = id_set[j] # circuit_j = make_gate(n, index, pauli_id) # state_j = psi_dash.copy() # circuit_j.update_quantum_state(state_j) # s = inner_product(state_j, state_i) # S[i][j] = s # S[j][i] = s ### Compute Sij as expectation values of sigma_list Sij_list = np.zeros(len_list) Sij_my_list = np.zeros(len_list) ipos, my_ndim = mpi.myrange(len_list) T2 = time.time() for iope in range(ipos, ipos + my_ndim): val = sigma_list[iope].get_expectation_value(psi_dash) Sij_my_list[iope] = val T3 = time.time() mpi.comm.Allreduce(Sij_my_list, Sij_list, mpi.MPI.SUM) T4 = time.time() ### Distribute Sij ij = 0 sizeT = size * (size - 1) // 2 ipos, my_ndim = mpi.myrange(sizeT) S = np.zeros((size, size), dtype=complex) my_S = np.zeros((size, size), dtype=complex) for i in range(size): for j in range(i): if ij in range(ipos, ipos + my_ndim): ind = sigma_ij_index[ij] coef = sigma_ij_coef[ij] my_S[i, j] = coef * Sij_list[ind] my_S[j, i] = my_S[i, j].conjugate() ij += 1 mpi.comm.Allreduce(my_S, S, mpi.MPI.SUM) for i in range(size): S[i, i] = 1 T5 = time.time() sigma = [] for i in range(size): pauli_id = id_set[i] circuit_i = make_gate(n, index, pauli_id) state_i = psi_dash.copy() circuit_i.update_quantum_state(state_i) sigma.append(state_i) T6 = time.time() b_l = np.empty(size) for i in range(size): b_i = inner_product(sigma[i], delta) b_i = -2 * b_i.imag b_l[i] = b_i Amat = 2 * np.real(S) T7 = time.time() zct = b_l @ Amat def cost_fun(vct): return LA.norm(Amat @ vct - b_l)**2 def J_cost_fun(vct): wct = Amat.T @ Amat @ vct return 2.0 * (wct - zct) #x = sp.optimize.minimize(cost_fun, x0=xv, method='Newton-CG', # jac=J_cost_fun, tol=1e-8).x #xv = x.copy() #x = sp.optimize.least_squares(cost_fun, x0=xv, ftol=1e-8).x #xv = x.copy() x, res, rnk, s = lstsq(Amat, b_l, cond=1e-8) a = x.copy() ### Just in case, broadcast a... mpi.comm.Bcast(a, root=0) T8 = time.time() psi_dash = calc_psi_lessH(psi_dash, n, index, a, id_set) T9 = time.time() if cf.debug: prints(f"T0 -> T1 {T1-T0}") prints(f"T1 -> T2 {T2-T1}") prints(f"T2 -> T3 {T3-T2}") prints(f"T3 -> T4 {T4-T3}") prints(f"T4 -> T5 {T5-T4}") prints(f"T5 -> T6 {T6-T5}") prints(f"T6 -> T7 {T7-T6}") prints(f"T7 -> T8 {T8-T7}") prints(f"T8 -> T9 {T9-T8}") En = observable.get_expectation_value(psi_dash) if S2_observable is not None: S2 = S2_observable.get_expectation_value(psi_dash) energy.append(En) dE = energy[t + 1] - energy[t] print_state(psi_dash, name="QITE")
def func2(): qs = QuantumState(2) circuit = func() circuit.update_quantum_state(qs)
def gen_gate(): s2 = QuantumState(n) gate = StateReflection(s2) del s2 return gate
def qite_exact(Quket): nspin = Quket.n_qubits db = Quket.dt ntime = Quket.maxiter qbit = Quket.det observable = Quket.qulacs.Hamiltonian threshold = Quket.ftol active_qubit = [x for x in range(nspin)] n = nspin size = 4**nspin index = np.arange(n) delta = QuantumState(n) first_state = QuantumState(n) first_state.set_computational_basis(qbit) prints(f"Exact QITE: Pauli operator group size = {size}") energy = [] psi_dash = first_state.copy() value = observable.get_expectation_value(psi_dash) energy.append(value) t1 = time.time() cf.t_old = t1 dE = 100 for t in range(ntime): t2 = time.time() cput = t2 - cf.t_old cf.t_old = t2 if cf.debug: print_state(psi_dash) prints(f"{t*db:6.2f}: E = {value:.12f} CPU Time = {cput:5.2f}") if abs(dE) < threshold: break #if t == 0: # xv = np.zeros(size) psi_dash_copy = psi_dash.copy() #mpi.comm.bcast(size, root=0) #S_part = np.zeros((size, size), dtype=complex) #S = np.zeros((size, size), dtype=complex) #sizeT = size*(size+1)//2 #nblock = sizeT//mpi.nprocs #ij = mpi.rank*nblock #start = int(np.sqrt(2*ij + 1/4) - 1/2) #end = int(np.sqrt(2*(ij+nblock) + 1/4) - 1/2) #for i in range(start, end): # for j in range(i+1): # S_part[i, j] = calc_inner1(i, j, n, active_qubit, # index, psi_dash) # ij += 1 # S[:i, i] = S[i, :i] #mpi.comm.Allreduce(S_part, S, mpi.MPI.SUM) S_part = np.zeros((size, size), dtype=complex) S = np.zeros((size, size), dtype=complex) sizeT = size * (size - 1) // 2 ipos, my_ndim = mpi.myrange(sizeT) ij = 0 for i in range(size): for j in range(i): if ij in range(ipos, ipos + my_ndim): S_part[i, j] = calc_inner1(i, j, n, active_qubit, index, psi_dash) S_part[j, i] = S_part[i, j].conjugate() ij += 1 mpi.comm.Allreduce(S_part, S, mpi.MPI.SUM) for i in range(size): S[i, i] = 1 sigma = [] for i in range(size): state_i = make_state1(i, n, active_qubit, index, psi_dash) sigma.append(state_i) delta = calc_delta(psi_dash, observable, n, db) b_l = [] b_l = np.empty(size) for i in range(size): b_i = inner_product(sigma[i], delta) b_i = -2 * b_i.imag b_l[i] = b_i Amat = 2 * np.real(S) zct = b_l @ Amat #def cost_fun(vct): # return LA.norm(Amat@vct - b_l)**2 #def J_cost_fun(vct): # wct = Amat.T@Amat@vct # return 2.0*(wct-zct) #x = sp.optimize.minimize(cost_fun, x0=xv, method="Newton-CG", # jac=J_cost_fun, tol=1e-8).x #xv = x.copy() x, res, rnk, s = lstsq(Amat, b_l, cond=1.0e-8) a = x.copy() ### Just in case, broadcast a... mpi.comm.Bcast(a, root=0) psi_dash = calc_psi(psi_dash_copy, n, index, a, active_qubit) value = observable.get_expectation_value(psi_dash) energy.append(value) dE = energy[t + 1] - energy[t]
def cost_phf_sample(Quket, print_level, qulacs_hamiltonian, qulacs_hamiltonianZ, qulacs_s2Z, qulacs_ancZ, coef0_H, coef0_S2, ref, theta_list, samplelist): """Function: Sample Hamiltonian and S**2 expectation values with PHF and PUCCSD. Write out the statistics in csv files. Author(s): Takashi Tsuchimochi """ t1 = time.time() noa = Quket.noa nob = Quket.nob nva = Quket.nva nvb = Quket.nvb n_electrons = Quket.n_electrons n_qubit_system = n_qubits n_qubits = Quket.n_qubits + 1 anc = n_qubit_system ndim1 = Quket.ndim1 state = QuantumState(n_qubits) circuit_rhf = set_circuit_rhfZ(n_qubits, n_electrons) circuit_rhf.update_quantum_state(state) if ref == "phf": circuit_uhf = set_circuit_uhfZ(n_qubits, noa, nob, nva, nvb, theta_list) circuit_uhf.update_quantum_state(state) print("pHF") elif ref == "puccsd": circuit = set_circuit_uccsd(n_qubits, noa, nob, nva, nvb, theta_list, ndim1) for i in range(rho): circuit.update_quantum_state(state) print("UCCSD") if print_level > -1: print("State before projection") utils.print_state(state, n_qubit_system) #### Set post-measurement states #### #poststate0 = state.copy() #poststate1 = state.copy() #circuit0 = QuantumCircuit(n_qubits) #circuit1 = QuantumCircuit(n_qubits) #### Projection to anc = 0 or anc = 1 ### #circuit0.add_gate(P0(0)) #circuit1.add_gate(P1(0)) #circuit0.update_quantum_state(poststate0) #circuit1.update_quantum_state(poststate1) #### Renormalize each state ### #norm0 = poststate0.get_squared_norm() #norm1 = poststate1.get_squared_norm() #poststate0.normalize(norm0) #poststate1.normalize(norm1) ### grid loop ### Ng = 4 beta = [-0.861136311594053, -0.339981043584856, 0.339981043584856, 0.861136311594053] wg = [0.173927422568724, 0.326072577431273, 0.326072577431273, 0.173927422568724] Ng = 2 beta = [0.577350269189626, -0.577350269189626] wg = [0.5, 0.5] ### a list to compute the probability to observe 0 in ancilla qubit p0_list = np.full(n_qubits, 2) p0_list[-1] = 0 ### Array for <HUg>, <S2Ug>, <Ug> # samplelist = [10,100,1000,10000,100000,1000000,10000000] ncyc = 4 prints("", filepath="./log2.txt") for i_sample in samplelist: i_sample_x = i_sample if i_sample == 10000000: print("OK") ncyc = ncyc*10 i_sample_x = 1000000 sampleHUg1 = [] sampleHUg2 = [] sampleHUg3 = [] sampleHUg4 = [] sampleS2Ug1 = [] sampleS2Ug2 = [] sampleS2Ug3 = [] sampleS2Ug4 = [] sampleUg1 = [] sampleUg2 = [] sampleUg3 = [] sampleUg4 = [] # sampleEn = [] # sampleS2 = [] sampleHUg = np.zeros((ncyc, Ng)) sampleS2Ug = np.zeros((ncyc, Ng)) sampleUg = np.zeros((ncyc, Ng)) sampleEn = np.zeros((ncyc, 1)) sampleS2 = np.zeros((ncyc, 1)) for icyc in range(ncyc): prints(f"n_sample = {i_sample_x} ({icyc} / {ncyc})", filepath="./log2.txt") HUg = [] S2Ug = [] Ug = [] Ephf = S2 = Norm = 0 for i in range(Ng): ### Copy quantum state of UHF (cannot be done in real device) ### state_g = QuantumState(n_qubits) state_g.load(state) ### Construct Ug test circuit_ug = QuantumCircuit(n_qubits) ### Hadamard on anc circuit_ug.add_H_gate(anc) controlled_Ug(circuit_ug, n_qubits, anc, np.arccos(beta[i])) circuit_ug.add_H_gate(anc) circuit_ug.update_quantum_state(state_g) ### Set post-measurement states #### poststate0 = state_g.copy() poststate1 = state_g.copy() circuit0 = QuantumCircuit(n_qubits) circuit1 = QuantumCircuit(n_qubits) ### Projection to anc = 0 or anc = 1 ### circuit0.add_gate(P0(anc)) circuit1.add_gate(P1(anc)) circuit0.update_quantum_state(poststate0) circuit1.update_quantum_state(poststate1) ### Renormalize each state ### norm0 = poststate0.get_squared_norm() norm1 = poststate1.get_squared_norm() poststate0.normalize(norm0) poststate1.normalize(norm1) ### Set ancilla qubit of poststate1 to zero (so that it won't be used) ### circuit_anc = QuantumCircuit(n_qubits) circuit_anc.add_X_gate(anc) circuit_anc.update_quantum_state(poststate1) print( test_transition_observable( state_g, qulacs_hamiltonianZ, poststate0, poststate1, 100000)) # exit() ### Probabilities for getting 0 and 1 in ancilla qubit ### p0 = state_g.get_marginal_probability(p0_list) p1 = 1 - p0 ### Compute expectation value <HUg> ### HUg.append(sample_observable(state_g, qulacs_hamiltonianZ, i_sample_x).real) #HUg.append(adaptive_sample_observable(state_g, # qulacs_hamiltonianZ, # i_sample_x).real) ### <S2Ug> ### S2Ug.append(sample_observable(state_g, qulacs_s2Z, i_sample_x).real) #S2Ug.append(adaptive_sample_observable(state_g, # qulacs_s2Z, # i_sample_x).real) #S2Ug.append(qulacs_s2Z.get_expectation_value(state_g)) #HUg.append(0) #S2Ug.append(0) #Ug.append(p0 - p1) n_term = qulacs_hamiltonianZ.get_term_count() n_sample_total = i_sample_x * n_term # in the worst-case scenario, # Ug is measured as many times as n_sample_total #(required to evaluate HUg) Ug.append(sample_observable(state_g, qulacs_ancZ, i_sample_x*n_term).real) #p0_sample = 0 #for j_sample in range(n_sample_total): # if(p0 > np.random.rand()): # p0_sample += 1 #Ug.append(2*p0_sample/n_sample_total - 1) ### Norm accumulation ### Norm += wg[i]*Ug[i] sampleHUg[icyc, i] = HUg[i] sampleS2Ug[icyc, i] = S2Ug[i] sampleUg[icyc, i] = Ug[i] #print('p0 : ',p0,' p1 : ',p1, ' p0 - p1 : ',p0-p1) sampleHUg1.append(HUg[0]) sampleHUg2.append(HUg[1]) #sampleHUg3.append(HUg[2]) #sampleHUg4.append(HUg[3]) sampleS2Ug1.append(S2Ug[0]) sampleS2Ug2.append(S2Ug[1]) #sampleS2Ug3.append(S2Ug[2]) #sampleS2Ug4.append(S2Ug[3]) sampleUg1.append(Ug[0]) sampleUg2.append(Ug[1]) #sampleUg3.append(Ug[2]) #sampleUg4.append(Ug[3]) ### Energy calculation <HP>/<P> and <S**2P>/<P> ### Ephf = 0 for i in range(Ng): Ephf += wg[i]*HUg[i]/Norm S2 += wg[i]*S2Ug[i]/Norm # print(" <S**2> = ", S2, '\n') Ephf += coef0_H S2 += coef0_S2 sampleEn[icyc, 0] = Ephf sampleS2[icyc, 0] = S2 # print(" <E[PHF]> (Nsample = ",i_sample,") = ", Ephf) #print(f"(n_sample = {i_sample}): sample HUg1\n",sampleHUg1) #print(f"(n_sample = {i_sample}): sample HUg2\n",sampleHUg2) #print(f"(n_sample = {i_sample}): sample HUg3\n",sampleHUg3) #print(f"(n_sample = {i_sample}): sample HUg4\n",sampleHUg4) #print(f"(n_sample = {i_sample}): sample S2Ug1\n",sampleS2Ug1) #print(f"(n_sample = {i_sample}): sample S2Ug2\n",sampleS2Ug2) #print(f"(n_sample = {i_sample}): sample S2Ug3\n",sampleS2Ug3) #print(f"(n_sample = {i_sample}): sample S2Ug4\n",sampleS2Ug4) #print(f"(n_sample = {i_sample}): sample Ug1\n",sampleUg1) #print(f"(n_sample = {i_sample}): sample Ug2\n",sampleUg2) #print(f"(n_sample = {i_sample}): sample Ug3\n",sampleUg3) #print(f"(n_sample = {i_sample}): sample Ug4\n",sampleUg4) #print(f"(n_sample = {i_sample}): sample HUg1\n",sampleHUg1) #print(f"(n_sample = {i_sample}): sample HUg2\n",sampleHUg2) #print(f"(n_sample = {i_sample}): sample HUg3\n",sampleHUg3) #print(f"(n_sample = {i_sample}): sample HUg4\n",sampleHUg4) #print(f"(n_sample = {i_sample}): sample En\n",sampleEn) #print(f"(n_sample = {i_sample}): sample S2\n",sampleS2) with open(f"./Ug_{i_sample}.csv", "w") as fUg: writer = csv.writer(fUg) writer.writerows(sampleUg) with open(f"./HUg_{i_sample}.csv", "w") as fHUg: writer = csv.writer(fHUg) writer.writerows(sampleHUg) with open(f"./S2Ug_{i_sample}.csv", "w") as fS2Ug: writer = csv.writer(fS2Ug) writer.writerows(sampleS2Ug) with open(f"./En_{i_sample}.csv", "w") as fEn: writer = csv.writer(fEn) writer.writerows(sampleEn) with open(f"./S2_{i_smaple}.csv", "w") as fS2: writer = csv.writer(fS2) writer.writerows(sampleS2) return Ephf, S2
def test_observable(state, obs, obsZ, n_sample): """Function Args: state (qulacs.QuantumState): This includes entangled ancilla (n_qubits = n_qubit_system + 1) obs (qulacs.Observable): This does not include ancilla Z (n_qubit_system) obsZ (qulacs.Observable): Single Pauli Z for ancilla (1) poststate0 (qulacs.QuantumState): post-measurement state when ancilla = 0 (n_qubit_system) poststate1 (qulacs.QuantumState): post-measurement state when ancilla = 1 (n_qubit_system) n_sample (int): number of samples for each observable Return: :float: sampled expectation value of the observable Author(s): Takashi Tsuchimochi """ n_term = obs.get_term_count() n_qubits = obs.get_qubit_count() p0 = state.get_zero_probability(n_qubits) p1 = 1 - p0 opt = f"0{n_qubits}b" expH = 0 exp = [] coef = [] buf_state = QuantumState(n_qubits) for i in range(n_term): pauli_term = obs.get_term(i) coef.append(pauli_term.get_coef().real) pauli_id = pauli_term.get_pauli_id_list() pauli_index = pauli_term.get_index_list() if len(pauli_id) == 0: # means identity exp.extend(coef) continue buf_state.load(state) measurement_circuit = QuantumCircuit(n_qubits) mask = "".join(["1" if n_qubits - 1 - k in pauli_index else "0" for k in range(n_qubits)]) measure_observable = QubitOperator((), 1) for single_pauli, index in zip(pauli_id, pauli_index): if single_pauli == 1: ### X measurement_circuit.add_H_gate(index) measure_observable *= QubitOperator(f"X{index}") elif single_pauli == 2: ### Y measurement_circuit.add_Sdag_gate(index) measurement_circuit.add_H_gate(index) measure_observable *= QubitOperator(f"Y{index}") elif single_pauli == 3: ### Z measure_observable *= QubitOperator(f"Z{index}") qulacs_measure_observable \ = create_observable_from_openfermion_text( str(measure_observable)) measurement_circuit.update_quantum_state(buf_state) #exp.append(obsZ.get_expectation_value(buf_state).real) samples = buf_state.sampling(n_sample) #print(f"samples? {format(samples[0], opt)}") #print(f"I = {i:5d} h_I = {coef[i]:10.5f} <P_I> = {exp[i]:10.5f}") #mask = int(mask, 2) #print(sum(list(map(lambda x: (-1)**(bin(x & mask).count('1')), # samples)))) #print(coef*sum(list(map(lambda x: (-1)**(bin(x & mask).count('1')), # samples)))) expH += coef[i]*exp[i] samples = buf_state.sampling(n_sample) mask = int(mask, 2) prob = (sum(list(map(lambda x: (-1)**(bin(x & mask).count("1")), samples))) /n_sample) measure_list = list(map(int, np.ones(n_qubits)*2)) for j in pauli_index: measure_list[j] = 1 #print(qulacs_measure_observable.get_expectation_value(state)) expH += coef[i]*prob #print(f"coef: {coef[i]:10.5f} prob: {prob:10.5f}") return expH
def NProj(Quket, Q, threshold=1e-8): """Function Perform number-projection to QuantumState |Q> |Q'> = PN |Q> where PN is a number-projection operator (non-unitary). PN = \sum_i^ng wg[i] Ug[i] This function provides a shortcut to |Q'>, which is unreal. One actually needs to develop a quantum circuit for this (See QST 6, 014004 (2021)). Author(s): Takashi Tsuchimochi """ n_qubits = Q.get_qubit_count() state_P = QuantumState(n_qubits) state_P.multiply_coef(0) state_g = QuantumState(n_qubits) nphi = max(Quket.projection.number_ngrids, 1) #print_state(Q) for iphi in range(nphi): coef = (Quket.projection.np_weight[iphi] * np.exp(1j * Quket.projection.np_angle[iphi] * (Quket.projection.n_active_electrons - Quket.projection.n_active_orbitals))) state_g = Q.copy() circuit = QuantumCircuit(n_qubits) set_circuit_ExpNa(circuit, n_qubits, Quket.projection.np_angle[iphi]) set_circuit_ExpNb(circuit, n_qubits, Quket.projection.np_angle[iphi]) circuit.update_quantum_state(state_g) state_g.multiply_coef(coef) state_P.add_state(state_g) norm2 = state_P.get_squared_norm() if norm2 < threshold: error( "Norm of number-projected state is too small!\n", "This usually means the broken-symmetry state has NO component ", "of the target number.") state_P.normalize(norm2) return state_P
class QulacsDevice(Device): """Qulacs device""" name = 'Qulacs device' short_name = 'qulacs.simulator' pennylane_requires = '>=0.5.0' version = __version__ author = 'Steven Oud' _capabilities = {'model': 'qubit', 'tensor_observables': True} _operations_map = { 'QubitStateVector': None, 'BasisState': None, 'QubitUnitary': None, 'Toffoli': toffoli, 'CSWAP': CSWAP, 'CRZ': crz, 'Rot': None, 'SWAP': gate.SWAP, 'CNOT': gate.CNOT, 'CZ': gate.CZ, 'S': gate.S, 'Sdg': gate.Sdag, 'T': gate.T, 'Tdg': gate.Tdag, 'RX': gate.RX, 'RY': gate.RY, 'RZ': gate.RZ, 'PauliX': gate.X, 'PauliY': gate.Y, 'PauliZ': gate.Z, 'Hadamard': gate.H } _observable_map = { 'PauliX': X, 'PauliY': Y, 'PauliZ': Z, 'Hadamard': H, 'Identity': I, 'Hermitian': hermitian } operations = _operations_map.keys() observables = _observable_map.keys() def __init__(self, wires, gpu=False, **kwargs): super().__init__(wires=wires) if gpu: if not GPU_SUPPORTED: raise DeviceError( 'GPU not supported with installed version of qulacs. ' 'Please install "qulacs-gpu" to use GPU simulation.') self._state = QuantumStateGpu(wires) else: self._state = QuantumState(wires) self._circuit = QuantumCircuit(wires) self._first_operation = True def apply(self, operation, wires, par): par = np.negative(par) if operation == 'BasisState' and not self._first_operation: raise DeviceError( 'Operation {} cannot be used after other Operations have already been applied ' 'on a {} device.'.format(operation, self.short_name)) self._first_operation = False if operation == 'QubitStateVector': if len(par[0]) != 2**len(wires): raise ValueError('State vector must be of length 2**wires.') self._state.load(par[0]) elif operation == 'BasisState': if len(par[0]) != len(wires): raise ValueError('Basis state must prepare all qubits.') basis_state = 0 for bit in reversed(par[0]): basis_state = (basis_state << 1) | bit self._state.set_computational_basis(basis_state) elif operation == 'QubitUnitary': if len(par[0]) != 2**len(wires): raise ValueError( 'Unitary matrix must be of shape (2**wires, 2**wires).') unitary_gate = gate.DenseMatrix(wires, par[0]) self._circuit.add_gate(unitary_gate) elif operation == 'Rot': self._circuit.add_gate( gate.merge([ gate.RZ(wires[0], par[0]), gate.RY(wires[0], par[1]), gate.RZ(wires[0], par[2]) ])) elif operation in ('CRZ', 'Toffoli', 'CSWAP'): mapped_operation = self._operations_map[operation] if callable(mapped_operation): gate_matrix = mapped_operation(*par) else: gate_matrix = mapped_operation dense_gate = gate.DenseMatrix(wires, gate_matrix) self._circuit.add_gate(dense_gate) else: mapped_operation = self._operations_map[operation] self._circuit.add_gate(mapped_operation(*wires, *par)) @property def state(self): return self._state.get_vector() def pre_measure(self): self._circuit.update_quantum_state(self._state) def expval(self, observable, wires, par): bra = self._state.copy() if isinstance(observable, list): A = self._get_tensor_operator_matrix(observable, par) wires = [item for sublist in wires for item in sublist] else: A = self._get_operator_matrix(observable, par) dense_gate = gate.DenseMatrix(wires, A) dense_gate.update_quantum_state(self._state) expectation = inner_product(bra, self._state) return expectation.real def probabilities(self): states = itertools.product(range(2), repeat=self.num_wires) probs = np.abs(self.state)**2 return OrderedDict(zip(states, probs)) def reset(self): self._state.set_zero_state() self._circuit = QuantumCircuit(self.num_wires) def _get_operator_matrix(self, operation, par): A = self._observable_map[operation] if not callable(A): return A return A(*par) def _get_tensor_operator_matrix(self, obs, par): ops = [self._get_operator_matrix(o, p) for o, p in zip(obs, par)] return functools.reduce(np.kron, ops)
value_train = list() input_test = list() value_test = list() with open('Training.data', 'rb') as f: data = pickle.load(f) training_data = data[0:80] test_data = data[80:100] f = open('loss2.txt',"w" ) print(training_data[0]) state = QuantumState(nqubit) for d in data: input_train.append(d[0] ) value_train.append(d[1]) # To have a basic training and cross validation set for d in training_data: input_train.append(d[0]) value_train.append(d[1]) for d in test_data: input_test.append(d[0]) value_test.append(d[1])
for j in range(n_qubit - 1): circuit.add_CNOT_gate(j, j + 1) circuit.add_gate(RY(j, theta_list[n_qubit * (1 + d) + j])) circuit.add_H_gate(j + 1) circuit.add_gate( RY(n_qubit - 1, theta_list[n_qubit * (1 + d) + n_qubit - 1])) return circuit n_qubit = nvar depth = 2 init_theta_list = np.random.randn(n_qubit * (depth + 1)) print("n_qubit =", n_qubit) input_state = QuantumState(n_qubit) input_state.set_zero_state() #input_state.set_Haar_random_state() def cost(theta_list): #input_state.set_zero_state() input_state.set_computational_basis( int('0b' + '1' * (n_qubit / 2) + '0' * (n_qubit / 2), 2)) circ = ansatz_circuit(n_qubit, depth, theta_list) circ.update_quantum_state(input_state) value = qulacs_hamiltonian.get_expectation_value(input_state) print(" cost -->", value) return value
""" probabilistic bit flip noise """ from qulacs import Observable from qulacs import QuantumState, QuantumCircuit from qulacs.gate import Probabilistic, X import matplotlib.pyplot as plt obs = Observable(1) obs.add_operator(1, "Z 0") state = QuantumState(1) circuit = QuantumCircuit(1) p = 0.1 # probability of bit flip n_circuit_sample = 10000 n_depth = 20 # the number of probabilistic gate probabilistic_pauli_gate = Probabilistic([p], [X(0)]) #define probabilistic gate circuit.add_gate(probabilistic_pauli_gate) # add the prob. gate to the circuit exp_array = [] for depth in range(n_depth): exp = 0 for i in [0] * n_circuit_sample: state.set_zero_state() for _ in range(depth): circuit.update_quantum_state(state) # apply the prob. gate exp += obs.get_expectation_value(
# partial trace p0 = psi.get_marginal_probability( [lambda i: 0 if i == a_idx else 2 for i in range(n_qubits)]) p1 = psi.get_marginal_probability( [lambda i: 1 if i == a_idx else 2 for i in range(n_qubits)]) # update kickback phase kth_digit = 1 if (p0 < p1) else 0 kickback_phase = kickback_phase / 2 + kth_digit return -0.5 * np.pi * kickback_phase if __name__ == "__main__": n_qubits = 3 # 2 for electron configurations and 1 for ancilla g_list = [0.3593, 0.0896, -0.4826, 0.0896] pauli_strings = ['Z 0', 'Y 0 Y 1', 'Z 1', 'X 0 X 1'] hf_state = QuantumState(n_qubits) hf_state.set_computational_basis(0b001) # |0>|01> t = 0.640 n_itter = 16 # determine precission # validity check _, eigs = reduced_term_hamiltonian() e_exact = eigs[0] print('e_exact:{}'.format(e_exact)) print('n, e_matrix, e_iqpe, |e_matrix-e_iqpe|, |e_exact-e_iqpe|') for n in range(1, 10, 2): iqpe_phase = iterative_phase_estimation(g_list, t, n_itter, hf_state, n_trotter_step=n,
def cost_proj(Quket, print_level, qulacs_hamiltonianZ, qulacs_s2Z, coef0_H, coef0_S2, kappa_list, theta_list=0, threshold=0.01): """Function: Energy functional for projected methods (phf, puccsd, puccd, opt_puccd) Author(s): Takashi Tsuchimochi """ t1 = time.time() noa = Quket.noa nob = Quket.nob nva = Quket.nva nvb = Quket.nvb n_electrons = Quket.n_electrons rho = Quket.rho DS = Quket.DS anc = Quket.anc n_qubit_system = Quket.n_qubits n_qubits = n_qubit_system + 1 # opt_psauccdとかはndimの計算が異なるけどこっちを使う? #ndim1 = noa * nva + nob * nvb #ndim2aa = int(noa * (noa - 1) * nva * (nva - 1) / 4) #ndim2ab = int(noa * nob * nva * nvb) #ndim2bb = int(nob * (nob - 1) * nvb * (nvb - 1) / 4) #ndim2 = ndim2aa + ndim2ab + ndim2bb ndim1 = Quket.ndim1 ndim2 = Quket.ndim2 ndim = Quket.ndim ref = Quket.ansatz state = QuantumState(n_qubits) if noa == nob: circuit_rhf = set_circuit_rhfZ(n_qubits, n_electrons) else: circuit_rhf = set_circuit_rohfZ(n_qubits, noa, nob) circuit_rhf.update_quantum_state(state) if ref == "phf": circuit_uhf = set_circuit_uhfZ(n_qubits, noa, nob, nva, nvb, kappa_list) circuit_uhf.update_quantum_state(state) elif ref == "sghf": circuit_ghf = set_circuit_ghfZ(n_qubits, noa + nob, nva + nvb, kappa_list) circuit_ghf.update_quantum_state(state) elif ref == "puccsd": # First prepare UHF determinant circuit_uhf = set_circuit_uhfZ(n_qubits, noa, nob, nva, nvb, kappa_list) circuit_uhf.update_quantum_state(state) # Then prepare UCCSD theta_list_rho = theta_list / rho circuit = set_circuit_uccsd(n_qubits, noa, nob, nva, nvb, 0, theta_list_rho, ndim1) for i in range(rho): circuit.update_quantum_state(state) elif ref == "puccd": # First prepare UHF determinant circuit_uhf = set_circuit_uhfZ(n_qubits, noa, nob, nva, nvb, kappa_list) circuit_uhf.update_quantum_state(state) # Then prepare UCCD theta_list_rho = theta_list / rho circuit = set_circuit_uccd(n_qubits, noa, nob, nva, nvb, theta_list_rho) for i in range(rho): circuit.update_quantum_state(state) elif ref == "opt_puccd": if DS: # First prepare UHF determinant circuit_uhf = set_circuit_uhfZ(n_qubits, noa, nob, nva, nvb, theta_list) circuit_uhf.update_quantum_state(state) # Then prepare UCCD theta_list_rho = theta_list[ndim1:] / rho circuit = set_circuit_uccd(n_qubits, noa, nob, nva, nvb, theta_list_rho) for i in range(rho): circuit.update_quantum_state(state) else: # First prepare UCCD theta_list_rho = theta_list[ndim1:] / rho circuit = set_circuit_uccd(n_qubits, noa, nob, nva, nvb, theta_list_rho) for i in range(rho): circuit.update_quantum_state(state) # then rotate circuit_uhf = set_circuit_uhfZ(n_qubits, noa, nob, nva, nvb, theta_list) circuit_uhf.update_quantum_state(state) elif ref == "opt_psauccd": # ここが問題 # ndim2が他と異なる #theta_list_rho = theta_list[ndim1 : ndim1+ndim2]/rho theta_list_rho = theta_list[ndim1:] / rho circuit = set_circuit_sauccd(n_qubits, noa, nva, theta_list_rho) for i in range(rho): circuit.update_quantum_state(state) circuit_uhf = set_circuit_uhfZ(n_qubits, noa, nob, nva, nvb, theta_list) circuit_uhf.update_quantum_state(state) if print_level > 0: if ref in ("uhf", "phf", "suhf", "sghf"): SaveTheta(ndim, kappa_list, cf.tmp) else: SaveTheta(ndim, theta_list, cf.tmp) if print_level > 1: prints("State before projection") print_state(state, n_qubits=n_qubit_system) if ref in ("puccsd", "opt_puccd"): print_amplitudes(theta_list, noa, nob, nva, nvb, threshold) ### grid loop ### ### a list to compute the probability to observe 0 in ancilla qubit ### Array for <HUg>, <S2Ug>, <Ug> Ep = S2 = Norm = 0 nalpha = max(Quket.projection.euler_ngrids[0], 1) nbeta = max(Quket.projection.euler_ngrids[1], 1) ngamma = max(Quket.projection.euler_ngrids[2], 1) HUg = np.empty(nalpha * nbeta * ngamma) S2Ug = np.empty(nalpha * nbeta * ngamma) Ug = np.empty(nalpha * nbeta * ngamma) ig = 0 for ialpha in range(nalpha): alpha = Quket.projection.sp_angle[0][ialpha] alpha_coef = Quket.projection.sp_weight[0][ialpha] for ibeta in range(nbeta): beta = Quket.projection.sp_angle[1][ibeta] beta_coef = (Quket.projection.sp_weight[1][ibeta] * Quket.projection.dmm[ibeta]) for igamma in range(ngamma): gamma = Quket.projection.sp_angle[2][igamma] gamma_coef = Quket.projection.sp_weight[2][igamma] ### Copy quantum state of UHF (cannot be done in real device) ### state_g = QuantumState(n_qubits) state_g.load(state) ### Construct Ug test circuit_ug = QuantumCircuit(n_qubits) ### Hadamard on anc circuit_ug.add_H_gate(anc) #circuit_ug.add_X_gate(anc) #controlled_Ug(circuit_ug, n_qubits, anc, beta) controlled_Ug_gen(circuit_ug, n_qubits, anc, alpha, beta, gamma) #circuit_ug.add_X_gate(anc) circuit_ug.add_H_gate(anc) circuit_ug.update_quantum_state(state_g) ### Compute expectation value <HUg> ### HUg[ig] = qulacs_hamiltonianZ.get_expectation_value(state_g) ### <S2Ug> ### # print_state(state_g) S2Ug[ig] = qulacs_s2Z.get_expectation_value(state_g) ### <Ug> ### p0 = state_g.get_zero_probability(anc) p1 = 1 - p0 Ug[ig] = p0 - p1 ### Norm accumulation ### Norm += alpha_coef * beta_coef * gamma_coef * Ug[ig] Ep += alpha_coef * beta_coef * gamma_coef * HUg[ig] S2 += alpha_coef * beta_coef * gamma_coef * S2Ug[ig] ig += 1 # print('p0 : ',p0,' p1 : ',p1, ' p0 - p1 : ',p0-p1) # print("Time: ",t2-t1) ### Energy calculation <HP>/<P> and <S**2P>/<P> ### Ep /= Norm S2 /= Norm Ep += coef0_H S2 += coef0_S2 t2 = time.time() cpu1 = t2 - t1 if print_level == -1: prints(f"Initial E[{ref}] = {Ep:.12f} <S**2> = {S2:17.15f} " f"rho = {rho}") elif print_level == 1: cput = t2 - cf.t_old cf.t_old = t2 cf.icyc += 1 prints(f"{cf.icyc:5d}: E[{ref}] = {Ep:.12f} <S**2> = {S2:17.15f} " f"CPU Time = {cput:5.2f} ({cpu1:2.2f} / step)") elif print_level > 1: prints(f"Final: E[{ref}] = {Ep:.12f} <S**2> = {S2:17.15f} " f"rho = {rho}") print_state(state, n_qubits=n_qubits - 1) if ref in ("puccsd", "opt_puccd"): print_amplitudes(theta_list, noa, nob, nva, nvb) prints("HUg", HUg) prints("Ug", Ug) # Store wave function Quket.state = state return Ep, S2
def S2Proj(Quket, Q, threshold=1e-8): """Function Perform spin-projection to QuantumState |Q> |Q'> = Ps |Q> where Ps is a spin-projection operator (non-unitary). Ps = \sum_i^ng wg[i] Ug[i] This function provides a shortcut to |Q'>, which is unreal. One actually needs to develop a quantum circuit for this (See PRR 2, 043142 (2020)). Author(s): Takashi Tsuchimochi """ spin = Quket.projection.spin s = (spin - 1) / 2 Ms = Quket.projection.Ms / 2 n_qubits = Q.get_qubit_count() state_P = QuantumState(n_qubits) state_P.multiply_coef(0) nalpha = max(Quket.projection.euler_ngrids[0], 1) nbeta = max(Quket.projection.euler_ngrids[1], 1) ngamma = max(Quket.projection.euler_ngrids[2], 1) for ialpha in range(nalpha): alpha = Quket.projection.sp_angle[0][ialpha] alpha_coef = Quket.projection.sp_weight[0][ialpha] * np.exp( 1j * alpha * Ms) for ibeta in range(nbeta): beta = Quket.projection.sp_angle[1][ibeta] beta_coef = (Quket.projection.sp_weight[1][ibeta] * Quket.projection.dmm[ibeta]) for igamma in range(ngamma): gamma = Quket.projection.sp_angle[2][igamma] gamma_coef = (Quket.projection.sp_weight[2][igamma] * np.exp(1j * gamma * Ms)) # Total Weight coef = (2 * s + 1) / (8 * np.pi) * (alpha_coef * beta_coef * gamma_coef) state_g = QuantumState(n_qubits) state_g.load(Q) circuit_Rg = QuantumCircuit(n_qubits) set_circuit_Rg(circuit_Rg, n_qubits, alpha, beta, gamma) circuit_Rg.update_quantum_state(state_g) state_g.multiply_coef(coef) state_P.add_state(state_g) # Normalize norm2 = state_P.get_squared_norm() if norm2 < threshold: error( "Norm of spin-projected state is too small!\n", "This usually means the broken-symmetry state has NO component ", "of the target spin.") state_P.normalize(norm2) # print_state(state_P,name="P|Q>",threshold=1e-6) return state_P
class QulacsDevice(QubitDevice): """Qulacs device""" name = "Qulacs device" short_name = "qulacs.simulator" pennylane_requires = ">=0.11.0" version = __version__ author = "Steven Oud and Xanadu" gpu_supported = GPU_SUPPORTED _capabilities = { "model": "qubit", "tensor_observables": True, "inverse_operations": True } _operation_map = { "QubitStateVector": None, "BasisState": None, "QubitUnitary": None, "Toffoli": gate.TOFFOLI, "CSWAP": gate.FREDKIN, "CRZ": crz, "SWAP": gate.SWAP, "CNOT": gate.CNOT, "CZ": gate.CZ, "S": gate.S, "T": gate.T, "RX": gate.RX, "RY": gate.RY, "RZ": gate.RZ, "PauliX": gate.X, "PauliY": gate.Y, "PauliZ": gate.Z, "Hadamard": gate.H, "PhaseShift": phase_shift, } _observable_map = { "PauliX": "X", "PauliY": "Y", "PauliZ": "Z", "Identity": "I", "Hadamard": None, "Hermitian": None, } operations = _operation_map.keys() observables = _observable_map.keys() # Add inverse gates to _operation_map _operation_map.update({k + ".inv": v for k, v in _operation_map.items()}) def __init__(self, wires, shots=1000, analytic=True, gpu=False, **kwargs): super().__init__(wires=wires, shots=shots, analytic=analytic) if gpu: if not QulacsDevice.gpu_supported: raise DeviceError( "GPU not supported with installed version of qulacs. " "Please install 'qulacs-gpu' to use GPU simulation.") self._state = QuantumStateGpu(self.num_wires) else: self._state = QuantumState(self.num_wires) self._circuit = QuantumCircuit(self.num_wires) self._pre_rotated_state = self._state.copy() def apply(self, operations, **kwargs): rotations = kwargs.get("rotations", []) self.apply_operations(operations) self._pre_rotated_state = self._state.copy() # Rotating the state for measurement in the computational basis if rotations: self.apply_operations(rotations) def apply_operations(self, operations): """Apply the circuit operations to the state. This method serves as an auxiliary method to :meth:`~.QulacsDevice.apply`. Args: operations (List[pennylane.Operation]): operations to be applied """ for i, op in enumerate(operations): if i > 0 and isinstance(op, (QubitStateVector, BasisState)): raise DeviceError( "Operation {} cannot be used after other Operations have already been applied " "on a {} device.".format(op.name, self.short_name)) if isinstance(op, QubitStateVector): self._apply_qubit_state_vector(op) elif isinstance(op, BasisState): self._apply_basis_state(op) elif isinstance(op, QubitUnitary): self._apply_qubit_unitary(op) elif isinstance(op, (CRZ, PhaseShift)): self._apply_matrix(op) else: self._apply_gate(op) def _apply_qubit_state_vector(self, op): """Initialize state with a state vector""" wires = op.wires input_state = op.parameters[0] if len(input_state) != 2**len(wires): raise ValueError("State vector must be of length 2**wires.") if input_state.ndim != 1 or len(input_state) != 2**len(wires): raise ValueError("State vector must be of length 2**wires.") if not np.isclose(np.linalg.norm(input_state, 2), 1.0, atol=tolerance): raise ValueError("Sum of amplitudes-squared does not equal one.") input_state = _reverse_state(input_state) # call qulacs' state initialization self._state.load(input_state) def _apply_basis_state(self, op): """Initialize a basis state""" wires = op.wires par = op.parameters # translate from PennyLane to Qulacs wire order bits = par[0][::-1] n_basis_state = len(bits) if not set(bits).issubset({0, 1}): raise ValueError( "BasisState parameter must consist of 0 or 1 integers.") if n_basis_state != len(wires): raise ValueError( "BasisState parameter and wires must be of equal length.") basis_state = 0 for bit in bits: basis_state = (basis_state << 1) | bit # call qulacs' basis state initialization self._state.set_computational_basis(basis_state) def _apply_qubit_unitary(self, op): """Apply unitary to state""" # translate op wire labels to consecutive wire labels used by the device device_wires = self.map_wires(op.wires) par = op.parameters if len(par[0]) != 2**len(device_wires): raise ValueError( "Unitary matrix must be of shape (2**wires, 2**wires).") if op.inverse: par[0] = par[0].conj().T # reverse wires (could also change par[0]) reverse_wire_labels = device_wires.tolist()[::-1] unitary_gate = gate.DenseMatrix(reverse_wire_labels, par[0]) self._circuit.add_gate(unitary_gate) unitary_gate.update_quantum_state(self._state) def _apply_matrix(self, op): """Apply predefined gate-matrix to state (must follow qulacs convention)""" # translate op wire labels to consecutive wire labels used by the device device_wires = self.map_wires(op.wires) par = op.parameters mapped_operation = self._operation_map[op.name] if op.inverse: mapped_operation = self._get_inverse_operation( mapped_operation, device_wires, par) if callable(mapped_operation): gate_matrix = mapped_operation(*par) else: gate_matrix = mapped_operation # gate_matrix is already in correct order => no wire-reversal needed dense_gate = gate.DenseMatrix(device_wires.labels, gate_matrix) self._circuit.add_gate(dense_gate) gate.DenseMatrix(device_wires.labels, gate_matrix).update_quantum_state(self._state) def _apply_gate(self, op): """Apply native qulacs gate""" # translate op wire labels to consecutive wire labels used by the device device_wires = self.map_wires(op.wires) par = op.parameters mapped_operation = self._operation_map[op.name] if op.inverse: mapped_operation = self._get_inverse_operation( mapped_operation, device_wires, par) # Negating the parameters such that it adheres to qulacs par = np.negative(par) # mapped_operation is already in correct order => no wire-reversal needed self._circuit.add_gate(mapped_operation(*device_wires.labels, *par)) mapped_operation(*device_wires.labels, *par).update_quantum_state(self._state) @staticmethod def _get_inverse_operation(mapped_operation, device_wires, par): """Return the inverse of an operation""" if mapped_operation is None: return mapped_operation # if an inverse variant of the operation exists try: inverse_operation = getattr(gate, mapped_operation.get_name() + "dag") except AttributeError: # if the operation is hard-coded try: if callable(mapped_operation): inverse_operation = np.conj(mapped_operation(*par)).T else: inverse_operation = np.conj(mapped_operation).T # if mapped_operation is a qulacs.gate and np.conj is applied on it except TypeError: # else, redefine the operation as the inverse matrix def inverse_operation(*p): # embed the gate in a unitary matrix with shape (2**wires, 2**wires) g = mapped_operation(*p).get_matrix() mat = reduce(np.kron, [np.eye(2)] * len(device_wires)).astype(complex) mat[-len(g):, -len(g):] = g # mat follows PL convention => reverse wire-order reverse_wire_labels = device_wires.tolist()[::-1] gate_mat = gate.DenseMatrix(reverse_wire_labels, np.conj(mat).T) return gate_mat return inverse_operation def analytic_probability(self, wires=None): """Return the (marginal) analytic probability of each computational basis state.""" if self._state is None: return None all_probs = self._abs(self.state)**2 prob = self.marginal_prob(all_probs, wires) return prob def expval(self, observable): if self.analytic: qulacs_observable = Observable(self.num_wires) if isinstance(observable.name, list): observables = [ self._observable_map[obs] for obs in observable.name ] else: observables = [self._observable_map[observable.name]] if None not in observables: applied_wires = self.map_wires(observable.wires).tolist() opp = " ".join([ f"{obs} {applied_wires[i]}" for i, obs in enumerate(observables) ]) qulacs_observable.add_operator(1.0, opp) return qulacs_observable.get_expectation_value( self._pre_rotated_state) # exact expectation value eigvals = self._asarray(observable.eigvals, dtype=self.R_DTYPE) prob = self.probability(wires=observable.wires) return self._dot(eigvals, prob) # estimate the ev return np.mean(self.sample(observable)) @property def state(self): # returns the state after all operations are applied return _reverse_state(self._state.get_vector()) def reset(self): self._state.set_zero_state() self._pre_rotated_state = self._state.copy() self._circuit = QuantumCircuit(self.num_wires)
def test_VqeOptimizer(): from qulacs import ParametricQuantumCircuit from qulacs import QuantumState from qulacs import Observable from qulacs.gate import Probabilistic, X, Y, Z import numpy as np import matplotlib.pyplot as plt n_qubit = 2 p_list = [0.05, 0.1, 0.15] parametric_circuit_list = \ [ParametricQuantumCircuit(n_qubit) for i in range(len(p_list))] initial_state = QuantumState(n_qubit) for (p, circuit) in zip(p_list, parametric_circuit_list): circuit.add_H_gate(0) circuit.add_parametric_RY_gate(1, np.pi / 6) circuit.add_CNOT_gate(0, 1) prob = Probabilistic([p / 4, p / 4, p / 4], [X(0), Y(0), Z(0)]) circuit.add_gate(prob) noiseless_circuit = ParametricQuantumCircuit(n_qubit) noiseless_circuit.add_H_gate(0) noiseless_circuit.add_parametric_RY_gate(1, np.pi / 6) noiseless_circuit.add_CNOT_gate(0, 1) n_sample_per_circuit = 1 n_circuit_sample = 1000 obs = Observable(n_qubit) obs.add_operator(1.0, "Z 0 Z 1") obs.add_operator(0.5, "X 0 X 1") initial_param = np.array([np.pi / 6]) opt = VqeOptimizer(parametric_circuit_list, initial_state, obs, initial_param, p_list, n_circuit_sample=n_circuit_sample, n_sample_per_circuit=n_sample_per_circuit, noiseless_circuit=noiseless_circuit) noisy = opt.sample_output(initial_param) mitigated, exp_array, _ = opt.sample_mitigated_output(initial_param, return_full=True) exact = opt.exact_output(initial_param) print(noisy, exact) print(exp_array, mitigated) opt_param = opt.optimize() print(opt_param) theta_list = np.linspace(0, np.pi, 100) output_list = [opt.exact_output([theta]) for theta in theta_list] plt.plot(theta_list, output_list, color="black", linestyle="dashed", label="exact") plt.scatter(opt.parameter_history, opt.exp_history, c="blue", label="optimization history") plt.xlabel("theta") plt.ylabel("output") plt.legend() plt.show()
def cost_phf_sample_oneshot(print_level, qulacs_hamiltonianZ, qulacs_s2Z, qulacs_ancZ, coef0_H, coef0_S2, kappa_list): """Function: Test function for sampling Hamiltonian and S** expectation values with PHF just for once. Author(s): Takashi Tsuchimochi 使われてない? """ t1 = time.time() noa = Quket.noa nob = Quket.nob nva = Quket.nva nvb = Quket.nvb n_electrons = Quket.n_electrons n_qubit_system = n_qubits n_qubits = Quket.n_qubits + 1 anc = n_qubit_system state = QuantumState(n_qubits) circuit_rhf = set_circuit_rhfZ(n_qubits, n_electrons) circuit_rhf.update_quantum_state(state) circuit_uhf = set_circuit_uhfZ(n_qubits, noa, nob, nva, nvb, kappa_list) circuit_uhf.update_quantum_state(state) ### Set post-measurement states #### poststate0 = state.copy() poststate1 = state.copy() circuit0 = QuantumCircuit(n_qubits) circuit1 = QuantumCircuit(n_qubits) ### Projection to anc = 0 or anc = 1 ### circuit0.add_gate(P0(0)) circuit1.add_gate(P1(0)) circuit0.update_quantum_state(poststate0) circuit1.update_quantum_state(poststate1) ### Renormalize each state ### norm0 = poststate0.get_squared_norm() norm1 = poststate1.get_squared_norm() poststate0.normalize(norm0) poststate1.normalize(norm1) ### grid loop ### Ng = 4 beta = [-0.861136311594053, -0.339981043584856, 0.339981043584856, 0.861136311594053] wg = [0.173927422568724, 0.326072577431273, 0.326072577431273, 0.173927422568724] ### a list to compute the probability to observe 0 in ancilla qubit p0_list = np.full(n_qubits, 2) p0_list[-1] = 0 ### Array for <HUg>, <S2Ug>, <Ug> samplelist = [5, 50, 500, 5000, 50000, 500000, 5000000] Ng = 4 ncyc = 10 prints("", filepath="./log.txt", opentype="w") for i_sample in samplelist: sampleEn = [] sampleS2 = [] for icyc in range(ncyc): prints(f"n_sample : {i_sample} ({icyc} / {ncyc})", filepath="./log.txt") HUg = [] S2Ug = [] Ug = [] Ephf = S2 = Norm = 0 for i in range(Ng): ### Copy quantum state of UHF (cannot be done in real device) ### state_g = QuantumState(n_qubits) circuit_rhf.update_quantum_state(state_g) circuit_uhf.update_quantum_state(state_g) ### Construct Ug test circuit_ug = QuantumCircuit(n_qubits) ### Hadamard on anc circuit_ug.add_H_gate(anc) controlled_Ug(circuit_ug, n_qubits, anc, np.arccos(beta[i])) circuit_ug.add_H_gate(anc) circuit_ug.update_quantum_state(state_g) ### Probabilities for getting 0 and 1 in ancilla qubit ### p0 = state_g.get_marginal_probability(p0_list) p1 = 1 - p0 ### Compute expectation value <HUg> ### HUg.append(sample_observable(state_g, qulacs_hamiltonianZ, i_sample).real) ### <S2Ug> ### S2Ug.append(sample_observable(state_g, qulacs_s2Z, i_sample).real) #S2Ug.append(qulacs_s2Z.get_expectation_value(state_g)) #Ug.append(p0 - p1) Ug.append(sample_observable(state_g, qulacs_ancZ, i_sample).real) ### Norm accumulation ### Norm += wg[i]*g[i] sampleHUg[icyc, i] = HUg[i] sampleS2Ug[icyc, i] = S2Ug[i] sampleUg[icyc, i] = Ug[i] #print(f"{p0=} {p1=} {p0-p1=}") sampleHUg1.append(HUg[0]) sampleHUg2.append(HUg[1]) sampleHUg3.append(HUg[2]) sampleHUg4.append(HUg[3]) sampleS2Ug1.append(S2Ug[0]) sampleS2Ug2.append(S2Ug[1]) sampleS2Ug3.append(S2Ug[2]) SAMpleS2Ug4.append(S2Ug[3]) sampleUg1.append(Ug[0]) sampleUg2.append(Ug[1]) sampleUg3.append(Ug[2]) sampleUg4.append(Ug[3]) ### Energy calculation <HP>/<P> and <S**2P>/<P> ### Ephf = 0 for i in range(Ng): Ephf += wg[i]*HUg[i]/Norm S2 += wg[i]*S2Ug[i]/Norm #print(f" E[PHF] = {Ephf} <S**2> = {S2} (Nsample = {i_sample})") Ephf += coef0_H S2 += coef0_S2 sampleEn[icyc, 0] = Ephf sampleS2[icyc, 0] = S2 #print(f"(n_sample = {i_sample}): sample HUg1\n", sampleHUg1) #print(f"(n_sample = {i_sample}): sample HUg2\n", sampleHUg2) #print(f"(n_sample = {i_sample}): sample HUg3\n", sampleHUg3) #print(f"(n_sample = {i_sample}): sample HUg4\n", sampleHUg4) #print(f"(n_sample = {i_sample}): sample S2Ug1\n", sampleS2Ug1) #print(f"(n_sample = {i_sample}): sample S2Ug2\n", sampleS2Ug2) #print(f"(n_sample = {i_sample}): sample S2Ug3\n", sampleS2Ug3) #print(f"(n_sample = {i_sample}): sample S2Ug4\n", sampleS2Ug4) #print(f"(n_sample = {i_sample}): sample Ug1\n", sampleUg1) #print(f"(n_sample = {i_sample}): sample Ug2\n", sampleUg2) #print(f"(n_sample = {i_sample}): sample Ug3\n", sampleUg3) #print(f"(n_sample = {i_sample}): sample Ug4\n", sampleUg4) #print(f"(n_sample = {i_sample}): sample HUg1\n", sampleHUg1) #print(f"(n_sample = {i_sample}): sample HUg2\n", sampleHUg2) #print(f"(n_sample = {i_sample}): sample HUg3\n", sampleHUg3) #print(f"(n_sample = {i_sample}): sample HUg4\n", sampleHUg4) #print(f"(n_sample = {i_sample}): sample En\n", sampleEn) #print(f"(n_sample = {i_sample}): sample S2\n", sampleS2) with open(f"./HUg_{i_sample}.csv", "w") as fHUg: writer = csv.writer(fHUg) writer.writerows(sampleHUg) with open(f"./S2Ug_{i_sample}.csv", "w") as fS2Ug: writer = csv.writer(fS2Ug) writer.writerows(sampleS2Ug) with open(f"./Ug_{i_sample}.csv", "w") as fUg: writer = csv.writer(fUg) writer.writerows(sampleUg) with open(f"./En_{i_sample}.csv", "w") as fEn: writer = csv.writer(fEn) writer.writerows(sampleEn) with open(f"./S2_{i_sample}.csv", "w") as fS2: writer = csv.writer(fS2) writer.writerows(sampleS2) return Ephf, S2
def test_transition_observable(state, obs, poststate0, poststate1, n_sample): """ Args: state (qulacs.QuantumState): This includes entangled ancilla (n_qubits = n_qubit_system + 1) obs (qulacs.Observable): This does not include ancilla Z (n_qubit_system) poststate0 (qulacs.QuantumState): post-measurement state when ancilla = 0 (n_qubit_system) poststate1 (qulacs.QuantumState): post-measurement state when ancilla = 1 (n_qubit_system) n_sample (int): number of samples for each observable Return: :float: sampled expectation value of the observable """ n_term = obs.get_term_count() n_qubits = obs.get_qubit_count() p0 = state.get_zero_probability(n_qubits - 1) p1 = 1 - p0 opt = f"0{n_qubits}b" prints(f"p0: {p0} p1: {p1}") print_state(poststate0, name="post(0)") prints("post(1)") print_state(poststate1, name="post(1)") expH = 0 exp = [] coef = [] buf_state = QuantumState(n_qubits) for i in range(n_term): pauli_term = obs.get_term(i) coef.append(pauli_term.get_coef().real) pauli_id = pauli_term.get_pauli_id_list() pauli_index = pauli_term.get_index_list() if len(pauli_id) == 0: # means identity exp.extend(coef) continue buf_state.load(state) measurement_circuit = QuantumCircuit(n_qubits) mask = "".join(["1" if n_qubits - 1 - k in pauli_index else "0" for k in range(n_qubits)]) measure_observable = QubitOperator((), 1) #measure_observable = QubitOperator('Z%d' % n_qubits) for single_pauli, index in zip(pauli_id, pauli_index): if single_pauli == 1: ### X measurement_circuit.add_H_gate(index) measure_observable *= QubitOperator(f"X{index}") elif single_pauli == 2: ### Y measurement_circuit.add_Sdag_gate(index) measurement_circuit.add_H_gate(index) measure_observable *= QubitOperator(f"Y{index}") elif single_pauli == 3: ### Z measure_observable *= QubitOperator(f"Z{index}") qulacs_measure_observable \ = create_observable_from_openfermion_text( str(measure_observable)) ### p0 ### H0 = qulacs_measure_observable.get_expectation_value(poststate0) ### p1 ### H1 = qulacs_measure_observable.get_expectation_value(poststate1) prob = p0*H0 - p1*H1 # print(prob, qulacs_measure_observable.get_expectation_value(state), obs.get_expectation_value(state)) prob = qulacs_measure_observable.get_expectation_value(state) expH += coef[i]*prob # measurement_circuit.update_quantum_state(buf_state) # samples = buf_state.sampling(n_sample) # print('samples? ',format(samples[0],opt)) # print("I = :",'%5d' % i, " h_I ", '%10.5f' % coef[i], " <P_I> ", '%10.5f' % exp[i]) # mask = int(mask, 2) # print(sum(list(map(lambda x: (-1) **(bin(x & mask).count('1')), samples)))) # print(coef*sum(list(map(lambda x: (-1) ** # (bin(x & mask).count('1')), samples)))) # expH += coef[i] * exp[i] # samples = buf_state.sampling(n_sample) # mask = int(mask, 2) # prob = sum(list(map(lambda x: (-1) ** # (bin(x & mask).count('1')), samples)))/n_sample # measure_list = list(map(int,np.ones(n_qubits)*2)) # for j in pauli_index: # measure_list[j] = 1 # print(qulacs_measure_observable.get_expectation_value(state)) # expH += coef[i] * prob print(f"coef: {coef[i]:10.5f} prob: {prob:10.5f}") return expH
cu_mat[x * 2 + 1][crow // 2 * 4 + 1 - crow] = 1 m = 2**num_bits dist_mat = np.full((m, m), .5 / m) for x in range(m): dist_mat[x][x] = -1 + .5 / m if num_bits < 6: print("CU Gate Matrix:") for i in range(2**(num_bits + 1)): print(''.join([str(b) for b in cu_mat[i]])) print("Dist Gate Matrix:") for i in range(2**num_bits): print(''.join(["{:>6.2}".format(b) for b in dist_mat[i]])) state = QuantumState(num_bits + 1) state.set_computational_basis(0) x_gate = X(0) x_gate.update_quantum_state(state) print("\nInitial State:") show_quantum_state(state) for i in range(0, num_bits + 1): h_gate = H(i) h_gate.update_quantum_state(state) print("\nAfter H Gate:") show_quantum_state(state) ite = int(math.pow(2., num_bits * .5))
def cost_ic_mrucc_spinfree(Quket, print_level, theta_list): """ Function Author(s): Yuto Mori """ t1 = time.time() nstates = Quket.multi.nstates n_qubits = Quket.n_qubits ndim = Quket.ndim ndim1 = Quket.ndim1 rho = Quket.rho DS = Quket.DS v_n, a_n, c_n = calc_num_v_a_c(Quket) states = [] for istate in range(nstates): det = Quket.multi.states[istate] state = create_icmr_uccsd_state_spinfree( n_qubits, v_n, a_n, c_n, rho, DS, theta_list, det, ndim1, act2act=Quket.multi.act2act_opt, SpinProj=Quket.projection.SpinProj) states.append(state) H, S2, S = create_HS2S(Quket, states) root_invS = root_inv(S.real) H_ortho = root_invS.T @ H @ root_invS nstates0 = root_invS.shape[1] en, dvec = np.linalg.eig(H_ortho) idx = np.argsort(en.real, -1) en = en.real[idx] dvec = dvec[:, idx] cvec = root_invS @ dvec S2dig = cvec.T @ S2 @ cvec s2 = [S2dig[i, i].real for i in range(nstates0)] t2 = time.time() cpu1 = t2 - t1 if print_level == 1: cput = t2 - cf.t_old cf.t_old = t2 cf.icyc += 1 prints(f"{cf.icyc:5d}: ", end="") for istate in range(nstates0): prints( f"E[{istate}] = {en[istate]:.8f} " f"(<S**2> = {s2[istate]:7.5f}) ", end="") prints(f"CPU Time = {cput:5.2f} ({cpu1:2.2f} / step)") SaveTheta(ndim, theta_list, cf.tmp) # cf.iter_threshold = 0 if print_level > 1: cput = t2 - cf.t_old cf.t_old = t2 prints("Final: ", end="") for istate in range(nstates0): prints( f"E[{istate}] = {en[istate]:.8f} " f"(<S**2> = {s2[istate]:7.5f}) ", end="") prints(f"CPU Time = {cput:5.2f} ({cpu1:2.2f} / step)\n") prints("------------------------------------") for istate in range(nstates): prints(f"ic Basis {istate}") print_state(states[istate]) prints("") printmat(cvec.real, name="Coefficients: ") prints("------------------------------------\n\n") prints("###############################################") prints("# ic states #") prints("###############################################", end="") for istate in range(nstates0): prints("") prints(f"State : {istate}") prints(f"E : {en[istate]:.8f}") prints(f"<S**2> : {s2[istate]:.5f}") prints(f"Superposition : ") spstate = QuantumState(n_qubits) spstate.multiply_coef(0) for jstate in range(nstates0): state = states[jstate].copy() coef = cvec[jstate, istate] state.multiply_coef(coef) spstate.add_state(state) print_state(spstate) prints("###############################################") cost = np.sum(Quket.multi.weights * en) norm = np.sum(Quket.multi.weights) cost /= norm return cost, s2
return y_dict[x] fx_type = 'balanced' cu_mat = np.zeros((2**(num_bits + 1), 2**(num_bits + 1)), np.int8) for x in range(2**num_bits): crow = x * 2 + f(x) cu_mat[x * 2][crow] = 1 cu_mat[x * 2 + 1][crow // 2 * 4 + 1 - crow] = 1 if num_bits < 6: print("CU Gate Matrix:") for i in range(2**(num_bits + 1)): print(''.join([str(b) for b in cu_mat[i]])) state = QuantumState(num_bits + 1) state.set_computational_basis(0) print("\nInitial State:") show_quantum_state(state) for i in range(1, num_bits + 1): h_gate = H(i) h_gate.update_quantum_state(state) print("\nAfter H Gate:") show_quantum_state(state) cu_gate = DenseMatrix(tuple(range(num_bits + 1)), cu_mat) cu_gate.update_quantum_state(state)
def adaptive_sample_observable(state, obs, n_sample): """ Args: state (qulacs.QuantumState): obs (qulacs.Observable) n_sample (int): number of samples for each observable Return: :float: sampled expectation value of the observable """ n_term = obs.get_term_count() n_qubits = obs.get_qubit_count() exp = 0 buf_state = QuantumState(n_qubits) ### check the coefficients for each term... coef_list = np.array([abs(obs.get_term(i).get_coef()) for i in range(n_term)]) sum_coef = np.sum(coef_list) ### sort sorted_indices = np.argsort(-coef_list) coef_list.sort() #sorted_coef_list = [coef_list[i] for i in sorted_indices] ### determine sampling wight n_sample_total = n_sample*n_term n_sample_list = n_sample_total*coef_list//sum_coef n_count = np.sum(n_sample_list) n_rest = n_sample_total - n_count n_sample_list[sorted_indices[:n_rest]] += 1 j = 0 for i in range(n_term): if n_sample_list[i] == 0: continue j += n_sample_list[i] pauli_term = obs.get_term(i) coef = pauli_term.get_coef() pauli_id = pauli_term.get_pauli_id_list() pauli_index = pauli_term.get_index_list() if len(pauli_id) == 0: # means identity exp += coef continue buf_state.load(state) measurement_circuit = QuantumCircuit(n_qubits) mask = "".join(["1" if n_qubits - 1 - k in pauli_index else "0" for k in range(n_qubits)]) for single_pauli, index in zip(pauli_id, pauli_index): if single_pauli == 1: measurement_circuit.add_H_gate(index) elif single_pauli == 2: measurement_circuit.add_Sdag_gate(index) measurement_circuit.add_H_gate(index) measurement_circuit.update_quantum_state(buf_state) samples = buf_state.sampling(n_sample_list[i]) mask = int(mask, 2) exp += (coef *sum(list(map(lambda x: (-1)**(bin(x & mask).count("1")), samples))) /n_sample_list[i]) return exp
def test_circuit_add_parametric_gate(self): from qulacs import ParametricQuantumCircuit, QuantumState from qulacs.gate import Identity, X, Y, Z, H, S, Sdag, T, Tdag, sqrtX, sqrtXdag, sqrtY, sqrtYdag from qulacs.gate import P0, P1, U1, U2, U3, RX, RY, RZ, CNOT, CZ, SWAP, TOFFOLI, FREDKIN, Pauli, PauliRotation from qulacs.gate import DenseMatrix, SparseMatrix, DiagonalMatrix, RandomUnitary, ReversibleBoolean, StateReflection from qulacs.gate import BitFlipNoise, DephasingNoise, IndependentXZNoise, DepolarizingNoise, TwoQubitDepolarizingNoise, AmplitudeDampingNoise, Measurement from qulacs.gate import merge, add, to_matrix_gate, Probabilistic, CPTP, Instrument, Adaptive from qulacs.gate import ParametricRX, ParametricRY, ParametricRZ, ParametricPauliRotation from scipy.sparse import lil_matrix qc = ParametricQuantumCircuit(3) qs = QuantumState(3) ref = QuantumState(3) sparse_mat = lil_matrix((4, 4)) sparse_mat[0, 0] = 1 sparse_mat[1, 1] = 1 def func(v, d): return (v + 1) % d def adap(v): return True gates = [ Identity(0), X(0), Y(0), Z(0), H(0), S(0), Sdag(0), T(0), Tdag(0), sqrtX(0), sqrtXdag(0), sqrtY(0), sqrtYdag(0), Probabilistic([0.5, 0.5], [X(0), Y(0)]), CPTP([P0(0), P1(0)]), Instrument([P0(0), P1(0)], 1), Adaptive(X(0), adap), CNOT(0, 1), CZ(0, 1), SWAP(0, 1), TOFFOLI(0, 1, 2), FREDKIN(0, 1, 2), Pauli([0, 1], [1, 2]), PauliRotation([0, 1], [1, 2], 0.1), DenseMatrix(0, np.eye(2)), DenseMatrix([0, 1], np.eye(4)), SparseMatrix([0, 1], sparse_mat), DiagonalMatrix([0, 1], np.ones(4)), RandomUnitary([0, 1]), ReversibleBoolean([0, 1], func), StateReflection(ref), BitFlipNoise(0, 0.1), DephasingNoise(0, 0.1), IndependentXZNoise(0, 0.1), DepolarizingNoise(0, 0.1), TwoQubitDepolarizingNoise(0, 1, 0.1), AmplitudeDampingNoise(0, 0.1), Measurement(0, 1), merge(X(0), Y(1)), add(X(0), Y(1)), to_matrix_gate(X(0)), P0(0), P1(0), U1(0, 0.), U2(0, 0., 0.), U3(0, 0., 0., 0.), RX(0, 0.), RY(0, 0.), RZ(0, 0.), ] gates.append(merge(gates[0], gates[1])) gates.append(add(gates[0], gates[1])) parametric_gates = [ ParametricRX(0, 0.1), ParametricRY(0, 0.1), ParametricRZ(0, 0.1), ParametricPauliRotation([0, 1], [1, 1], 0.1) ] ref = None for gate in gates: qc.add_gate(gate) for gate in gates: qc.add_gate(gate) for pgate in parametric_gates: qc.add_parametric_gate(pgate) for pgate in parametric_gates: qc.add_parametric_gate(pgate) qc.update_quantum_state(qs) qc = None qs = None for gate in gates: gate = None for pgate in parametric_gates: gate = None gates = None parametric_gates = None