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