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