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))
def main(): import numpy as np n_qubit = 2 obs = Observable(n_qubit) initial_state = QuantumState(n_qubit) obs.add_operator(1, "Z 0 Z 1") circuit_list = [] p_list = [0.02, 0.04, 0.06, 0.08] #prepare circuit list for p in p_list: circuit = QuantumCircuit(n_qubit) circuit.add_H_gate(0) circuit.add_RY_gate(1, np.pi / 6) circuit.add_CNOT_gate(0, 1) circuit.add_gate( Probabilistic([p / 4, p / 4, p / 4], [X(0), Y(0), Z(0)])) #depolarizing noise circuit.add_gate( Probabilistic([p / 4, p / 4, p / 4], [X(1), Y(1), Z(1)])) #depolarizing noise circuit_list.append(circuit) #get mitigated output mitigated, non_mitigated_array, fit_coefs = error_mitigation_extrapolate_linear( circuit_list, p_list, initial_state, obs, n_circuit_sample=100000, return_full=True) #plot the result p = np.linspace(0, max(p_list), 100) plt.plot(p, fit_coefs[0] * p + fit_coefs[1], linestyle="--", label="linear fit") plt.scatter(p_list, non_mitigated_array, label="un-mitigated") plt.scatter(0, mitigated, label="mitigated output") #prepare the clean result state = QuantumState(n_qubit) circuit = QuantumCircuit(n_qubit) circuit.add_H_gate(0) circuit.add_RY_gate(1, np.pi / 6) circuit.add_CNOT_gate(0, 1) circuit.update_quantum_state(state) plt.scatter(0, obs.get_expectation_value(state), label="True output") plt.xlabel("error rate") plt.ylabel("expectation value") plt.legend() plt.show()
def qtest(angle): state = QuantumState(3) state.set_Haar_random_state() circuit = QuantumCircuit(3) circuit.add_X_gate(0) merged_gate = merge(CNOT(0, 1), Y(1)) circuit.add_gate(merged_gate) circuit.add_RX_gate(1, angle) circuit.update_quantum_state(state) observable = Observable(3) observable.add_operator(2.0, "X 2 Y 1 Z 0") observable.add_operator(-3.0, "Z 2") result = observable.get_expectation_value(state) output = {'energy': result} return (output)
def convert_openfermion_op(n_qubit, openfermion_op): """convert_openfermion_op Args: n_qubit (:class:`int`) openfermion_op (:class:`openfermion.ops.QubitOperator`) Returns: :class:`qulacs.Observable` """ ret = Observable(n_qubit) for pauli_product in openfermion_op.terms: coef = float(np.real(openfermion_op.terms[pauli_product])) pauli_string = '' for pauli_operator in pauli_product: pauli_string += pauli_operator[1] + ' ' + str(pauli_operator[0]) pauli_string += ' ' ret.add_operator(coef, pauli_string[:-1]) return ret
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 test_observable(self): from qulacs import Observable obs = Observable(1) obs.add_operator(1.0, "X 0") term = obs.get_term(0) del term
U.add_RZ_gate(i, angle_z) return U # Function to update theta def set_U_out(theta): global U_out parameter_count = U_out.get_parameter_count() for i in range(parameter_count): U_out.set_parameter(i, theta[i]) # Construct an observable gate obs = Observable(nqubit) obs.add_operator(1, "Z 0") obs.add_operator(2, "Z 1") #obs.add_operator(4, "Z 2") # Function for prediction def qcl_pred(x, U_out): # Output state U_out.update_quantum_state(x) # Output from the model res = obs.get_expectation_value(state) return res # cost function L
#circuit.add_H_gate(2) circuit.add_RX_gate(0, 0.1) circuit.add_RX_gate(1, 0.1) #circuit.add_RX_gate(2, 0.1) merged_gate = merge(CNOT(0,1),Y(1)) circuit.add_gate(merged_gate) meas0 = Measurement(0, 0) circuit.add_gate(meas0) meas1 = Measurement(1, 1) circuit.add_gate(meas1) #meas2 = Measurement(2, 2) #circuit.add_gate(meas2) print(circuit) observable = Observable(nqubit) observable.add_operator(1, "Z 0") observable.add_operator(2, "Z 1") #observable.add_operator(4, "Z 2") data = list() x_value = list() y_value = list() for i in range(n_data): #state.set_Haar_random_state() x = random.random() state.set_zero_state() # U_in|000> U_in(x).update_quantum_state(state) state_vec = state.get_vector() circuit.update_quantum_state(state) value = observable.get_expectation_value(state)
parameter_count = U_out.get_parameter_count() theta_init = [U_out.get_parameter(ind) for ind in range(parameter_count)] # Function to update theta def set_U_out(theta): global U_out parameter_count = U_out.get_parameter_count() for i in range(parameter_count): U_out.set_parameter(i, theta[i]) # Construct an observable gate from qulacs import Observable obs = Observable(nqubit) obs.add_operator(2.,'Z 0') # Add an operator 2*Z. This number should be optimised. # Function for prediction def qcl_pred(x, U_out): state = QuantumState(nqubit) state.set_zero_state() # Input state U_in(x).update_quantum_state(state) # Output state U_out.update_quantum_state(state) # Output from the model res = obs.get_expectation_value(state)