def create_grover(oracle_type, oracle_method): # Build the circuit if oracle_method=="log": algorithm = Grover(LogicalExpressionOracle(oracle_type),num_iterations=num_iterations) oracle_circuit = Grover(LogicalExpressionOracle(oracle_type)).construct_circuit() else: algorithm = Grover(TruthTableOracle(oracle_type),num_iterations=num_iterations) oracle_circuit = Grover(TruthTableOracle(oracle_type)).construct_circuit() display(oracle_circuit.draw(output="mpl")) display(algorithm) return(algorithm)
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 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_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_logic_expr_oracle(self, dimacs_str, sols, mct_mode, optimization): """ Logic Expr oracle test """ num_shots = 1024 leo = LogicalExpressionOracle(dimacs_str, optimization=optimization, mct_mode=mct_mode) leo_circuit = leo.circuit m = ClassicalRegister(1, name='m') for assignment in itertools.product([True, False], repeat=len(leo.variable_register)): qc = QuantumCircuit(m, leo.variable_register) for idx, t_f in enumerate(assignment): if t_f: qc.x(leo.variable_register[idx]) qc += leo_circuit qc.barrier(leo.output_register) qc.measure(leo.output_register, m) # print(qc.draw(line_length=10000)) counts = q_execute(qc, BasicAer.get_backend('qasm_simulator'), shots=num_shots).result().get_counts(qc) if assignment in sols: self.assertEqual(counts['1'], num_shots) else: self.assertEqual(counts['0'], num_shots)
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_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_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 grover_general_logicalexpression_qiskit(oracle_string: str) -> QuantumCircuit: from qiskit.aqua.algorithms import Grover from qiskit.aqua.components.oracles import LogicalExpressionOracle # input is logical expression, like '(A | B) & (A | ~B) & (~A | B)' oracle = LogicalExpressionOracle(oracle_string) grover = Grover(oracle) grover_circuit = grover.construct_circuit(measurement=True) return grover_circuit
def generate_grover(self, incr=False, n_iters=None): """ Generate grover oracle and the full grover circuit using qiskit's implementation """ if n_iters is None: n_iters = int(2**((self.gc.nnodes * self.gc.ncolors - 1) / 2.)) constraints = self.graphcover_constraints() CNF = self.dimacs_format(constraints, self.gc.nnodes * self.gc.ncolors) self.oracle = LogicalExpressionOracle(CNF, optimization='espresso') return Grover(self.oracle, incremental=incr, num_iterations=n_iters, mct_mode='advanced')
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 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_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))
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'])
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")
print(f'{randomVal} yields {resultingAction}') return resultingAction """ Starting here... first we'll give the opening message """ print( "Grover is an AI who's decisions are based on the result of running the Grover algorithm." ) print( "He tends to cheat more on bad days, when there's more noise in the quantum computer..." ) print() """ Get the data from the quantum computer """ expression = 'a & b' oracle = LogicalExpressionOracle(expression, optimization=True) grover = Grover(oracle) grover_compiled = grover.construct_circuit(measurement=True) # Load our saved IBMQ accounts and get the backend print("Loading account...") provider = IBMQ.load_account() provider = IBMQ.get_provider(hub='ibm-q') device = provider.get_backend('ibmq_ourense') #device = least_busy(provider.backends(simulator=False)) print("Selected device: ", device) job = execute(grover_compiled, backend=device, shots=1024) job_monitor(job, interval=2) """ Now we can process the for our RNG stuff """
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"])