def _run(self):
if self._quantum_instance.is_statevector:
qc = self.construct_circuit(measurement=False)
result = self._quantum_instance.execute(qc)
complete_state_vec = result.get_statevector(qc)
variable_register_density_matrix = get_subsystem_density_matrix(
complete_state_vec,
range(len(self._oracle.variable_register), qc.width())
)
variable_register_density_matrix_diag = np.diag(variable_register_density_matrix)
max_amplitude = max(
variable_register_density_matrix_diag.min(),
variable_register_density_matrix_diag.max(),
key=abs
)
max_amplitude_idx = \
np.where(variable_register_density_matrix_diag == max_amplitude)[0][0]
top_measurement = np.binary_repr(max_amplitude_idx, len(self._oracle.variable_register))
else:
qc = self.construct_circuit(measurement=True)
measurement = self._quantum_instance.execute(qc).get_counts(qc)
self._ret['measurement'] = measurement
top_measurement = max(measurement.items(), key=operator.itemgetter(1))[0]
self._ret['result'] = 'constant' if int(top_measurement) == 0 else 'balanced'
return self._ret
def _compute_energy(self):
if self._quantum_instance.is_statevector:
qc = self.construct_circuit(measurement=False)
result = self._quantum_instance.execute(qc)
complete_state_vec = result.get_statevector(qc)
ancilla_density_mat = get_subsystem_density_matrix(
complete_state_vec,
range(self._num_ancillae,
self._num_ancillae + self._operator.num_qubits))
ancilla_density_mat_diag = np.diag(ancilla_density_mat)
max_amplitude = \
max(ancilla_density_mat_diag.min(), ancilla_density_mat_diag.max(), key=abs)
max_amplitude_idx = np.where(
ancilla_density_mat_diag == max_amplitude)[0][0]
top_measurement_label = np.binary_repr(max_amplitude_idx,
self._num_ancillae)[::-1]
else:
qc = self.construct_circuit(measurement=True)
result = self._quantum_instance.execute(qc)
ancilla_counts = result.get_counts(qc)
top_measurement_label = \
sorted([(ancilla_counts[k], k) for k in ancilla_counts])[::-1][0][-1][::-1]
top_measurement_decimal = sum([
t[0] * t[1] for t in zip(self._binary_fractions,
[int(n) for n in top_measurement_label])
])
self._ret['top_measurement_label'] = top_measurement_label
self._ret['top_measurement_decimal'] = top_measurement_decimal
self._ret['eigvals'] = \
[top_measurement_decimal / self._ret['stretch'] - self._ret['translation']]
self._ret['energy'] = self._ret['eigvals'][0]
def _run_with_existing_iterations(self):
qc = self.construct_circuit()
if self._quantum_instance.is_statevector:
result = self._quantum_instance.execute(qc)
complete_state_vec = result.get_statevector(qc)
variable_register_density_matrix = get_subsystem_density_matrix(
complete_state_vec,
range(len(self._oracle.variable_register), qc.width()))
variable_register_density_matrix_diag = np.diag(
variable_register_density_matrix)
max_amplitude = max(variable_register_density_matrix_diag.min(),
variable_register_density_matrix_diag.max(),
key=abs)
max_amplitude_idx = np.where(
variable_register_density_matrix_diag == max_amplitude)[0][0]
top_measurement = format(
max_amplitude_idx,
'0{}b'.format(len(self._oracle.variable_register)))
else:
measurement_cr = ClassicalRegister(len(
self._oracle.variable_register),
name='m')
qc.add_register(measurement_cr)
qc.measure(self._oracle.variable_register, measurement_cr)
measurement = self._quantum_instance.execute(qc).get_counts(qc)
top_measurement = max(measurement.items(),
key=operator.itemgetter(1))[0]
self._ret['top_measurement'] = top_measurement
assignment = self._oracle.interpret_measurement(
top_measurement=top_measurement)
oracle_evaluation = self._oracle.evaluate_classically(assignment)
return assignment, oracle_evaluation
def _run_experiment(self, power):
"""Run a grover experiment for a given power of the Grover operator."""
if self._quantum_instance.is_statevector:
qc = self.construct_circuit(power, measurement=False)
result = self._quantum_instance.execute(qc)
statevector = result.get_statevector(qc)
num_bits = len(self._grover_operator.reflection_qubits)
# trace out work qubits
if qc.width() != num_bits:
rho = get_subsystem_density_matrix(statevector,
range(num_bits, qc.width()))
statevector = np.diag(rho)
max_amplitude = max(statevector.max(), statevector.min(), key=abs)
max_amplitude_idx = np.where(statevector == max_amplitude)[0][0]
top_measurement = np.binary_repr(max_amplitude_idx, num_bits)
else:
qc = self.construct_circuit(power, measurement=True)
measurement = self._quantum_instance.execute(qc).get_counts(qc)
self._ret['measurement'] = measurement
top_measurement = max(measurement.items(),
key=operator.itemgetter(1))[0]
self._ret['top_measurement'] = top_measurement
# as_list = [int(bit) for bit in top_measurement]
# return self.post_processing(as_list), self.is_good_state(top_measurement)
return self.post_processing(top_measurement), self.is_good_state(
top_measurement)
def _compute_energy(self):
qc = self.construct_circuit()
if self._quantum_instance.is_statevector:
result = self._quantum_instance.execute(qc)
complete_state_vec = result.get_statevector(qc)
ancilla_density_mat = get_subsystem_density_matrix(
complete_state_vec,
range(self._num_ancillae, self._num_ancillae + self._operator.num_qubits)
)
ancilla_density_mat_diag = np.diag(ancilla_density_mat)
max_amplitude = max(ancilla_density_mat_diag.min(), ancilla_density_mat_diag.max(), key=abs)
max_amplitude_idx = np.where(ancilla_density_mat_diag == max_amplitude)[0][0]
top_measurement_label = np.binary_repr(max_amplitude_idx, self._num_ancillae)[::-1]
else:
from qiskit import ClassicalRegister
c_ancilla = ClassicalRegister(self._num_ancillae, name='ca')
qc.add_register(c_ancilla)
qc.barrier(self._phase_estimation_circuit.ancillary_register)
qc.measure(self._phase_estimation_circuit.ancillary_register, c_ancilla)
result = self._quantum_instance.execute(qc)
ancilla_counts = result.get_counts(qc)
top_measurement_label = sorted([(ancilla_counts[k], k) for k in ancilla_counts])[::-1][0][-1][::-1]
top_measurement_decimal = sum(
[t[0] * t[1] for t in zip(self._binary_fractions, [int(n) for n in top_measurement_label])]
)
self._ret['top_measurement_label'] = top_measurement_label
self._ret['top_measurement_decimal'] = top_measurement_decimal
self._ret['eigvals'] = [top_measurement_decimal / self._ret['stretch'] - self._ret['translation']]
self._ret['energy'] = self._ret['eigvals'][0]
def _run(self):
if not self._ret['factors']:
logger.debug('Running with N={} and a={}.'.format(self._N, self._a))
if self._quantum_instance.is_statevector:
breakpoints, circuit = self.construct_circuit(measurement=False)
logger.warning('The statevector_simulator might lead to subsequent computation using too much memory.')
result = self._quantum_instance.execute(circuit)
complete_state_vec = result.get_statevector(circuit)
# TODO: this uses too much memory
up_qreg_density_mat = get_subsystem_density_matrix(
complete_state_vec,
range(2 * self._n, 4 * self._n + 2)
)
up_qreg_density_mat_diag = np.diag(up_qreg_density_mat)
counts = dict()
for i, v in enumerate(up_qreg_density_mat_diag):
if not v == 0:
counts[bin(int(i))[2:].zfill(2 * self._n)] = v ** 2
else:
breakpoints, circuit = self.construct_circuit(measurement=True)
sim_result = self._quantum_instance.execute( breakpoints + [circuit] )
# validate maximal superposition in top register
assert ( sim_result.get_assertion_passed(breakpoints[0]) )
# validate initialize down register to 1
assert ( sim_result.get_assertion_passed(breakpoints[1]) )
# validate uncomputation is complete and registers are in product state
assert ( sim_result.get_assertion_passed(breakpoints[2]) )
counts = sim_result.get_counts(circuit)
self._ret['results'] = dict()
# For each simulation result, print proper info to user and try to calculate the factors of N
for output_desired in list(counts.keys()):
# Get the x_value from the final state qubits
logger.info("------> Analyzing result {0}.".format(output_desired))
self._ret['results'][output_desired] = None
success = self._get_factors(output_desired, int(2 * self._n))
if success:
logger.info('Found factors {} from measurement {}.'.format(
self._ret['results'][output_desired], output_desired
))
else:
logger.info('Cannot find factors from measurement {} because {}'.format(
output_desired, self._ret['results'][output_desired]
))
return self._ret
def _run(self):
if not self._ret['factors']:
self._a = self._pick_coprime_a()
logger.debug('Running with N={} and a={}.'.format(
self._N, self._a))
circuit = self.construct_circuit()
if self._quantum_instance.is_statevector:
logger.warning(
'The statevector_simulator might lead to subsequent computation using too much memory.'
)
result = self._quantum_instance.execute(circuit)
complete_state_vec = result.get_statevector(circuit)
# TODO: this uses too much memory
up_qreg_density_mat = get_subsystem_density_matrix(
complete_state_vec, range(2 * self._n, 4 * self._n + 2))
up_qreg_density_mat_diag = np.diag(up_qreg_density_mat)
counts = dict()
for i, v in enumerate(up_qreg_density_mat_diag):
if not v == 0:
counts[bin(int(i))[2:].zfill(2 * self._n)] = v**2
else:
up_cqreg = ClassicalRegister(2 * self._n, name='m')
circuit.add_register(up_cqreg)
circuit.measure(self._up_qreg, up_cqreg)
counts = self._quantum_instance.execute(circuit).get_counts(
circuit)
self._ret['results'] = dict()
# For each simulation result, print proper info to user and try to calculate the factors of N
for output_desired in list(counts.keys()):
# Get the x_value from the final state qubits
logger.info(
"------> Analyzing result {0}.".format(output_desired))
self._ret['results'][output_desired] = None
success = self._get_factors(output_desired, int(2 * self._n))
if success:
logger.info('Found factors {} from measurement {}.'.format(
self._ret['results'][output_desired], output_desired))
else:
logger.warning(
'Cannot find factors from measurement {} because {}'.
format(output_desired,
self._ret['results'][output_desired]))
return self._ret
def _estimate_phase_iteratively(self):
"""
Iteratively construct the different order of controlled evolution
circuit to carry out phase estimation.
"""
self._ret['top_measurement_label'] = ''
omega_coef = 0
# k runs from the number of iterations back to 1
for k in range(self._num_iterations, 0, -1):
omega_coef /= 2
if self._quantum_instance.is_statevector:
qc = self.construct_circuit(k,
-2 * np.pi * omega_coef,
measurement=False)
result = self._quantum_instance.execute(qc)
complete_state_vec = result.get_statevector(qc)
ancilla_density_mat = get_subsystem_density_matrix(
complete_state_vec, range(self._operator.num_qubits))
ancilla_density_mat_diag = np.diag(ancilla_density_mat)
max_amplitude = max(ancilla_density_mat_diag.min(),
ancilla_density_mat_diag.max(),
key=abs)
x = np.where(ancilla_density_mat_diag == max_amplitude)[0][0]
else:
qc = self.construct_circuit(k,
-2 * np.pi * omega_coef,
measurement=True)
measurements = self._quantum_instance.execute(qc).get_counts(
qc)
if '0' not in measurements:
if '1' in measurements:
x = 1
else:
raise RuntimeError(
'Unexpected measurement {}.'.format(measurements))
else:
if '1' not in measurements:
x = 0
else:
x = 1 if measurements['1'] > measurements['0'] else 0
self._ret['top_measurement_label'] = \
'{}{}'.format(x, self._ret['top_measurement_label'])
omega_coef = omega_coef + x / 2
logger.info('Reverse iteration %s of %s with measured bit %s', k,
self._num_iterations, x)
return omega_coef
def _run(self) -> AlgorithmResult:
if not self._ret['factors']:
logger.debug('Running with N=%s and a=%s.', self._N, self._a)
if self._quantum_instance.is_statevector:
circuit = self.construct_circuit(measurement=False)
logger.warning('The statevector_simulator might lead to '
'subsequent computation using too much memory.')
result = self._quantum_instance.execute(circuit)
complete_state_vec = result.get_statevector(circuit)
# TODO: this uses too much memory
up_qreg_density_mat = get_subsystem_density_matrix(
complete_state_vec,
range(2 * self._n, 4 * self._n + 2)
)
up_qreg_density_mat_diag = np.diag(up_qreg_density_mat)
counts = dict()
for i, v in enumerate(up_qreg_density_mat_diag):
if not v == 0:
counts[bin(int(i))[2:].zfill(2 * self._n)] = v ** 2
else:
circuit = self.construct_circuit(measurement=True)
counts = self._quantum_instance.execute(circuit).get_counts(circuit)
self._ret.data["total_counts"] = len(counts)
# For each simulation result, print proper info to user
# and try to calculate the factors of N
for measurement in list(counts.keys()):
# Get the x_final value from the final state qubits
logger.info("------> Analyzing result %s.", measurement)
factors = self._get_factors(measurement)
if factors:
logger.info(
'Found factors %s from measurement %s.',
factors, measurement
)
self._ret.data["successful_counts"] += 1
if factors not in self._ret['factors']:
self._ret['factors'].append(factors)
return self._ret
def _run(self):
if not self._ret['factors']:
logger.debug('Running with N=%s and a=%s.', self._N, self._a)
if self._quantum_instance.is_statevector:
circuit = self.construct_circuit(measurement=False)
logger.warning('The statevector_simulator might lead to '
'subsequent computation using too much memory.')
result = self._quantum_instance.execute(circuit)
complete_state_vec = result.get_statevector(circuit)
# TODO: this uses too much memory
up_qreg_density_mat = get_subsystem_density_matrix(
complete_state_vec, range(2 * self._n, 4 * self._n + 2))
up_qreg_density_mat_diag = np.diag(up_qreg_density_mat)
counts = dict()
for i, v in enumerate(up_qreg_density_mat_diag):
if not v == 0:
counts[bin(int(i))[2:].zfill(2 * self._n)] = v**2
else:
circuit = self.construct_circuit(measurement=True)
counts = self._quantum_instance.execute(circuit).get_counts(
circuit)
self._ret['results'] = dict()
# For each simulation result, print proper info to user
# and try to calculate the factors of N
for output_desired in list(counts.keys()):
# Get the x_value from the final state qubits
logger.info("------> Analyzing result %s.", output_desired)
self._ret['results'][output_desired] = None
success = self._get_factors(output_desired, int(2 * self._n))
if success:
logger.info('Found factors %s from measurement %s.',
self._ret['results'][output_desired],
output_desired)
else:
logger.info(
'Cannot find factors from measurement %s because %s',
output_desired, self._ret['results'][output_desired])
return self._ret
def _run(self):
if self._quantum_instance.is_statevector:
bp, qc = self.construct_circuit(measurement=False)
result = self._quantum_instance.execute(qc)
complete_state_vec = result.get_statevector(qc)
variable_register_density_matrix = get_subsystem_density_matrix(
complete_state_vec,
range(len(self._oracle.variable_register), qc.width())
)
variable_register_density_matrix_diag = np.diag(variable_register_density_matrix)
max_amplitude = max(
variable_register_density_matrix_diag.min(),
variable_register_density_matrix_diag.max(),
key=abs
)
max_amplitude_idx = np.where(variable_register_density_matrix_diag == max_amplitude)[0][0]
top_measurement = np.binary_repr(max_amplitude_idx, len(self._oracle.variable_register))
else:
bp, qc = self.construct_circuit(measurement=True)
sim_result = self._quantum_instance.execute( bp + [qc] )
# assert classical input state in oracle variable_register
print ( "sim_result.get_assertion_passed(bp[0]) = " )
print ( sim_result.get_assertion_passed(bp[0]) )
assert ( sim_result.get_assertion_passed(bp[0]) )
# assert uniform superposition in oracle variable_register after Hadamards
assert ( sim_result.get_assertion_passed(bp[1]) )
# assert classical output state in oracle variable_register after Hadamards
assert ( sim_result.get_assertion_passed(bp[2]) != sim_result.get_assertion_passed(bp[3]) )
measurement = sim_result.get_counts(qc)
print ("measurement = ")
print (measurement)
self._ret['measurement'] = measurement
top_measurement = max(measurement.items(), key=operator.itemgetter(1))[0]
self._ret['result'] = 'constant' if int(top_measurement) == 0 else 'balanced'
return self._ret
def _run_with_existing_iterations(self):
if self._quantum_instance.is_statevector:
qc = self.construct_circuit(measurement=False)
result = self._quantum_instance.execute(qc)
complete_state_vec = result.get_statevector(qc)
variable_register_density_matrix = get_subsystem_density_matrix(
complete_state_vec,
range(len(self._oracle.variable_register), qc.width())
)
variable_register_density_matrix_diag = np.diag(variable_register_density_matrix)
max_amplitude = max(
variable_register_density_matrix_diag.min(),
variable_register_density_matrix_diag.max(),
key=abs
)
max_amplitude_idx = np.where(variable_register_density_matrix_diag == max_amplitude)[0][0]
top_measurement = np.binary_repr(max_amplitude_idx, len(self._oracle.variable_register))
else:
bp, qc = self.construct_circuit(measurement=True)
sim_result = self._quantum_instance.execute( bp + [qc] )
print("If only one match exists in the database,")
print("the chi-squared statstics of the assertions should decrease monotonically,")
print("validating that the amplitude is correctly amplified.")
print("The chi-squared statstics = ")
assertion_chisq = [ sim_result.get_assertion_stats(breakpoint)[0] for breakpoint in bp ]
print (assertion_chisq)
def non_increasing(L):
return all(x>=y for x, y in zip(L, L[1:]))
assert ( non_increasing(assertion_chisq) )
measurement = sim_result.get_counts(qc)
self._ret['measurement'] = measurement
top_measurement = max(measurement.items(), key=operator.itemgetter(1))[0]
self._ret['top_measurement'] = top_measurement
oracle_evaluation, assignment = self._oracle.evaluate_classically(top_measurement)
return assignment, oracle_evaluation
def _run(self):
if self._quantum_instance.is_statevector:
qc = self.construct_circuit(measurement=False)
result = self._quantum_instance.execute(qc)
complete_state_vec = result.get_statevector(qc)
variable_register_density_matrix = get_subsystem_density_matrix(
complete_state_vec,
range(len(self._oracle.variable_register), qc.width())
)
variable_register_density_matrix_diag = np.diag(variable_register_density_matrix)
measurements = {
np.binary_repr(idx, width=len(self._oracle.variable_register)):
abs(variable_register_density_matrix_diag[idx]) ** 2
for idx in range(len(variable_register_density_matrix_diag))
if not variable_register_density_matrix_diag[idx] == 0
}
else:
qc = self.construct_circuit(measurement=True)
measurements = self._quantum_instance.execute(qc).get_counts(qc)
self._ret['result'] = self._interpret_measurement(measurements)
return self._ret
def _run_with_existing_iterations(self):
if self._quantum_instance.is_statevector:
qc = self.construct_circuit(measurement=False)
result = self._quantum_instance.execute(qc)
complete_state_vec = result.get_statevector(qc)
variable_register_density_matrix = get_subsystem_density_matrix(
complete_state_vec,
range(len(self._oracle.variable_register), qc.width()))
variable_register_density_matrix_diag = np.diag(
variable_register_density_matrix)
max_amplitude = max(variable_register_density_matrix_diag.min(),
variable_register_density_matrix_diag.max(),
key=abs)
max_amplitude_idx = \
np.where(variable_register_density_matrix_diag == max_amplitude)[0][0]
top_measurement = np.binary_repr(
max_amplitude_idx, len(self._oracle.variable_register))
else:
qc = self.construct_circuit(measurement=True)
measurement = self._quantum_instance.execute(qc).get_counts(qc)
self._ret['measurement'] = measurement
top_measurement = max(measurement.items(),
key=operator.itemgetter(1))[0]
#########################################################
####### COMPLETE CIRCUIT APPEARS AT THIS STAGE ##########
#########################################################
'''
qc.draw(output="mpl")
plt.show()
'''
self._ret['complete_circuit'] = qc
self._ret['top_measurement'] = top_measurement
oracle_evaluation, assignment = self._oracle.evaluate_classically(
top_measurement)
return assignment, oracle_evaluation
