def test_measurement_error_mitigation(self): aqua_globals.random_seed = 0 # build noise model noise_model = noise.NoiseModel() read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]]) noise_model.add_all_qubit_readout_error(read_err) backend = Aer.get_backend('qasm_simulator') quantum_instance = QuantumInstance(backend=backend, seed=167, seed_transpiler=167, noise_model=noise_model) quantum_instance_with_mitigation = QuantumInstance(backend=backend, seed=167, seed_transpiler=167, noise_model=noise_model, measurement_error_mitigation_cls=CompleteMeasFitter) input = 'a & b & c' oracle = LogicalExpressionOracle(input, optimization='off') grover = Grover(oracle) result_wo_mitigation = grover.run(quantum_instance) prob_top_measurement_wo_mitigation = result_wo_mitigation['measurement'][ result_wo_mitigation['top_measurement']] result_w_mitigation = grover.run(quantum_instance_with_mitigation) prob_top_measurement_w_mitigation = result_w_mitigation['measurement'][result_w_mitigation['top_measurement']] self.assertGreaterEqual(prob_top_measurement_w_mitigation, prob_top_measurement_wo_mitigation)
def test_measurement_error_mitigation_auto_refresh(self): aqua_globals.random_seed = 0 # build noise model noise_model = noise.NoiseModel() read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]]) noise_model.add_all_qubit_readout_error(read_err) backend = Aer.get_backend('qasm_simulator') quantum_instance = QuantumInstance(backend=backend, seed=1679, seed_transpiler=167, noise_model=noise_model, measurement_error_mitigation_cls=CompleteMeasFitter, cals_matrix_refresh_period=0) input = 'a & b & c' oracle = LogicalExpressionOracle(input, optimization='off') grover = Grover(oracle) _ = grover.run(quantum_instance) cals_matrix_1 = quantum_instance.cals_matrix.copy() time.sleep(15) aqua_globals.random_seed = 2 quantum_instance.set_config(seed=111) _ = grover.run(quantum_instance) cals_matrix_2 = quantum_instance.cals_matrix.copy() diff = cals_matrix_1 - cals_matrix_2 total_diff = np.sum(np.abs(diff)) self.assertGreater(total_diff, 0.0)
def test_measurement_error_mitigation(self): try: from qiskit import Aer from qiskit.providers.aer import noise except Exception as e: self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(e))) return aqua_globals.random_seed = 0 # build noise model noise_model = noise.NoiseModel() read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]]) noise_model.add_all_qubit_readout_error(read_err) backend = Aer.get_backend('qasm_simulator') quantum_instance = QuantumInstance(backend=backend, seed_simulator=167, seed_transpiler=167, noise_model=noise_model) quantum_instance_with_mitigation = QuantumInstance(backend=backend, seed_simulator=167, seed_transpiler=167, noise_model=noise_model, measurement_error_mitigation_cls=CompleteMeasFitter) input = 'a & b & c' oracle = LogicalExpressionOracle(input) grover = Grover(oracle) result_wo_mitigation = grover.run(quantum_instance) prob_top_measurement_wo_mitigation = result_wo_mitigation['measurement'][ result_wo_mitigation['top_measurement']] result_w_mitigation = grover.run(quantum_instance_with_mitigation) prob_top_measurement_w_mitigation = result_w_mitigation['measurement'][result_w_mitigation['top_measurement']] self.assertGreaterEqual(prob_top_measurement_w_mitigation, prob_top_measurement_wo_mitigation)
def test_measurement_error_mitigation_with_dedicated_shots(self): from qiskit import Aer from qiskit.providers.aer import noise aqua_globals.random_seed = 0 # build noise model noise_model = noise.NoiseModel() read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]]) noise_model.add_all_qubit_readout_error(read_err) backend = Aer.get_backend('qasm_simulator') quantum_instance = QuantumInstance(backend=backend, seed_simulator=1679, seed_transpiler=167, shots=100, noise_model=noise_model, measurement_error_mitigation_cls=CompleteMeasFitter, cals_matrix_refresh_period=0) input = 'a & b & c' oracle = LogicalExpressionOracle(input) grover = Grover(oracle) _ = grover.run(quantum_instance) cals_matrix_1, timestamp_1 = quantum_instance.cals_matrix(qubit_index=[0, 1, 2]) quantum_instance.measurement_error_mitigation_shots = 1000 _ = grover.run(quantum_instance) cals_matrix_2, timestamp_2 = quantum_instance.cals_matrix(qubit_index=[0, 1, 2]) diff = cals_matrix_1 - cals_matrix_2 total_diff = np.sum(np.abs(diff)) self.assertGreater(total_diff, 0.0) self.assertGreater(timestamp_2, timestamp_1)
def test_iterations(self): """Test the iterations argument""" grover = Grover(oracle=self._oracle, good_state=['111'], iterations=2) ret = grover.run(self._sv) self.assertTrue(Operator(ret['circuit']).equiv(Operator(self._expected))) grover = Grover(oracle=self._oracle, good_state=['111'], iterations=[1, 2, 3]) ret = grover.run(self._sv) self.assertTrue(ret.oracle_evaluation) self.assertIn(ret.top_measurement, ['111'])
def test_measurement_error_mitigation_auto_refresh(self): """ measurement error mitigation auto refresh test """ try: # pylint: disable=import-outside-toplevel from qiskit import Aer from qiskit.providers.aer import noise except ImportError as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return aqua_globals.random_seed = 0 # build noise model noise_model = noise.NoiseModel() read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]]) noise_model.add_all_qubit_readout_error(read_err) backend = Aer.get_backend('qasm_simulator') quantum_instance = QuantumInstance( backend=backend, seed_simulator=1679, seed_transpiler=167, noise_model=noise_model, measurement_error_mitigation_cls=CompleteMeasFitter, cals_matrix_refresh_period=0) oracle = LogicalExpressionOracle('a & b & c') grover = Grover(oracle) _ = grover.run(quantum_instance) self.assertGreater(quantum_instance.time_taken, 0.) quantum_instance.reset_execution_results() cals_matrix_1, timestamp_1 = quantum_instance.cals_matrix( qubit_index=[0, 1, 2]) time.sleep(15) aqua_globals.random_seed = 2 quantum_instance.set_config(seed_simulator=111) _ = grover.run(quantum_instance) cals_matrix_2, timestamp_2 = quantum_instance.cals_matrix( qubit_index=[0, 1, 2]) diff = cals_matrix_1 - cals_matrix_2 total_diff = np.sum(np.abs(diff)) self.assertGreater(total_diff, 0.0) self.assertGreater(timestamp_2, timestamp_1)
def grovers_search(dictionary): oracle = LogicalExpressionOracle(dictionary["expression"]) quantum_instance = QuantumInstance(dictionary["quantum_instance"], shots=dictionary["shots"]) grover = Grover(oracle) result = grover.run(quantum_instance) return result
def test_grover(self, input, sol, oracle_cls, mct_mode, simulator, optimization='off'): self.groundtruth = sol if optimization == 'off': oracle = oracle_cls(input, optimization='off') else: oracle = oracle_cls( input, optimization='qm-dlx' if oracle_cls == TTO else 'espresso') grover = Grover(oracle, incremental=True, mct_mode=mct_mode) backend = BasicAer.get_backend(simulator) quantum_instance = QuantumInstance(backend, shots=1000) ret = grover.run(quantum_instance) self.log.debug('Ground-truth Solutions: {}.'.format(self.groundtruth)) self.log.debug('Top measurement: {}.'.format( ret['top_measurement'])) if ret['oracle_evaluation']: self.assertIn(ret['top_measurement'], self.groundtruth) self.log.debug('Search Result: {}.'.format(ret['result'])) else: self.assertEqual(self.groundtruth, []) self.log.debug('Nothing found.')
def test_readme_sample(self): """ readme sample test """ # pylint: disable=import-outside-toplevel # --- Exact copy of sample code ---------------------------------------- from qiskit import Aer from qiskit.aqua.components.oracles import LogicalExpressionOracle from qiskit.aqua.algorithms import Grover sat_cnf = """ c Example DIMACS 3-sat p cnf 3 5 -1 -2 -3 0 1 -2 3 0 1 2 -3 0 1 -2 -3 0 -1 2 3 0 """ backend = Aer.get_backend('qasm_simulator') oracle = LogicalExpressionOracle(sat_cnf) algorithm = Grover(oracle) result = algorithm.run(backend) print(result["result"]) # ---------------------------------------------------------------------- valid_set = [[-1, -2, -3], [1, -2, 3], [1, 2, -3]] found = result['result'] in valid_set self.assertTrue(found, "Result {} is not in valid set {}". format(result['result'], valid_set))
def grover_with_custom_circuit(number_of_qibits): """ This function is used to run the minimum search with grover's algorithm. It does everything but work. It creates a reversible boolean oracle function using the same function that the grover_with_logical_expression but for some reason the CustomCircuitOracle never marks anything. Sometimes it will get luck and the top measure will be the smallest valued index but don't let that fool you. :param number_of_qibits: log_2(n) of the number of indexes in N :return: the results of the search """ qreg = QuantumRegister(number_of_qibits) output = QuantumRegister(number_of_qibits) # qc = QuantumCircuit(qreg, output) # qc.z([0, 1, 2, 3]) # qc.cz(0, 3) # qc.h([0, 1, 2, 3]) # for i in range(number_of_qibits): # qc.h(qreg[i]) qc = QuantumCircuit(qreg, output, name='oracle') circuit_oracle = CustomCircuitOracle(variable_register=qreg, output_register=output, circuit=qc, evaluate_classically_callback=f_L) grover = Grover(oracle=circuit_oracle) draw: Figure = grover.grover_operator.draw(output='mpl') draw.savefig('custom_circuit_grover.png') result = grover.run( QuantumInstance(BasicAer.get_backend('qasm_simulator'), shots=2048)) return result
def test_measurement_error_mitigation(self): """ measurement error mitigation test """ try: # pylint: disable=import-outside-toplevel from qiskit import Aer from qiskit.providers.aer import noise except ImportError as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return aqua_globals.random_seed = 0 # build noise model noise_model = noise.NoiseModel() read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]]) noise_model.add_all_qubit_readout_error(read_err) backend = Aer.get_backend('qasm_simulator') quantum_instance = QuantumInstance(backend=backend, seed_simulator=167, seed_transpiler=167, noise_model=noise_model) qi_with_mitigation = \ QuantumInstance(backend=backend, seed_simulator=167, seed_transpiler=167, noise_model=noise_model, measurement_error_mitigation_cls=CompleteMeasFitter) oracle = LogicalExpressionOracle('a & b & c') grover = Grover(oracle) result_wo_mitigation = grover.run(quantum_instance) self.assertGreater(quantum_instance.time_taken, 0.) quantum_instance.reset_execution_results() prob_top_meas_wo_mitigation = result_wo_mitigation.measurement[ result_wo_mitigation.top_measurement] result_w_mitigation = grover.run(qi_with_mitigation) prob_top_meas_w_mitigation = \ result_w_mitigation.measurement[result_w_mitigation.top_measurement] self.assertGreaterEqual(prob_top_meas_w_mitigation, prob_top_meas_wo_mitigation)
def test_run_circuit_oracle(self): """Test execution with a quantum circuit oracle""" oracle = QuantumCircuit(2) oracle.cz(0, 1) list_good_state = ["11"] grover = Grover(oracle=oracle, good_state=list_good_state) ret = grover.run(self._qasm) self.assertIn(ret['top_measurement'], list_good_state)
def test_run_grover_operator_oracle(self): """Test execution with a grover operator oracle""" oracle = QuantumCircuit(2) oracle.cz(0, 1) grover_op = GroverOperator(oracle) grover = Grover(oracle=grover_op.oracle, grover_operator=grover_op, good_state=["11"]) ret = grover.run(self._qasm) self.assertIn(ret['top_measurement'], ['11'])
def test_old_signature(self): """Test the old signature without naming arguments works.""" oracle = TTO('0001') circuit = QuantumCircuit(2) circuit.h([0, 1]) init_state = Custom(2, circuit=circuit) backend = BasicAer.get_backend('statevector_simulator') grover = Grover(oracle, init_state, True, 10, 1.44, ROTATION_COUNTS[1], 'noancilla', backend) ret = grover.run() self.assertEqual(ret.top_measurement, '11')
def test_using_grover_for_ccx(self): """ using grover correctly (with the evaluate_classically callback provided) """ q_v = QuantumRegister(2, name='v') q_o = QuantumRegister(1, name='o') circuit = QuantumCircuit(q_v, q_o) circuit.ccx(q_v[0], q_v[1], q_o[0]) oracle = CustomCircuitOracle(variable_register=q_v, output_register=q_o, circuit=circuit, evaluate_classically_callback=lambda m: (m == '11', [1, 2])) algorithm = Grover(oracle) result = algorithm.run( quantum_instance=QuantumInstance(BasicAer.get_backend('qasm_simulator'))) self.assertEqual(result['result'], [1, 2])
def test_grover(self, dimacs_file, incremental, num_iterations, mct_mode, simulator, optimization='off'): dimacs_file = self._get_resource_path(dimacs_file) # get ground-truth with open(dimacs_file) as f: buf = f.read() if incremental: self.log.debug( 'Testing incremental Grover search on SAT problem instance: \n{}' .format(buf, )) else: self.log.debug( 'Testing Grover search with {} iteration(s) on SAT problem instance: \n{}' .format( num_iterations, buf, )) header = buf.split('\n')[0] self.assertGreaterEqual(header.find('solution'), 0, 'Ground-truth info missing.') self.groundtruth = [ ''.join([ '1' if i > 0 else '0' for i in sorted( [int(v) for v in s.strip().split() if v != '0'], key=abs) ])[::-1] for s in header.split('solutions:' if header.find( 'solutions:') >= 0 else 'solution:')[-1].split(',') ] backend = get_aer_backend(simulator) oracle = LogicExpressionOracle(buf, optimization=optimization) grover = Grover(oracle, num_iterations=num_iterations, incremental=incremental, mct_mode=mct_mode) run_config = RunConfig(shots=1000, max_credits=10, memory=False) quantum_instance = QuantumInstance(backend, run_config) ret = grover.run(quantum_instance) self.log.debug('Ground-truth Solutions: {}.'.format(self.groundtruth)) self.log.debug('Top measurement: {}.'.format( ret['top_measurement'])) if ret['oracle_evaluation']: self.assertIn(ret['top_measurement'], self.groundtruth) self.log.debug('Search Result: {}.'.format(ret['result'])) else: self.assertEqual(self.groundtruth, ['']) self.log.debug('Nothing found.')
def test_num_iteration(self): """Test specified num_iterations""" # filtering the following: # DeprecationWarning: The num_iterations argument is deprecated as of 0.8.0, # and will be removed no earlier than 3 months after the release date. # If you want to use the num_iterations argument you should use the iterations # argument instead and pass an integer for the number of iterations. try: warnings.filterwarnings(action="ignore", category=DeprecationWarning) grover = Grover(oracle=self._oracle, good_state=['111'], num_iterations=2) finally: warnings.filterwarnings(action="always", category=DeprecationWarning) ret = grover.run(self._sv) self.assertTrue(Operator(ret['circuit']).equiv(Operator(self._expected)))
def call_grover(truth_map: str, num_vertices: int, shots=1024) -> dict: """Call the simulation for grover's algorithm with the truth map and time its execution :param truth_map: The string bitmap :param num_vertices: Number of vertices of the graph for documentation purposes :return: the GroverResult item """ start = time() oracle = TruthTableOracle(truth_map) grover = Grover(oracle) # Wow that's nice that this already exists result = grover.run( QuantumInstance(BasicAer.get_backend('qasm_simulator'), shots=shots)) end = time() print('Grover\'s search on n = {} vertices:\nTime elapsed: {}s\n'.format( num_vertices, end - start)) return result
def test_grover(self, input_test, sol, oracle_cls, mct_mode, simulator, optimization): """ grover test """ groundtruth = sol oracle = oracle_cls(input_test, optimization=optimization) grover = Grover(oracle, incremental=True, mct_mode=mct_mode) backend = BasicAer.get_backend(simulator) quantum_instance = QuantumInstance(backend, shots=1000) ret = grover.run(quantum_instance) self.log.debug('Ground-truth Solutions: %s.', groundtruth) self.log.debug('Top measurement: %s.', ret['top_measurement']) if ret['oracle_evaluation']: self.assertIn(ret['top_measurement'], groundtruth) self.log.debug('Search Result: %s.', ret['result']) else: self.assertEqual(groundtruth, []) self.log.debug('Nothing found.')
def test_readme_sample(self): """ readme sample test """ # pylint: disable=import-outside-toplevel,redefined-builtin def print(*args): """ overloads print to log values """ if args: self.log.debug(args[0], *args[1:]) # --- Exact copy of sample code ---------------------------------------- from qiskit import Aer from qiskit.aqua.components.oracles import LogicalExpressionOracle from qiskit.aqua.algorithms import Grover sat_cnf = """ c Example DIMACS 3-sat p cnf 3 5 -1 -2 -3 0 1 -2 3 0 1 2 -3 0 1 -2 -3 0 -1 2 3 0 """ backend = Aer.get_backend('qasm_simulator') oracle = LogicalExpressionOracle(sat_cnf) algorithm = Grover(oracle) result = algorithm.run(backend) print(result.assignment) # ---------------------------------------------------------------------- valid_set = [[-1, -2, -3], [1, -2, 3], [1, 2, -3]] found = result.assignment in valid_set self.assertTrue( found, "Result {} is not in valid set {}".format(result.assignment, valid_set))
def grover_with_logical_expression(): """ This function is used to run the minimum search with grover's algorithm with the logical expression oracle. This one does work sometimes. I noticed at one point that the inverse of the correct bits were getting marked i.e. if index 3(0011) was supposed to be marked, then 12(1100) was getting marked. I never figured out what was going on here which is the such as for 0011 to be marked as opposed to 1100. I dug down deep into qiskit oracle source code and found nothing that would suggest the order of the bits are expected to be flipped. Probably something small that I've look at 100 times and thought that it was correct. :param number_of_qibits: log_2(n) of the number of indexes in N :return: the results of the search """ expression = get_boolean_functions_from_truth_table_logical_oracle() oracle = LogicalExpressionOracle(expression=expression, optimization=True, mct_mode='noancilla') grover = Grover(oracle=oracle) draw: Figure = grover.grover_operator.draw(output='mpl') draw.savefig('logical_expression_grover.png') return grover.run( QuantumInstance(BasicAer.get_backend('qasm_simulator'), shots=2048))
def solve(self): constraints = "" index = [] for i in range(self.N): c = self.chopsticks[i] next_c = self.chopsticks[(i+1) % self.N] if (i > 0): constraints += ' & ' constraints += exactly1(c + '_R', c + '_L') constraints += ' & ' constraints += exactly1(c + '_R', next_c + '_L') if i % 2 == 0: index.append(c + '_R') index.append(c + '_L') else: index.append(c + '_L') index.append(c + '_R') backend = Aer.get_backend('qasm_simulator') #IBMQ.load_account() #backend = IBMQ.get_backend('ibmq_16_melbourne') print(backend.configuration()) oracle = logical_expression_oracle.LogicalExpressionOracle( constraints) #, mct_mode='advanced', optimization='espresso') algorithm = Grover(oracle) result = algorithm.run(backend) hist = plot_histogram(result["measurement"], title='measurement distribution') hist.show() hist.savefig('qiskit.png') print(index) print(result["result"]) for r in (result["result"]): i = abs(r) - 1 if r < 0: print('~' + index[i]) else: print(index[i])
from qiskit import Aer from qiskit.aqua.components.oracles import LogicalExpressionOracle from qiskit.aqua.algorithms import Grover sat_cnf = """ c Example DIMACS 3-sat p cnf 3 5 -1 -2 -3 0 1 -2 3 0 1 2 -3 0 1 -2 -3 0 -1 2 3 0 """ backend = Aer.get_backend('qasm_simulator') oracle = LogicalExpressionOracle(sat_cnf) algorithm = Grover(oracle) result = algorithm.run(backend) print(result["result"])
import numpy as np from qiskit import BasicAer from qiskit.aqua import QuantumInstance, run_algorithm from qiskit.aqua.algorithms import Grover from qiskit.aqua.components.oracles import LogicalExpressionOracle, TruthTableOracle input_3sat = ''' c example DIMACS-CNF 3-SAT p cnf 3 5 -1 -2 -3 0 1 -2 3 0 1 2 -3 0 1 -2 -3 0 -1 2 3 0 ''' oracle = LogicalExpressionOracle(input_3sat) grover = Grover(oracle) backend = BasicAer.get_backend('qasm_simulator') quantum_instance = QuantumInstance(backend, shots=1024) result = grover.run(quantum_instance) print(result['measurement'])
from qiskit import Aer from qiskit.aqua.components.oracles import LogicalExpressionOracle from qiskit.aqua.algorithms import Grover sat_cnf = """ c Example DIMACS 3-sat p cnf 3 5 -1 -2 -3 0 1 -2 3 0 1 2 -3 0 1 -2 -3 0 -1 2 3 0 """ backend = Aer.get_backend('qasm_simulator') oracle = LogicalExpressionOracle(sat_cnf) algorithm = Grover(oracle) assignment = algorithm.run(backend) print(assignment["assignment"])
def dinner_party_using_grover(): # This algorithm will solve the dinner party problem, where you want to invite friends to a dinner party, but # not all fit to each other. This results in a logical expression (D can with meet with A or C can meet with B # but A and B do not want to meet. # The algorithm will use Grover's algorithm to solve this problem. # NOTICE: to execute even a small number of elements, the algorithm will need at least 11 qubits # which most IBMQ backends don't provide. # Here an overview of an example: # Example Table for a simple expression: log_expr = '((D & A) | (C & B)) & ~(A & B)' # D | C | B | A | Result # - - - - - - - - - - - - # 0 | 0 | 0 | 0 | 0 # 1 | 0 | 0 | 0 | 0 # 0 | 1 | 0 | 0 | 0 # 1 | 1 | 0 | 0 | 0 # 0 | 0 | 1 | 0 | 0 # 1 | 0 | 1 | 0 | 0 # 0 | 1 | 1 | 0 | 1 # 1 | 1 | 1 | 0 | 1 # 0 | 0 | 0 | 1 | 0 # 1 | 0 | 0 | 1 | 1 # 0 | 1 | 0 | 1 | 0 # 1 | 1 | 0 | 1 | 1 # 0 | 0 | 1 | 1 | 0 # 1 | 0 | 1 | 1 | 0 # 0 | 1 | 1 | 1 | 0 # 1 | 1 | 1 | 1 | 0 # In the later plot results are organized alphabetically # starting with the least significant bit (...1 = A; ..1. = B; .1.. = C; 1... = D; and so on) # Example: 0110 shows the probability B and C would be a possible combination from qiskit.aqua.algorithms import Grover from qiskit.aqua.components.oracles import LogicalExpressionOracle from qiskit.tools.visualization import plot_histogram # Logical Expressions which can be used for the LogicalExpressionOracle: & = and; | = or; ~ = not; ^ = xor log_expr = '((D & A) | (C & B)) & ~(A & B)' dinner_calculator = Grover(LogicalExpressionOracle(log_expr)) # Execute the dinner_calculator # Max 4 qubits can be used on a Quantum Computer right now (+1 scratch qubit, so in total 5) trys = 1024 qubits = None ibmq = False required_backend = None print("Execute the following command:") print(" Number of trys: " + str(trys)) print(" Number of qubits: " + str(qubits)) print(" IBMQ Backend Required: " + str(ibmq)) print(" Specific IBMQ Backend Required: " + str(required_backend)) quantum_instance = get_quantumcomputer_quantum_instance(trys, qubits, ibmq, required_backend) dinner_result = dinner_calculator.run(quantum_instance) if quantum_instance.is_simulator: print("As a simulator was selected, no job monitor will be shown.") else: print("Running on IBMQ") print(job_monitor(dinner_result)) # Plot the final Histrogram plot_histogram(dinner_result['measurement'], title="Possible Party Combinations")
def test_num_iteration(self): """Test specified num_iterations""" grover = Grover(oracle=self._oracle, good_state=['111'], num_iterations=2) ret = grover.run(self._sv) self.assertTrue(Operator(ret['circuit']).equiv(Operator(self._expected)))
def test_run_state_vector_oracle(self): """Test execution with a state vector oracle""" mark_state = Statevector.from_label('11') grover = Grover(oracle=mark_state, good_state=['11']) ret = grover.run(self._qasm) self.assertIn(ret['top_measurement'], ['11'])