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"])
