def convert_to_wpauli_list(term): if term[0] == complex(0): separated_ham = 0 * WeightedPauliOperator.from_list( paulis=[Pauli.from_label('I' * num_qubits)]) else: separated_ham = WeightedPauliOperator.from_list([term[1]], [term[0]]) return separated_ham
def Gen_rand_1_ham(num_terms, num_qubits): wop = 0*WeightedPauliOperator.from_list(paulis = [Pauli.from_label('I'*num_qubits)]) ham = wop for i in range(0,num_terms): pauli = random_pauli(num_qubits) wpauli = WeightedPauliOperator.from_list(paulis=[pauli], weights=[1.0]) ham = ham + wpauli return ham
def Gen_rand_rand_ham(num_terms, num_qubits): wop = 0*WeightedPauliOperator.from_list(paulis = [Pauli.from_label('I'*num_qubits)]) ham = wop pauli_list = [] i = 0 while i < num_terms: pauli = random_pauli(num_qubits) if pauli_list.count(pauli) == 0: wpauli = WeightedPauliOperator.from_list(paulis=[pauli], weights=[np.random.uniform(0,1)]) ham = ham + wpauli pauli_list.append(pauli) i = i+1 return ham
def test_negation_operator(self): """ negation operator test """ paulis = [Pauli.from_label(x) for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY']] coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8] op1 = WeightedPauliOperator.from_list(paulis, coeffs) coeffs = [-0.2, -0.6, -0.8, 0.2, 0.6, 0.8] op2 = WeightedPauliOperator.from_list(paulis, coeffs) self.assertNotEqual(op1, op2) self.assertEqual(op1, -op2) self.assertEqual(-op1, op2) op1 = op1 * -1.0 self.assertEqual(op1, op2)
def split_into_paulis(ham): ham_details = ham.print_details() ham_list = ham_details.split('\n') pauli_list = [0] * (len(ham_list) - 1 ) #exclude last entry of ham list bc is just blank name_list = [0] * (len(ham_list) - 1) weight_list = [0] * (len(ham_list) - 1) for counter in range(0, len(ham_list) - 1, 1): pauli = Pauli.from_label(ham_list[counter][:4]) name_list[counter] = WeightedPauliOperator.from_list( [pauli]).print_details() weight_list[counter] = complex(ham_list[counter][6:-1]) pauli_list[counter] = WeightedPauliOperator.from_list([pauli]) return weight_list, pauli_list, name_list
def test_chop(self): """ chop test """ paulis = [ Pauli.from_label(x) for x in ['IIXX', 'ZZXX', 'ZZZZ', 'XXZZ', 'XXXX', 'IXXX'] ] coeffs = [0.2, 0.3, 0.4, 0.5, 0.6, 0.7] op = WeightedPauliOperator.from_list(paulis, coeffs) grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator( op, TPBGroupedWeightedPauliOperator.sorted_grouping) original_num_basis = len(grouped_op.basis) chopped_grouped_op = grouped_op.chop(0.35, copy=True) self.assertLessEqual(len(chopped_grouped_op.basis), 3) self.assertLessEqual(len(chopped_grouped_op.basis), original_num_basis) # ZZXX group is remove for b, _ in chopped_grouped_op.basis: self.assertFalse(b.to_label() == 'ZZXX') chopped_grouped_op = grouped_op.chop(0.55, copy=True) self.assertLessEqual(len(chopped_grouped_op.basis), 1) self.assertLessEqual(len(chopped_grouped_op.basis), original_num_basis) for b, _ in chopped_grouped_op.basis: self.assertFalse(b.to_label() == 'ZZXX') self.assertFalse(b.to_label() == 'ZZZZ') self.assertFalse(b.to_label() == 'XXZZ')
def setUp(self): super().setUp() seed = 0 np.random.seed(seed) aqua_globals.random_seed = seed self.num_qubits = 3 paulis = [ Pauli.from_label(pauli_label) for pauli_label in itertools.product('IXYZ', repeat=self.num_qubits) ] weights = np.random.random(len(paulis)) self.qubit_op = WeightedPauliOperator.from_list(paulis, weights) self.var_form = RYRZ(self.qubit_op.num_qubits, 1) qasm_simulator = BasicAer.get_backend('qasm_simulator') self.quantum_instance_qasm = QuantumInstance(qasm_simulator, shots=65536, seed_simulator=seed, seed_transpiler=seed) statevector_simulator = BasicAer.get_backend('statevector_simulator') self.quantum_instance_statevector = QuantumInstance( statevector_simulator, shots=1, seed_simulator=seed, seed_transpiler=seed)
def setUp(self): super().setUp() seed = 0 aqua_globals.random_seed = seed self.num_qubits = 3 paulis = [ Pauli.from_label(pauli_label) for pauli_label in itertools.product('IXYZ', repeat=self.num_qubits) ] weights = aqua_globals.random.random(len(paulis)) self.qubit_op = WeightedPauliOperator.from_list(paulis, weights) warnings.filterwarnings('ignore', category=DeprecationWarning) self.var_form = RYRZ(self.qubit_op.num_qubits, 1) warnings.filterwarnings('always', category=DeprecationWarning) qasm_simulator = BasicAer.get_backend('qasm_simulator') self.quantum_instance_qasm = QuantumInstance(qasm_simulator, shots=65536, seed_simulator=seed, seed_transpiler=seed) statevector_simulator = BasicAer.get_backend('statevector_simulator') self.quantum_instance_statevector = \ QuantumInstance(statevector_simulator, shots=1, seed_simulator=seed, seed_transpiler=seed)
def output_dressed_ham(self): i = 0 term_sums = [0] * 4**self.num_qubits sum_term = self.zero_term other_sum_term = self.zero_term for term in self.ham_term_list: for descendant in term['descendants']: weight, pauli, name = split_into_paulis(descendant) term_sums[int(base_4_map( name[0]))] = np.real(term_sums[int(base_4_map( name[0]))]) + np.real(weight[0] * self.constants[i]) other_sum_term = other_sum_term + np.real( weight[0] * self.constants[i]) * pauli[0] i = i + 1 for i, entry in enumerate(term_sums): if abs(entry) > 0.000001: pauli_num = quaternary(i) pauli_name = create_term(pauli_num, self.num_qubits) pauli = Pauli.from_label(pauli_name) wpauli = WeightedPauliOperator.from_list(paulis=[pauli]) sum_term = entry * wpauli + sum_term print(sum_term.print_details()) mat = to_matrix_operator(sum_term) print(mat.print_details()) #mat_2 = to_matrix_operator(other_sum_term) #print(mat_2.print_details()) print(term_sums)
def test_sorted_grouping(self): """Test with color grouping approach.""" num_qubits = 2 paulis = [ Pauli.from_label(pauli_label) for pauli_label in itertools.product('IXYZ', repeat=num_qubits) ] weights = aqua_globals.random.random(len(paulis)) op = WeightedPauliOperator.from_list(paulis, weights) grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator( op, TPBGroupedWeightedPauliOperator.sorted_grouping) # check all paulis are still existed. for g_p in grouped_op.paulis: passed = False for pauli in op.paulis: if pauli[1] == g_p[1]: passed = pauli[0] == g_p[0] break self.assertTrue( passed, "non-existed paulis in grouped_paulis: {}".format( g_p[1].to_label())) # check the number of basis of grouped # one should be less than and equal to the original one. self.assertGreaterEqual(len(op.basis), len(grouped_op.basis))
def test_simplify(self): """ simplify test """ pauli_a = 'IXYZ' pauli_b = 'IXYZ' coeff_a = 0.5 coeff_b = -0.5 pauli_term_a = [coeff_a, Pauli.from_label(pauli_a)] pauli_term_b = [coeff_b, Pauli.from_label(pauli_b)] op_a = WeightedPauliOperator(paulis=[pauli_term_a]) op_b = WeightedPauliOperator(paulis=[pauli_term_b]) new_op = op_a + op_b new_op.simplify() self.assertEqual(0, len(new_op.paulis), "{}".format(new_op.print_details())) self.assertTrue(new_op.is_empty()) paulis = [ Pauli.from_label(x) for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY'] ] coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8] op1 = WeightedPauliOperator.from_list(paulis, coeffs) for i, pauli in enumerate(paulis): tmp_op = WeightedPauliOperator(paulis=[[-coeffs[i], pauli]]) op1 += tmp_op op1.simplify() self.assertEqual(len(paulis) - (i + 1), len(op1.paulis))
def test_chop_complex(self): """ chop complex test """ paulis = [ Pauli.from_label(x) for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY'] ] coeffs = [ 0.2 + -0.5j, 0.6 - 0.3j, 0.8 - 0.6j, -0.5 + -0.2j, -0.3 + 0.6j, -0.6 + 0.8j ] op = WeightedPauliOperator.from_list(paulis, coeffs) ori_op = op.copy() for threshold, num_paulis in zip([0.4, 0.7, 0.9], [6, 2, 0]): op = ori_op.copy() op1 = op.chop(threshold=threshold, copy=True) self.assertEqual(len(op.paulis), 6, "\n{}".format(op.print_details())) self.assertEqual(len(op1.paulis), num_paulis, "\n{}".format(op1.print_details())) op1 = op.chop(threshold=threshold, copy=False) self.assertEqual(len(op.paulis), num_paulis, "\n{}".format(op.print_details())) self.assertEqual(len(op1.paulis), num_paulis, "\n{}".format(op1.print_details()))
def __init__(self, operator, optimizer, var_form = None, max_evals_grouped = 1, aux_operators = None, callback = None, auto_conversion = True, initial_point = None, ham_list = None, operator_list = None, nonzero_terms = None, starting_point = False, expecs = None, expec_mode = False, dir_to_bracket = False, ham_term_list = None, ham_energy_list = None, base_3_list = None): super().__init__( operator = operator, var_form = var_form, optimizer = optimizer, initial_point = initial_point, max_evals_grouped = max_evals_grouped, aux_operators = aux_operators, callback = callback, auto_conversion = auto_conversion ) self.num_qubits = operator.num_qubits if expecs == None and expec_mode == True: expecs = pd.read_csv('{}_qubit_pauli_values.csv'.format(self.num_qubits)) #this file is required unless you pass in the expecation values (in order) manually expecs = expecs.to_dict() if expec_mode == True: self.expecs = expecs else: self.expecs = [] if operator_list is not None: self.op_list = operator_list else: self.op_list = var_form.operator_pool.pool if initial_point is not None: self.param_list = initial_point else: self.param_list = [0]*len(self.op_list) self.starting_point = starting_point if starting_point: self.ham_list = ham_list self.nonzero_terms = nonzero_terms self.zero_term = 0*WeightedPauliOperator.from_list(paulis = [Pauli.from_label('I'*self.num_qubits)]) self.empt_term = self.zero_term - self.zero_term self.dir_to_bracket = dir_to_bracket self.ham_term_list = ham_term_list self.ham_energy_list = ham_energy_list self.base_3_list = base_3_list
def anti_commuting_part( self, operator: WeightedPauliOperator) -> WeightedPauliOperator: result = WeightedPauliOperator([]) for c, p in self._hamiltonian.paulis: part = WeightedPauliOperator.from_list(paulis=[p], weights=[c]) if part.anticommute_with(operator): result += part return result
def drop_z_2_symmetry_ops(self, inplace: bool = True): f_op = WeightedPauliOperator.from_list( paulis=[Pauli.from_label('X' * self.num_qubits)], weights=[1.0]) new_ops = list(filter(lambda op: f_op.commute_with(op), self.pool)) if inplace: self._pool = new_ops else: res = ADAPTQAOAPool.from_operator_list(new_ops) return res
def Generate_roto_op(op, *args, **kwargs): parameter = kwargs['parameter'] ham = kwargs['ham'] energy_step_tol = kwargs['energy_step_tol'] Iden = WeightedPauliOperator.from_list( paulis=[Pauli.from_label('I' * ham.num_qubits)], weights=[1.0]) psi = np.cos(parameter) * Iden + 1j * np.sin(parameter) * op psi_star = np.cos(parameter) * Iden - 1j * np.sin(parameter) * op return ((psi) * ham * (psi_star)).chop(threshold=energy_step_tol, copy=True)
def test_equal_operator(self): """ equal operator test """ paulis = [Pauli.from_label(x) for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY']] coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8] op1 = WeightedPauliOperator.from_list(paulis, coeffs) coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8] op2 = WeightedPauliOperator.from_list(paulis, coeffs) coeffs = [-0.2, -0.6, -0.8, 0.2, 0.6, 0.8] op3 = WeightedPauliOperator.from_list(paulis, coeffs) coeffs = [-0.2, 0.6, 0.8, -0.2, -0.6, -0.8] op4 = WeightedPauliOperator.from_list(paulis, coeffs) self.assertEqual(op1, op2) self.assertNotEqual(op1, op3) self.assertNotEqual(op1, op4) self.assertNotEqual(op3, op4)
def split_into_paulis(ham): """ Used to split the given hamiltonian into lists of constituent parts: weight_list: list of complex floats that are the weights of terms in the hamiltonian pauli_list: a list of the Weighted_pauli_operator representations of the pauli strings in the hamiltonian (does not include weights) name_list: a list of strings that correspond to the names of the operators in the hamiltonian """ num_qubits = ham.num_qubits ham_details = ham.print_details() ham_list = ham_details.split('\n') pauli_list = [0] * (len(ham_list) - 1 ) #exclude last entry of ham list bc is just blank name_list = [0] * (len(ham_list) - 1) weight_list = [0] * (len(ham_list) - 1) if len(ham_list) > 2: for counter in range(0, len(ham_list), 1): if ham_list[counter][num_qubits + 2:] == '': break if ham_list[counter][num_qubits + 1:] == '0': name_list[counter] = 'I' * num_qubits weight_list[counter] = complex(0) pauli_list[counter] = 0 * WeightedPauliOperator.from_list( paulis=[Pauli.from_label('I' * num_qubits)]) else: pauli = Pauli.from_label(ham_list[counter][:num_qubits]) name_list[counter] = ham_list[counter][:num_qubits] weight_list[counter] = complex(ham.paulis[counter][0]) pauli_list[counter] = WeightedPauliOperator.from_list([pauli]) else: if ham_list[0][num_qubits + 1:-1] == '0': name_list[0] = 'I' * num_qubits weight_list[0] = complex(0) pauli_list[0] = 0 * WeightedPauliOperator.from_list( paulis=[Pauli.from_label('I' * num_qubits)]) else: pauli = Pauli.from_label(ham_list[0][:num_qubits]) name_list[0] = ham_list[0][:num_qubits] weight_list[0] = complex(ham.paulis[0][0]) pauli_list[0] = WeightedPauliOperator.from_list([pauli]) return weight_list, pauli_list, name_list
def test_evolve(self, expansion_mode, evo_time, num_time_slices): expansion_orders = [1, 2, 3, 4] if expansion_mode == 'suzuki' else [1] num_qubits = 2 paulis = [ Pauli.from_label(pauli_label) for pauli_label in itertools.product('IXYZ', repeat=num_qubits) ] weights = np.random.random(len(paulis)) pauli_op = WeightedPauliOperator.from_list(paulis, weights) matrix_op = op_converter.to_matrix_operator(pauli_op) state_in = Custom(num_qubits, state='random') # get the exact state_out from raw matrix multiplication state_out_exact = matrix_op.evolve( state_in=state_in.construct_circuit('vector'), evo_time=evo_time, num_time_slices=0) # self.log.debug('exact:\n{}'.format(state_out_exact)) self.log.debug('Under {} expansion mode:'.format(expansion_mode)) for expansion_order in expansion_orders: # assure every time the operator from the original one if expansion_mode == 'suzuki': self.log.debug( 'With expansion order {}:'.format(expansion_order)) state_out_matrix = matrix_op.evolve( state_in=state_in.construct_circuit('vector'), evo_time=evo_time, num_time_slices=num_time_slices, expansion_mode=expansion_mode, expansion_order=expansion_order) quantum_registers = QuantumRegister(pauli_op.num_qubits, name='q') qc = QuantumCircuit(quantum_registers) qc += state_in.construct_circuit('circuit', quantum_registers) qc += pauli_op.copy().evolve( evo_time=evo_time, num_time_slices=num_time_slices, quantum_registers=quantum_registers, expansion_mode=expansion_mode, expansion_order=expansion_order, ) state_out_circuit = self.quantum_instance_statevector.execute( qc).get_statevector(qc) self.log.debug( 'The fidelity between exact and matrix: {}'.format( state_fidelity(state_out_exact, state_out_matrix))) self.log.debug( 'The fidelity between exact and circuit: {}'.format( state_fidelity(state_out_exact, state_out_circuit))) f_mc = state_fidelity(state_out_matrix, state_out_circuit) self.log.debug( 'The fidelity between matrix and circuit: {}'.format(f_mc)) self.assertAlmostEqual(f_mc, 1)
def setUp(self): super().setUp() seed = 0 aqua_globals.random_seed = seed self.num_qubits = 2 m_size = np.power(2, self.num_qubits) matrix = aqua_globals.random.rand(m_size, m_size) self.mat_op = MatrixOperator(matrix=matrix) paulis = [Pauli.from_label(pauli_label) for pauli_label in itertools.product('IXYZ', repeat=self.num_qubits)] weights = aqua_globals.random.random_sample(len(paulis)) self.pauli_op = WeightedPauliOperator.from_list(paulis, weights)
def test_from_to_file(self): """ from to file test """ paulis = [Pauli.from_label(x) for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY']] weights = [0.2 + -1j * 0.8, 0.6 + -1j * 0.6, 0.8 + -1j * 0.2, -0.2 + -1j * 0.8, -0.6 - -1j * 0.6, -0.8 - -1j * 0.2] op = WeightedPauliOperator.from_list(paulis, weights) file_path = self._get_resource_path('temp_op.json') op.to_file(file_path) self.assertTrue(os.path.exists(file_path)) load_op = WeightedPauliOperator.from_file(file_path) self.assertEqual(op, load_op) os.remove(file_path)
def test_instruction() -> None: # TKET-446 qreg = QuantumRegister(3) paulis = list(map(Pauli.from_label, ["XXI", "YYI", "ZZZ"])) weights = [0.3, 0.5 + 1j * 0.2, -0.4] op = WeightedPauliOperator.from_list(paulis, weights) evolution_circ = op.evolve(None, 1.2, num_time_slices=1, quantum_registers=qreg) tk_circ = qiskit_to_tk(evolution_circ) cmds = tk_circ.get_commands() assert len(cmds) == 1 assert cmds[0].op.type == OpType.CircBox
def retrieve_op_list(number, rev = False, num_qubits = 4): adapt_op_df = pd.read_csv('load_adapt_roto_2_op_df.csv') adapt_op_dict = adapt_op_df.to_dict() op_label_list = list(adapt_op_dict['Ham_{}'.format(number)]) op_list = [] for label in op_label_list: op_name = adapt_op_dict['Ham_{}'.format(number)][label] print(op_name) op = Pauli.from_label(op_name[:num_qubits]) op = WeightedPauliOperator.from_list([op]) op_list.append(op) if rev: return reverse(op_list) return op_list
def retrieve_ham(number, num_qubits = 4): adapt_data_df = pd.read_csv('load_adapt_roto_2_data_df.csv') adapt_data_dict = adapt_data_df.to_dict() Ham_list = adapt_data_dict['hamiltonian'] Ham = Ham_list[number] single_ham_list = Ham.split('\n') pauli_list = [0]*(len(single_ham_list)-1) weight_list = [0]*(len(single_ham_list)-1) for counter2 in range(0, len(single_ham_list)-1,1): pauli_list[counter2] = Pauli.from_label(single_ham_list[counter2][:num_qubits]) weight_list[counter2] = complex(single_ham_list[counter2][num_qubits:]) qubit_op = WeightedPauliOperator.from_list(pauli_list,weight_list) return qubit_op
def test_chop_real(self): """ chop real test """ paulis = [Pauli(x) for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY']] coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8] op = WeightedPauliOperator.from_list(paulis, coeffs) ori_op = op.copy() for threshold, num_paulis in zip([0.4, 0.7, 0.9], [4, 2, 0]): op = ori_op.copy() op1 = op.chop(threshold=threshold, copy=True) self.assertEqual(len(op.paulis), 6, "\n{}".format(op.print_details())) self.assertEqual(len(op1.paulis), num_paulis, "\n{}".format(op1.print_details())) op1 = op.chop(threshold=threshold, copy=False) self.assertEqual(len(op.paulis), num_paulis, "\n{}".format(op.print_details())) self.assertEqual(len(op1.paulis), num_paulis, "\n{}".format(op1.print_details()))
def first_vqe_kwargs(self) -> Dict: # This works for now, but always produces one extra parameter. -George, so we'll need to change this for rotoadapt too. id_op = WeightedPauliOperator.from_list(paulis=[Pauli.from_label('I' * self.operator_pool.num_qubits)], weights=[1.0]) var_form = self.variational_form([id_op]) self._operator_selector._quantum_instance = self.quantum_instance return { 'operator': self.hamiltonian, 'var_form': var_form, 'optimizer': DummyOptimizer(), 'initial_point': np.array([np.pi]), 'max_evals_grouped': self.max_evals_grouped, 'aux_operators': self.aux_operators, 'callback': self.callback, 'auto_conversion': self.auto_conversion }
def test_unsorted_grouping(self): """Test with normal grouping approach.""" num_qubits = 4 paulis = [Pauli.from_label(pauli_label) for pauli_label in itertools.product('IXYZ', repeat=num_qubits)] weights = aqua_globals.random.random_sample(len(paulis)) op = WeightedPauliOperator.from_list(paulis, weights) grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator( op, TPBGroupedWeightedPauliOperator.unsorted_grouping) for g_p in grouped_op.paulis: passed = False for pauli in op.paulis: if pauli[1] == g_p[1]: passed = pauli[0] == g_p[0] break self.assertTrue(passed, "non-existed paulis in grouped_paulis: {}".format(g_p[1].to_label())) self.assertGreaterEqual(len(op.basis), len(grouped_op.basis))
def test_evaluate_single_pauli_statevector(self): """ evaluate single pauli statevector test """ # X op = WeightedPauliOperator.from_list([Pauli.from_label('X')]) qr = QuantumRegister(1, name='q') wave_function = QuantumCircuit(qr) # + 1 eigenstate wave_function.h(qr[0]) circuits = op.construct_evaluation_circuit(wave_function=wave_function, statevector_mode=True) result = self.quantum_instance_statevector.execute(circuits) actual_value = op.evaluate_with_result(result=result, statevector_mode=True) self.assertAlmostEqual(1.0, actual_value[0].real, places=5) # - 1 eigenstate wave_function = QuantumCircuit(qr) wave_function.x(qr[0]) wave_function.h(qr[0]) circuits = op.construct_evaluation_circuit(wave_function=wave_function, statevector_mode=True) result = self.quantum_instance_statevector.execute(circuits) actual_value = op.evaluate_with_result(result=result, statevector_mode=True) self.assertAlmostEqual(-1.0, actual_value[0].real, places=5) # Y op = WeightedPauliOperator.from_list([Pauli.from_label('Y')]) qr = QuantumRegister(1, name='q') wave_function = QuantumCircuit(qr) # + 1 eigenstate wave_function.h(qr[0]) wave_function.s(qr[0]) circuits = op.construct_evaluation_circuit(wave_function=wave_function, statevector_mode=True) result = self.quantum_instance_statevector.execute(circuits) actual_value = op.evaluate_with_result(result=result, statevector_mode=True) self.assertAlmostEqual(1.0, actual_value[0].real, places=5) # - 1 eigenstate wave_function = QuantumCircuit(qr) wave_function.x(qr[0]) wave_function.h(qr[0]) wave_function.s(qr[0]) circuits = op.construct_evaluation_circuit(wave_function=wave_function, statevector_mode=True) result = self.quantum_instance_statevector.execute(circuits) actual_value = op.evaluate_with_result(result=result, statevector_mode=True) self.assertAlmostEqual(-1.0, actual_value[0].real, places=5) # Z op = WeightedPauliOperator.from_list([Pauli.from_label('Z')]) qr = QuantumRegister(1, name='q') wave_function = QuantumCircuit(qr) # + 1 eigenstate circuits = op.construct_evaluation_circuit(wave_function=wave_function, statevector_mode=True) result = self.quantum_instance_statevector.execute(circuits) actual_value = op.evaluate_with_result(result=result, statevector_mode=True) self.assertAlmostEqual(1.0, actual_value[0].real, places=5) # - 1 eigenstate wave_function = QuantumCircuit(qr) wave_function.x(qr[0]) circuits = op.construct_evaluation_circuit(wave_function=wave_function, statevector_mode=True) result = self.quantum_instance_statevector.execute(circuits) actual_value = op.evaluate_with_result(result=result, statevector_mode=True) self.assertAlmostEqual(-1.0, actual_value[0].real, places=5)
adapt_data_df = pd.read_csv('load_adapt_data_df.csv') adapt_data_dict = adapt_data_df.to_dict() Ham_list = adapt_data_dict['hamiltonian'] counter = 0 counter2 = 0 num_hams = 10 pauli_meta_list = [0]*num_hams weight_meta_list = [0]*num_hams Exact_energy_dict = {'Ham_1':[],'Ham_2':[],'Ham_3':[],'Ham_4':[],'Ham_5':[],'Ham_6':[],'Ham_7':[],'Ham_8':[],'Ham_9':[]} for counter in range(0,num_hams,1): Ham = Ham_list[counter] single_ham_list = Ham.split('\n') pauli_list = [0]*(len(single_ham_list)-1) weight_list = [0]*(len(single_ham_list)-1) for counter2 in range(0, len(single_ham_list)-1,1): pauli_list[counter2] = Pauli.from_label(single_ham_list[counter2][:4]) weight_list[counter2] = complex(single_ham_list[counter2][6:-1]) pauli_meta_list[counter] = pauli_list weight_meta_list[counter] = weight_list qubit_op = WeightedPauliOperator.from_list(pauli_list,weight_list) Exact_result = ExactEigensolver(qubit_op, k = 16).run() Exact_energy_dict['Ham_{}'.format(counter)] = Exact_result['energies'] print('E', Exact_result) Exact_energy_df = pd.DataFrame(Exact_energy_dict) Exact_energy_df_file = open("exact_energy_df.csv", "w+") Exact_energy_df.to_csv('exact_energy_df.csv') Exact_energy_df_file.close()
exact_dict = {'2': [], '3': [], '4': [], '5': [], '6': [], '7': [], '8': [], '9': [], '10': []} num_qubits = 4 #test = random_diagonal_hermitian(2) #print(test.print_details()) #mat = to_matrix_operator(test) #print(mat.print_details()) for i in range(0,1): k = 0 runtime_sum = 0 exact_time_sum = 0 vqeruntime_sum = 0 print('num_qubits', num_qubits) while k < runs: initial_state = Zero(num_qubits) op_list = [] wop = 0*WeightedPauliOperator.from_list(paulis=[Pauli.from_label('I'*num_qubits)], weights=[1.0]) #mat = np.random.uniform(0, 1, size=(2**num_qubits, 2**num_qubits)) + 1j * np.random.uniform(0, 1, size=(2**num_qubits, 2**num_qubits)) #mat = np.conjugate(np.transpose(mat)) + mat #ham = to_weighted_pauli_operator(MatrixOperator(mat)) #creates random hamiltonian from random matrix "mat" ham = get_h_4_hamiltonian(0.25, 2, "jw") #ham = retrieve_ham(0, num_qubits = num_qubits) print('old_ham', ham.print_details()) #ham = get_h_4_hamiltonian(0.5,2,'jw') #op_list = retrieve_op_list(0, rev = True, num_qubits = num_qubits) #for op in op_list: # print(op.print_details()) op_list = [WeightedPauliOperator.from_list([Pauli.from_label('IIXX')]), WeightedPauliOperator.from_list([Pauli.from_label('XXXY')])] #op_list = [WeightedPauliOperator.from_list([Pauli.from_label('YYZZ')],[1.0]), # WeightedPauliOperator.from_list([Pauli.from_label('XXXY')], [1.0]), # WeightedPauliOperator.from_list([Pauli.from_label('IIYZ')], [1.0])]