def classical_hhl_solver(a, b, theta): a_matrix = [[a, b], [b, a]] b_matrix = [np.cos(theta), np.sin(theta)] result_ref = NumPyLSsolver(a_matrix, b_matrix).run() result = np.round(result_ref['solution'], 4) print("Solution:\t", result) return result
def main(): #matrix = [[1, -1/3], [-1/3, 1]] matrix = [[15, 9, 5, -3], [9, 15, 3, -5], [5, 3, 15, -9], [-3, -5, -9, 15]] #vector = [1, 0] vector = [1/2,1/2,1/2,1/2] orig_size = len(vector) matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize(matrix, vector) # Initialize eigenvalue finding module eigs = create_eigs(matrix, 3, 50, False) num_q, num_a = eigs.get_register_sizes() # Initialize initial state module init_state = Custom(num_q, state_vector=vector) # Initialize reciprocal rotation module reci = LookupRotation(negative_evals=eigs._negative_evals, evo_time=eigs._evo_time) algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs, init_state, reci, num_q, num_a, orig_size) circuit_drawer(algo.construct_circuit(),output='mpl',filename='./hhlnew.png') result = algo.run(QuantumInstance(Aer.get_backend('statevector_simulator'))) print("Solution:\t\t", np.round(result['solution'], 5)) result_ref = NumPyLSsolver(matrix, vector).run() print("Classical Solution:\t", np.round(result_ref['solution'], 5)) print("Probability:\t\t %f" % result['probability_result']) fidelity(result['solution'], result_ref['solution'])
def test_hhl_negative_eigs(self): """ hhl negative eigs test """ self.log.debug('Testing HHL with matrix with negative eigenvalues') # The following seed was chosen so as to ensure we get a negative eigenvalue # and in case anything changes we assert this after the random matrix is created aqua_globals.random_seed = 27 n = 2 matrix = rmg.random_diag(n, eigrange=[-1, 1]) vector = aqua_globals.random.random(n) self.assertTrue(np.any(matrix < 0), "Random matrix has no negative values") # run NumPyLSsolver ref_result = NumPyLSsolver(matrix, vector).run() ref_solution = ref_result.solution ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl orig_size = len(vector) matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize( matrix, vector) # Initialize eigenvalue finding module eigs = TestHHL._create_eigs(matrix, 4, True) num_q, num_a = eigs.get_register_sizes() # Initialize initial state module init_state = QuantumCircuit(num_q) init_state.initialize(vector / np.linalg.norm(vector), range(num_q)) # Initialize reciprocal rotation module reci = LookupRotation(negative_evals=eigs._negative_evals, evo_time=eigs._evo_time) algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs, init_state, reci, num_q, num_a, orig_size) hhl_result = algo.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) hhl_solution = hhl_result.solution hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare results fidelity = state_fidelity(ref_normed, hhl_normed) np.testing.assert_approx_equal(fidelity, 1, significant=3) self.log.debug('HHL solution vector: %s', hhl_solution) self.log.debug('algebraic solution vector: %s', ref_normed) self.log.debug('fidelity HHL to algebraic: %s', fidelity) self.log.debug('probability of result: %s', hhl_result.probability_result)
def test_hhl_diagonal(self, vector, use_circuit_library): """ hhl diagonal test """ self.log.debug( 'Testing HHL simple test in mode Lookup with statevector simulator' ) matrix = [[1, 0], [0, 1]] # run NumPyLSsolver ref_result = NumPyLSsolver(matrix, vector).run() ref_solution = ref_result['solution'] ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl orig_size = len(vector) matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize( matrix, vector) # Initialize eigenvalue finding module eigs = TestHHL._create_eigs(matrix, 3, False, use_circuit_library) num_q, num_a = eigs.get_register_sizes() # Initialize initial state module init_state = Custom(num_q, state_vector=vector) # Initialize reciprocal rotation module reci = LookupRotation(negative_evals=eigs._negative_evals, evo_time=eigs._evo_time) algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs, init_state, reci, num_q, num_a, orig_size) if not use_circuit_library: warnings.filterwarnings('ignore', category=DeprecationWarning) hhl_result = algo.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) if not use_circuit_library: warnings.filterwarnings('always', category=DeprecationWarning) hhl_solution = hhl_result['solution'] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare results fidelity = state_fidelity(ref_normed, hhl_normed) np.testing.assert_approx_equal(fidelity, 1, significant=5) self.log.debug('HHL solution vector: %s', hhl_solution) self.log.debug('algebraic solution vector: %s', ref_solution) self.log.debug('fidelity HHL to algebraic: %s', fidelity) self.log.debug('probability of result: %s', hhl_result["probability_result"])
def test_hhl_diagonal_other_dim(self, n, num_ancillary): """ hhl diagonal other dim test """ self.log.debug('Testing HHL with matrix dimension other than 2**n') matrix = rmg.random_diag(n, eigrange=[0, 1]) vector = aqua_globals.random.random(n) # run NumPyLSsolver ref_result = NumPyLSsolver(matrix, vector).run() ref_solution = ref_result.solution ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl orig_size = len(vector) matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize( matrix, vector) # Initialize eigenvalue finding module eigs = TestHHL._create_eigs(matrix, num_ancillary, True) num_q, num_a = eigs.get_register_sizes() # Initialize initial state module with warnings.catch_warnings(): warnings.filterwarnings('ignore', category=DeprecationWarning) init_state = Custom(num_q, state_vector=vector) # Initialize reciprocal rotation module reci = LookupRotation(negative_evals=eigs._negative_evals, evo_time=eigs._evo_time) algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs, init_state, reci, num_q, num_a, orig_size) hhl_result = algo.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) hhl_solution = hhl_result.solution hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare result fidelity = state_fidelity(ref_normed, hhl_normed) np.testing.assert_approx_equal(fidelity, 1.0, significant=1) self.log.debug('HHL solution vector: %s', hhl_solution) self.log.debug('algebraic solution vector: %s', ref_solution) self.log.debug('fidelity HHL to algebraic: %s', fidelity) self.log.debug('probability of result: %s', hhl_result.probability_result)
def test_hhl_diagonal_negative(self, vector): """ hhl diagonal negative test """ self.log.debug( 'Testing HHL simple test in mode Lookup with statevector simulator' ) matrix = [[1, 0], [0, 1]] # run NumPyLSsolver ref_result = NumPyLSsolver(matrix, vector).run() ref_solution = ref_result.solution ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl orig_size = len(vector) matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize( matrix, vector) # Initialize eigenvalue finding module eigs = TestHHL._create_eigs(matrix, 4, True) num_q, num_a = eigs.get_register_sizes() # Initialize initial state module init_state = QuantumCircuit(num_q) init_state.initialize(vector / np.linalg.norm(vector), range(num_q)) # Initialize reciprocal rotation module reci = LookupRotation(negative_evals=eigs._negative_evals, evo_time=eigs._evo_time) algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs, init_state, reci, num_q, num_a, orig_size) hhl_result = algo.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) hhl_solution = hhl_result.solution hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare results fidelity = state_fidelity(ref_normed, hhl_normed) np.testing.assert_approx_equal(fidelity, 1, significant=5) self.log.debug('HHL solution vector: %s', hhl_solution) self.log.debug('algebraic solution vector: %s', ref_normed) self.log.debug('fidelity HHL to algebraic: %s', fidelity) self.log.debug('probability of result: %s', hhl_result.probability_result)
def test_hhl_negative_eigs(self): """ hhl negative eigs test """ self.log.debug('Testing HHL with matrix with negative eigenvalues') n = 2 matrix = rmg.random_diag(n, eigrange=[-1, 1]) vector = aqua_globals.random.random_sample(n) # run NumPyLSsolver ref_result = NumPyLSsolver(matrix, vector).run() ref_solution = ref_result['solution'] ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl orig_size = len(vector) matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize( matrix, vector) # Initialize eigenvalue finding module eigs = TestHHL._create_eigs(matrix, 4, True) num_q, num_a = eigs.get_register_sizes() # Initialize initial state module init_state = Custom(num_q, state_vector=vector) # Initialize reciprocal rotation module reci = LookupRotation(negative_evals=eigs._negative_evals, evo_time=eigs._evo_time) algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs, init_state, reci, num_q, num_a, orig_size) hhl_result = algo.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) hhl_solution = hhl_result["solution"] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare results fidelity = state_fidelity(ref_normed, hhl_normed) np.testing.assert_approx_equal(fidelity, 1, significant=3) self.log.debug('HHL solution vector: %s', hhl_solution) self.log.debug('algebraic solution vector: %s', ref_normed) self.log.debug('fidelity HHL to algebraic: %s', fidelity) self.log.debug('probability of result: %s', hhl_result["probability_result"])
def test_hhl_non_hermitian(self): """ hhl non hermitian test """ self.log.debug('Testing HHL with simple non-hermitian matrix') matrix = [[1, 1], [2, 1]] vector = [1, 0] # run NumPyLSsolver ref_result = NumPyLSsolver(matrix, vector).run() ref_solution = ref_result['solution'] ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl orig_size = len(vector) matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize( matrix, vector) # Initialize eigenvalue finding module eigs = TestHHL._create_eigs(matrix, 6, True) num_q, num_a = eigs.get_register_sizes() # Initialize initial state module init_state = Custom(num_q, state_vector=vector) # Initialize reciprocal rotation module reci = LookupRotation(negative_evals=eigs._negative_evals, evo_time=eigs._evo_time) algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs, init_state, reci, num_q, num_a, orig_size) hhl_result = algo.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) hhl_solution = hhl_result['solution'] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare result fidelity = state_fidelity(ref_normed, hhl_normed) self.assertGreater(fidelity, 0.8) self.log.debug('HHL solution vector: %s', hhl_solution) self.log.debug('algebraic solution vector: %s', ref_solution) self.log.debug('fidelity HHL to algebraic: %s', fidelity) self.log.debug('probability of result: %s', hhl_result["probability_result"])
def test_hhl_random_hermitian(self): """ hhl random hermitian test """ self.log.debug('Testing HHL with random hermitian matrix') n = 2 matrix = rmg.random_hermitian(n, eigrange=[0, 1]) vector = aqua_globals.random.random(n) # run NumPyLSsolver ref_result = NumPyLSsolver(matrix, vector).run() ref_solution = ref_result.solution ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl orig_size = len(vector) matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize( matrix, vector) # Initialize eigenvalue finding module eigs = TestHHL._create_eigs(matrix, 4, False) num_q, num_a = eigs.get_register_sizes() # Initialize initial state module with warnings.catch_warnings(): warnings.filterwarnings('ignore', category=DeprecationWarning) init_state = Custom(num_q, state_vector=vector) # Initialize reciprocal rotation module reci = LookupRotation(negative_evals=eigs._negative_evals, evo_time=eigs._evo_time) algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs, init_state, reci, num_q, num_a, orig_size) warnings.filterwarnings('ignore', category=DeprecationWarning) hhl_result = algo.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) warnings.filterwarnings('always', category=DeprecationWarning) hhl_solution = hhl_result.solution hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare result fidelity = state_fidelity(ref_normed, hhl_normed) np.testing.assert_approx_equal(fidelity, 1, significant=1)
from qiskit.aqua.algorithms import HHL, ExactLSsolver from qiskit.aqua.components.eigs import EigsQPE from qiskit.aqua.components.qfts import Standard as StandardQFTS from qiskit.aqua.components.iqfts import Standard as StandardIQFTS from qiskit.aqua.components.reciprocals import LookupRotation from qiskit.aqua.operators import MatrixOperator from qiskit.aqua.components.initial_states import Custom import numpy as np from qiskit.aqua.algorithms import NumPyLSsolver # Input matrix = [[1, -1 / 3], [-1 / 3, 1]] vector = [1, 0] # Liner Solution linearAlogo = NumPyLSsolver(np.array(matrix), vector) linearSol = NumPyLSsolver(np.array(matrix), vector) print(linearSol) def create_eigs(matrix, num_ancillae, negative_evals): ne_qfts = [None, None] if negative_evals: num_ancillae += 1 ne_qfts = [ StandardQFTS(num_ancillae - 1), StandardIQFTS(num_ancillae - 1) ] return EigsQPE(MatrixOperator(matrix=matrix), StandardIQFTS(num_ancillae),
def test_els(self): """ ELS test """ algo = NumPyLSsolver(self.matrix, self.vector) result = algo.run() np.testing.assert_array_almost_equal(result.solution, [1, 0]) np.testing.assert_array_almost_equal(result.eigvals, [3, -1])
# matrix = [[1, -(1/3)], [-(1/3), 1]] # [[1, -1/3], [-1/3, 1]] # vector = [1, 0] # [1, 0] orig_size = len(vector) matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize(matrix, vector) # Initialize eigenvalue finding module eigs = create_eigs(matrix, 3, 50, False) num_q, num_a = eigs.get_register_sizes() # Initialize initial state module init_state = Custom(num_q, state_vector=vector) # Initialize reciprocal rotation module reci = LookupRotation(negative_evals=eigs._negative_evals, evo_time=eigs._evo_time) algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs, init_state, reci, num_q, num_a, orig_size) result = algo.run(QuantumInstance(Aer.get_backend('statevector_simulator'))) print("Solution:\t\t", np.round(result['solution'], 5)) result_ref = NumPyLSsolver(matrix, vector).run() print("Classical Solution:\t", np.round(result_ref['solution'], 5)) print("Probability:\t\t %f" % result['probability_result']) fidelity(result['solution'], result_ref['solution']) print("circuit_width:\t", result['circuit_info']['width']) print("circuit_depth:\t", result['circuit_info']['depth']) print("CNOT gates:\t", result['circuit_info']['operations']['cx'])
def solve(self, matrix, vector): result = NumPyLSsolver(matrix, vector).run() return result['solution']