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_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_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(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_circuit():
"""
Builds a QuantumCircuit of the qiskit aqua implementation of
grover's algorithm with set parameters.
Args:
Returns:
Resuling circuit of the qiskit aqua implementation of Grover's
algorithm after adding measures on every qubit.
"""
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('aer_simulator')
oracle = SAT(sat_cnf)
grv = Grover(oracle)
circ = grv.construct_circuit()
return add_measures(circ)
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 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_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 get_circuit(**kwargs):
oracle_string = kwargs[
"oracle"] # input is binary String of a truth table, like '1000': A & B = 0 => f(x*) = 1
oracle = TruthTableOracle(oracle_string)
grover = Grover(oracle)
grover_circuit = grover.construct_circuit(measurement=True)
return grover_circuit
def grover_general_truthtable_qiskit(oracle_string: str) -> QuantumCircuit:
from qiskit.aqua.algorithms import Grover
from qiskit.aqua.components.oracles import TruthTableOracle
# input is binary String of a truth table, like '1000': A & B = 0 => f(x*) = 1
oracle = TruthTableOracle(oracle_string)
grover = Grover(oracle)
grover_circuit = grover.construct_circuit(measurement=True)
return grover_circuit
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 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 amplitude_amplification(self, evidence):
self.state_preparation = self.circ
self.oracle = QuantumCircuit(self.ctrl, self.anc, self.tgt)
for index, e in enumerate(evidence):
if evidence[e]['state'] == '1':
self.oracle.z([evidence[e]['n']])
self.grover_op = Grover(self.oracle,
state_preparation=self.state_preparation)
self.grover_op.draw()
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_construct_circuit(self):
"""Test construct_circuit"""
oracle = QuantumCircuit(2)
oracle.cz(0, 1)
grover = Grover(oracle=oracle, good_state=["11"])
constructed = grover.construct_circuit(1)
grover_op = GroverOperator(oracle)
expected = QuantumCircuit(2)
expected.compose(grover_op.state_preparation, inplace=True)
expected.compose(grover_op, inplace=True)
self.assertTrue(Operator(constructed).equiv(Operator(expected)))
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 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_oracle_quantumcircuit(self):
"""Test QuantumCircuit oracle"""
oracle = QuantumCircuit(2)
oracle.cz(0, 1)
grover = Grover(oracle=oracle, good_state=["11"])
grover_op = grover._grover_operator
self.assertTrue(Operator(grover_op).equiv(Operator(self._expected_grover_op)))
def test_state_preparation_type_error(self):
"""Test InitialState state_preparation with QuantumCircuit oracle"""
init_state = Zero(2)
oracle = QuantumCircuit(2)
oracle.cz(0, 1)
with self.assertRaises(TypeError):
Grover(oracle=oracle, state_preparation=init_state)
def test_is_good_state_statevector(self):
"""Test StateVector is_good_state"""
oracle = QuantumCircuit(2)
oracle.cz(0, 1)
is_good_state = Statevector.from_label('11')
grover = Grover(oracle=oracle, good_state=is_good_state)
self.assertTrue(grover._is_good_state.equiv(Statevector.from_label('11')))
def test_is_good_state_list(self):
"""Test List is_good_state"""
oracle = QuantumCircuit(2)
oracle.cz(0, 1)
is_good_state = ["11", "00"]
grover = Grover(oracle=oracle, good_state=is_good_state)
self.assertListEqual(grover._is_good_state, ["11", "00"])
def test_oracle_statevector(self):
"""Test StateVector oracle"""
mark_state = Statevector.from_label('11')
grover = Grover(oracle=mark_state, good_state=['11'])
grover_op = grover._grover_operator
self.assertTrue(
Operator(grover_op).equiv(Operator(self._expected_grover_op)))
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_grover_operator_getter(self):
"""Test the getter of grover_operator"""
oracle = QuantumCircuit(2)
oracle.cz(0, 1)
grover = Grover(oracle=oracle, good_state=["11"])
constructed = grover.grover_operator
expected = GroverOperator(oracle)
self.assertTrue(Operator(constructed).equiv(Operator(expected)))
def test_using_grover_for_error(self):
""" using grover without providing evaluate_classically callback """
q_v = QuantumRegister(2, name='v')
q_o = QuantumRegister(1, name='o')
circuit = QuantumCircuit(q_v, q_o)
oracle = CustomCircuitOracle(variable_register=q_v, output_register=q_o, circuit=circuit)
with self.assertRaises(AquaError):
_ = Grover(oracle)
def test_grover_operator(self):
"""Test GroverOperator"""
oracle = QuantumCircuit(2)
oracle.cz(0, 1)
grover_op = GroverOperator(oracle)
grover = Grover(oracle=grover_op.oracle,
grover_operator=grover_op, good_state=["11"])
grover_op = grover._grover_operator
self.assertTrue(Operator(grover_op).equiv(Operator(self._expected_grover_op)))
