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 = Aer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend, pass_manager=PassManager())
# self.log.debug('state_out:\n\n')
ret = eoh.run(quantum_instance)
self.log.debug('Evaluation result: {}'.format(ret))
def test_eoh(self):
SIZE = 2
temp = np.random.random((2**SIZE, 2**SIZE))
h1 = temp + temp.T
qubitOp = Operator(matrix=h1)
temp = np.random.random((2**SIZE, 2**SIZE))
h1 = temp + temp.T
evoOp = Operator(matrix=h1)
state_in = get_initial_state_instance('CUSTOM')
state_in.init_args(SIZE, state='random')
evo_time = 1
num_time_slices = 100
eoh = get_algorithm_instance('EOH')
eoh.setup_quantum_backend(skip_transpiler=True)
# self.log.debug('state_out:\n\n')
eoh.init_args(qubitOp, 'paulis', state_in, evoOp, evo_time,
num_time_slices)
ret = eoh.run()
self.log.debug('Evaluation result: {}'.format(ret))
def test_grouped_paulis(self):
n = 3 # number of qubits
pg = pauli_group(n, case=1)
self.assertTrue(pg != -1, "Error in pauli_group()")
pg = [[1.0, x] for x in pg] # create paulis with equal weight
self.log.debug("Number of Paulis: {}".format(len(pg)))
hamOpOriginal = Operator(paulis=pg, coloring=None)
hamOpOriginal._paulis_to_grouped_paulis()
gpOriginal = hamOpOriginal.grouped_paulis
hamOpNew = Operator(paulis=pg, coloring="largest-degree")
hamOpNew._paulis_to_grouped_paulis()
gpNew = hamOpNew.grouped_paulis
self.log.debug("#groups in original= {} #groups in new={}".format(len(gpOriginal), len(gpNew)))
self.log.debug("------- Original --------")
for each in gpOriginal:
for x in each:
self.log.debug('{} {}'.format(x[0], x[1].to_label()))
self.log.debug('---')
self.log.debug("-------- New ------------")
for each in gpNew:
for x in each:
self.log.debug('{} {}'.format(x[0], x[1].to_label()))
self.log.debug('---')
def __init__(self, cost_operator, p, initial_state=None):
self._cost_operator = cost_operator
self._p = p
self._initial_state = initial_state
self.num_parameters = 2 * p
self.parameter_bounds = [(0, np.pi)] * p + [(0, 2 * np.pi)] * p
self.preferred_init_points = [0] * p * 2
# prepare the mixer operator
v = np.zeros(self._cost_operator.num_qubits)
ws = np.eye(self._cost_operator.num_qubits)
self._mixer_operator = reduce(lambda x, y: x + y, [
Operator([[1, Pauli(v, ws[i, :])]])
for i in range(self._cost_operator.num_qubits)
])
def get_portfolio_qubitops(mu, sigma, q, budget, penalty):
# get problem dimension
n = len(mu)
e = np.ones(n)
E = np.matmul(np.asmatrix(e).T, np.asmatrix(e))
# map problem to Ising model
offset = -np.dot(
mu, e
) / 2 + penalty * budget**2 - budget * n * penalty + n**2 * penalty / 4 + q / 4 * np.dot(
e, np.dot(sigma, e))
mu_z = mu / 2 + budget * penalty * e - n * penalty / 2 * e - q / 2 * np.dot(
sigma, e)
sigma_z = penalty / 4 * E + q / 4 * sigma
# construct operator
pauli_list = []
for i in range(n):
i_ = i
# i_ = n-i-1
if np.abs(mu_z[i_]) > 1e-6:
xp = np.zeros(n, dtype=np.bool)
zp = np.zeros(n, dtype=np.bool)
zp[i_] = True
pauli_list.append([mu_z[i_], Pauli(zp, xp)])
for j in range(i):
j_ = j
# j_ = n-j-1
if np.abs(sigma_z[i_, j_]) > 1e-6:
xp = np.zeros(n, dtype=np.bool)
zp = np.zeros(n, dtype=np.bool)
zp[i_] = True
zp[j_] = True
pauli_list.append([2 * sigma_z[i_, j_], Pauli(zp, xp)])
offset += sigma_z[i_, i_]
return Operator(paulis=pauli_list), offset
def limit_paulis(mat, n=5, sparsity=None):
"""
Limits the number of Pauli basis matrices of a hermitian matrix to the n
highest magnitude ones.
Args:
mat (np.ndarray): Input matrix
n (int): number of surviving Pauli matrices (default=5)
sparsity (float < 1): sparsity of matrix
Returns:
scipy.sparse.csr_matrix
"""
from qiskit_aqua.operator import Operator
# Bringing matrix into form 2**Nx2**N
l = mat.shape[0]
if np.log2(l) % 1 != 0:
k = int(2**np.ceil(np.log2(l)))
m = np.zeros([k, k], dtype=np.complex128)
m[:l, :l] = mat
m[l:, l:] = np.identity(k-l)
mat = m
# Getting Pauli matrices
op = Operator(matrix=mat)
op._check_representation("paulis")
op._simplify_paulis()
paulis = sorted(op.paulis, key=lambda x: abs(x[0]), reverse=True)
g = 2**op.num_qubits
mat = scipy.sparse.csr_matrix(([], ([], [])), shape=(g, g),
dtype=np.complex128)
# Truncation
if sparsity is None:
for pa in paulis[:n]:
mat += pa[0]*pa[1].to_spmatrix()
else:
idx = 0
while mat[:l, :l].nnz/l**2 < sparsity:
mat += paulis[idx][0]*paulis[idx][1].to_spmatrix()
idx += 1
n = idx
mat = mat.toarray()
return mat[:l, :l]
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
qubitOp = Operator(matrix=h1)
# qubitOp_jw.chop_by_threshold(10 ** -10)
if qubitOp.grouped_paulis is None:
qubitOp._matrix_to_paulis()
qubitOp._paulis_to_grouped_paulis()
for ps in qubitOp.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 = get_initial_state_instance('CUSTOM')
state_in.init_args(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 = qubitOp.evolve(state_in.construct_circuit('vector'),
evo_time, 'matrix', 0)
# self.log.debug('exact:\n{}'.format(state_out_exact))
qubitOp_temp = copy.deepcopy(qubitOp)
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
qubitOp = copy.deepcopy(qubitOp_temp)
if expansion_mode == 'suzuki':
self.log.debug(
'With expansion order {}:'.format(expansion_order))
state_out_matrix = qubitOp.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(qubitOp.num_qubits)
qc = state_in.construct_circuit('circuit',
quantum_registers)
qc += qubitOp.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, qiskit.Aer.get_backend('statevector_simulator'))
state_out_circuit = np.asarray(
job.result().get_statevector(qc))
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 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
"""
"label": "XX"
}]
}
# ======================
# setting up the circuit
# ======================
# define the initial state
init_state = Zero(num_qubits)
# get a variational ansatz
ansatz = RY(num_qubits, initial_state=init_state)
# operator from hamiltonian
qubit_op = Operator.load_from_dict(pauli_dict)
# get an optimizer
optimizer = COBYLA(maxiter=1000, disp=True)
# form the algorithm
vqe = VQE(qubit_op, ansatz, optimizer)
# get a backend
backend = get_aer_backend("statevector_simulator")
# get a quantum instance
qinstance = QuantumInstance(backend, shots=1024)
# ===================
# do the optimization
