def test_qubits_5_zero_vector(self):
self.custom = Custom(5, state='zero')
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_equal(cct, [
1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0
])
def test_eoh(self):
SIZE = 2
temp = np.random.random((2**SIZE, 2**SIZE))
h1 = temp + temp.T
qubit_op = Operator(matrix=h1)
temp = np.random.random((2**SIZE, 2**SIZE))
h1 = temp + temp.T
evo_op = Operator(matrix=h1)
state_in = Custom(SIZE, state='random')
evo_time = 1
num_time_slices = 100
eoh = EOH(qubit_op, state_in, evo_op, 'paulis', evo_time,
num_time_slices)
backend = get_aer_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend,
shots=1,
pass_manager=PassManager())
# self.log.debug('state_out:\n\n')
ret = eoh.run(quantum_instance)
self.log.debug('Evaluation result: {}'.format(ret))
def test_iqpe(self, qubitOp):
self.algorithm = 'IQPE'
self.log.debug('Testing IQPE')
self.qubitOp = qubitOp
exact_eigensolver = ExactEigensolver(self.qubitOp, k=1)
results = exact_eigensolver.run()
w = results['eigvals']
v = results['eigvecs']
self.qubitOp.to_matrix()
np.testing.assert_almost_equal(
self.qubitOp.matrix @ v[0],
w[0] * v[0]
)
np.testing.assert_almost_equal(
expm(-1.j * sparse.csc_matrix(self.qubitOp.matrix)) @ v[0],
np.exp(-1.j * w[0]) * v[0]
)
self.ref_eigenval = w[0]
self.ref_eigenvec = v[0]
self.log.debug('The exact eigenvalue is: {}'.format(self.ref_eigenval))
self.log.debug('The corresponding eigenvector: {}'.format(self.ref_eigenvec))
num_time_slices = 50
num_iterations = 12
state_in = Custom(self.qubitOp.num_qubits, state_vector=self.ref_eigenvec)
iqpe = IQPE(self.qubitOp, state_in, num_time_slices, num_iterations,
paulis_grouping='random', expansion_mode='suzuki', expansion_order=2, shallow_circuit_concat=True)
backend = get_aer_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=100, pass_manager=PassManager())
result = iqpe.run(quantum_instance)
self.log.debug('top result str label: {}'.format(result['top_measurement_label']))
self.log.debug('top result in decimal: {}'.format(result['top_measurement_decimal']))
self.log.debug('stretch: {}'.format(result['stretch']))
self.log.debug('translation: {}'.format(result['translation']))
self.log.debug('final eigenvalue from IQPE: {}'.format(result['energy']))
self.log.debug('reference eigenvalue: {}'.format(self.ref_eigenval))
self.log.debug('ref eigenvalue (transformed): {}'.format(
(self.ref_eigenval + result['translation']) * result['stretch'])
)
self.log.debug('reference binary str label: {}'.format(decimal_to_binary(
(self.ref_eigenval.real + result['translation']) * result['stretch'],
max_num_digits=num_iterations + 3,
fractional_part_only=True
)))
np.testing.assert_approx_equal(result['energy'], self.ref_eigenval.real, significant=2)
def test_qpe(self, qubitOp, simulator):
self.algorithm = 'QPE'
self.log.debug('Testing QPE')
self.qubitOp = qubitOp
exact_eigensolver = ExactEigensolver(self.qubitOp, k=1)
results = exact_eigensolver.run()
w = results['eigvals']
v = results['eigvecs']
self.qubitOp.to_matrix()
np.testing.assert_almost_equal(self.qubitOp.matrix @ v[0], w[0] * v[0])
np.testing.assert_almost_equal(
expm(-1.j * sparse.csc_matrix(self.qubitOp.matrix)) @ v[0],
np.exp(-1.j * w[0]) * v[0])
self.ref_eigenval = w[0]
self.ref_eigenvec = v[0]
self.log.debug('The exact eigenvalue is: {}'.format(
self.ref_eigenval))
self.log.debug('The corresponding eigenvector: {}'.format(
self.ref_eigenvec))
num_time_slices = 50
n_ancillae = 6
state_in = Custom(self.qubitOp.num_qubits,
state_vector=self.ref_eigenvec)
iqft = Standard(n_ancillae)
qpe = QPE(self.qubitOp,
state_in,
iqft,
num_time_slices,
n_ancillae,
paulis_grouping='random',
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
backend = get_aer_backend(simulator)
run_config = RunConfig(shots=100, max_credits=10, memory=False)
quantum_instance = QuantumInstance(backend,
run_config,
pass_manager=PassManager())
# run qpe
result = qpe.run(quantum_instance)
# self.log.debug('transformed operator paulis:\n{}'.format(self.qubitOp.print_operators('paulis')))
# report result
self.log.debug('top result str label: {}'.format(
result['top_measurement_label']))
self.log.debug('top result in decimal: {}'.format(
result['top_measurement_decimal']))
self.log.debug('stretch: {}'.format(
result['stretch']))
self.log.debug('translation: {}'.format(
result['translation']))
self.log.debug('final eigenvalue from QPE: {}'.format(
result['energy']))
self.log.debug('reference eigenvalue: {}'.format(
self.ref_eigenval))
self.log.debug('ref eigenvalue (transformed): {}'.format(
(self.ref_eigenval + result['translation']) * result['stretch']))
self.log.debug('reference binary str label: {}'.format(
decimal_to_binary(
(self.ref_eigenval.real + result['translation']) *
result['stretch'],
max_num_digits=n_ancillae + 3,
fractional_part_only=True)))
np.testing.assert_approx_equal(result['energy'],
self.ref_eigenval.real,
significant=2)
def evolve(n, evo_time, num_time_slices, expansion_order):
print("n=", n)
# Problem setuo
gamma = 0.2
marked_bonds = generate_marked_bonds(n)
#print(marked_bonds)
h, J = generate_h_J(n, marked_bonds)
classical_ham = generate_classical_ham(n, h, J)
driver_ham = generate_driver_ham(n, h, J)
local_min = generate_local_minima(classical_ham, n)
minima = []
for string in local_min:
minima.append(int(string, 2))
#print(minima)
qubit_op = Operator(
matrix=classical_ham
) # create the classical operator, which we measure evals of
# Construct the evolution operator object which we evolve with
evo_op = Operator(matrix=(
classical_ham + gamma * driver_ham
)) # add to it the driver to form the operator we actually evolve with
start_index = randint(0, len(local_min) - 1)
state_num = int(local_min[start_index], 2)
state = np.zeros(2**n)
state[state_num] = 1
print("initial state of the evolution =", state_num)
# initialise the circuit
initial_state = Custom(n, 'uniform', state)
# expansion order can be toggled in order to speed up calculations
# Create the evolution of hamiltonian object
eoh = EOH(qubit_op,
initial_state,
evo_op,
'paulis',
evo_time,
num_time_slices,
expansion_mode='trotter',
expansion_order=expansion_order)
circtime = time.time()
# construct the circuit
circ = eoh.construct_circuit()
circtime = time.time() - circtime
qasmtime = time.time()
# generate the qasm data
qasm = circ.qasm()
qasmtime = time.time() - qasmtime
print("circuit construction time = ", circtime, " qasm write time = ",
qasmtime)
file = open("qasm.txt", 'w')
file.write(str(state_num) + '\n')
for i in range(0, 2**n):
energy_i = classical_ham[i][i]
file.write(str(energy_i) + '\n')
file.write(qasm)
file.close()
# Here is where we cam actually use the inbuilt qiskit simulator
"""
def build(self, qc, q, q_ancillas=None, params=None):
custom_state = Custom(self.num_target_qubits, state_vector=np.sqrt(self.probabilities))
qc.extend(custom_state.construct_circuit('circuit', q))
def test_qubits_qubits_given_mistmatch(self):
with self.assertRaises(ValueError):
self.custom = Custom(5, state_vector=[1.0] * 23)
def test_qubits_5_randgiven_vector(self):
self.custom = Custom(5, state_vector=np.random.rand(32))
cct = self.custom.construct_circuit('vector')
prob = np.sqrt(np.sum([x**2 for x in cct]))
self.assertAlmostEqual(prob, 1.0)
class TestInitialStateCustom(QiskitAquaTestCase):
def test_qubits_2_zero_vector(self):
self.custom = Custom(2, state='zero')
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_equal(cct, [1.0, 0.0, 0.0, 0.0])
def test_qubits_5_zero_vector(self):
self.custom = Custom(5, state='zero')
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_equal(cct, [
1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0
])
def test_qubits_2_zero_circuit(self):
self.custom = Custom(2, state='zero')
cct = self.custom.construct_circuit('circuit')
self.assertEqual(cct.qasm(),
'OPENQASM 2.0;\ninclude "qelib1.inc";\nqreg q[2];\n')
def test_qubits_5_zero_circuit(self):
self.custom = Custom(5, state='zero')
cct = self.custom.construct_circuit('circuit')
self.assertEqual(cct.qasm(),
'OPENQASM 2.0;\ninclude "qelib1.inc";\nqreg q[5];\n')
def test_qubits_2_uniform_vector(self):
self.custom = Custom(2, state='uniform')
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_equal(cct, [0.5] * 4)
def test_qubits_5_uniform_vector(self):
self.custom = Custom(5, state='uniform')
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_almost_equal(cct, [0.1767767] * 32)
def test_qubits_2_uniform_circuit(self):
self.custom = Custom(2, state='uniform')
cct = self.custom.construct_circuit('circuit')
self.assertEqual(
cct.qasm(), 'OPENQASM 2.0;\ninclude "qelib1.inc";\nqreg q[2];\n'
'u2(0.0,3.14159265358979) q[0];\nu2(0.0,3.14159265358979) q[1];\n')
def test_qubits_2_random_vector(self):
self.custom = Custom(2, state='random')
cct = self.custom.construct_circuit('vector')
prob = np.sqrt(np.sum([x**2 for x in cct]))
self.assertAlmostEqual(prob, 1.0)
def test_qubits_5_random_vector(self):
self.custom = Custom(5, state='random')
cct = self.custom.construct_circuit('vector')
prob = np.sqrt(np.sum([x**2 for x in cct]))
self.assertAlmostEqual(prob, 1.0)
def test_qubits_2_given_vector(self):
self.custom = Custom(2, state_vector=[0.5] * 4)
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_equal(cct, [0.5] * 4)
def test_qubits_5_given_vector(self):
self.custom = Custom(5, state_vector=[1.0] * 32)
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_almost_equal(cct, [0.1767767] * 32)
def test_qubits_5_randgiven_vector(self):
self.custom = Custom(5, state_vector=np.random.rand(32))
cct = self.custom.construct_circuit('vector')
prob = np.sqrt(np.sum([x**2 for x in cct]))
self.assertAlmostEqual(prob, 1.0)
def test_qubits_qubits_given_mistmatch(self):
with self.assertRaises(ValueError):
self.custom = Custom(5, state_vector=[1.0] * 23)
def test_qubits_2_zero_vector_wrong_cct_mode(self):
self.custom = Custom(5, state='zero')
with self.assertRaises(ValueError):
cct = self.custom.construct_circuit('matrix')
def test_qubits_2_given_vector(self):
self.custom = Custom(2, state_vector=[0.5] * 4)
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_equal(cct, [0.5] * 4)
def test_qubits_2_random_vector(self):
self.custom = Custom(2, state='random')
cct = self.custom.construct_circuit('vector')
prob = np.sqrt(np.sum([x**2 for x in cct]))
self.assertAlmostEqual(prob, 1.0)
def test_qubits_2_uniform_circuit(self):
self.custom = Custom(2, state='uniform')
cct = self.custom.construct_circuit('circuit')
self.assertEqual(
cct.qasm(), 'OPENQASM 2.0;\ninclude "qelib1.inc";\nqreg q[2];\n'
'u2(0.0,3.14159265358979) q[0];\nu2(0.0,3.14159265358979) q[1];\n')
def test_qubits_5_uniform_vector(self):
self.custom = Custom(5, state='uniform')
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_almost_equal(cct, [0.1767767] * 32)
def test_qubits_5_zero_circuit(self):
self.custom = Custom(5, state='zero')
cct = self.custom.construct_circuit('circuit')
self.assertEqual(cct.qasm(),
'OPENQASM 2.0;\ninclude "qelib1.inc";\nqreg q[5];\n')
def test_evolution(self):
SIZE = 2
#SPARSITY = 0
#X = [[0, 1], [1, 0]]
#Y = [[0, -1j], [1j, 0]]
Z = [[1, 0], [0, -1]]
I = [[1, 0], [0, 1]]
# + 0.5 * np.kron(Y, X)# + 0.3 * np.kron(Z, X) + 0.4 * np.kron(Z, Y)
h1 = np.kron(I, Z)
# np.random.seed(2)
temp = np.random.random((2**SIZE, 2**SIZE))
h1 = temp + temp.T
qubit_op = Operator(matrix=h1)
# qubit_op_jw.chop_by_threshold(10 ** -10)
if qubit_op.grouped_paulis is None:
qubit_op._matrix_to_paulis()
qubit_op._paulis_to_grouped_paulis()
for ps in qubit_op.grouped_paulis:
for p1 in ps:
for p2 in ps:
if p1 != p2:
np.testing.assert_almost_equal(
p1[1].to_matrix() @ p2[1].to_matrix(),
p2[1].to_matrix() @ p1[1].to_matrix())
state_in = Custom(SIZE, state='random')
evo_time = 1
num_time_slices = 3
# announces params
self.log.debug('evo time: {}'.format(evo_time))
self.log.debug('num time slices: {}'.format(num_time_slices))
self.log.debug('state_in: {}'.format(state_in._state_vector))
# get the exact state_out from raw matrix multiplication
state_out_exact = qubit_op.evolve(state_in.construct_circuit('vector'),
evo_time, 'matrix', 0)
# self.log.debug('exact:\n{}'.format(state_out_exact))
qubit_op_temp = copy.deepcopy(qubit_op)
for grouping in ['default', 'random']:
self.log.debug('Under {} paulis grouping:'.format(grouping))
for expansion_mode in ['trotter', 'suzuki']:
self.log.debug(
'Under {} expansion mode:'.format(expansion_mode))
for expansion_order in [
1, 2, 3, 4
] if expansion_mode == 'suzuki' else [1]:
# assure every time the operator from the original one
qubit_op = copy.deepcopy(qubit_op_temp)
if expansion_mode == 'suzuki':
self.log.debug(
'With expansion order {}:'.format(expansion_order))
state_out_matrix = qubit_op.evolve(
state_in.construct_circuit('vector'),
evo_time,
'matrix',
num_time_slices,
paulis_grouping=grouping,
expansion_mode=expansion_mode,
expansion_order=expansion_order)
quantum_registers = QuantumRegister(qubit_op.num_qubits)
qc = state_in.construct_circuit('circuit',
quantum_registers)
qc += qubit_op.evolve(
None,
evo_time,
'circuit',
num_time_slices,
quantum_registers=quantum_registers,
paulis_grouping=grouping,
expansion_mode=expansion_mode,
expansion_order=expansion_order,
)
job = q_execute(qc,
get_aer_backend('statevector_simulator'))
state_out_circuit = np.asarray(
job.result().get_statevector(qc, decimals=16))
self.log.debug(
'The fidelity between exact and matrix: {}'.format(
state_fidelity(state_out_exact, state_out_matrix)))
self.log.debug(
'The fidelity between exact and circuit: {}'.format(
state_fidelity(state_out_exact,
state_out_circuit)))
f_mc = state_fidelity(state_out_matrix, state_out_circuit)
self.log.debug(
'The fidelity between matrix and circuit: {}'.format(
f_mc))
self.assertAlmostEqual(f_mc, 1)
def test_qubits_5_given_vector(self):
self.custom = Custom(5, state_vector=[1.0] * 32)
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_almost_equal(cct, [0.1767767] * 32)
def test_qubits_2_zero_vector_wrong_cct_mode(self):
self.custom = Custom(5, state='zero')
with self.assertRaises(ValueError):
cct = self.custom.construct_circuit('matrix')
