def test_eoh(self):
""" EOH test """
size = 2
aqua_globals.random_seed = 0
temp = aqua_globals.random.random_sample((2**size, 2**size))
h_1 = temp + temp.T
qubit_op = MatrixOperator(matrix=h_1)
temp = aqua_globals.random.random_sample((2**size, 2**size))
h_1 = temp + temp.T
evo_op = MatrixOperator(matrix=h_1)
state_in = Custom(size, state='random')
evo_time = 1
num_time_slices = 100
eoh = EOH(qubit_op,
state_in,
evo_op,
evo_time=evo_time,
num_time_slices=num_time_slices)
backend = BasicAer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend, shots=1)
# self.log.debug('state_out:\n\n')
ret = eoh.run(quantum_instance)
self.log.debug('Evaluation result: %s', ret)
def test_eoh(self):
SIZE = 2
temp = np.random.random((2**SIZE, 2**SIZE))
h1 = temp + temp.T
qubit_op = MatrixOperator(matrix=h1)
temp = np.random.random((2**SIZE, 2**SIZE))
h1 = temp + temp.T
evo_op = MatrixOperator(matrix=h1)
state_in = Custom(SIZE, state='random')
evo_time = 1
num_time_slices = 100
eoh = EOH(qubit_op,
state_in,
evo_op,
evo_time=evo_time,
num_time_slices=num_time_slices)
backend = BasicAer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend, shots=1)
# self.log.debug('state_out:\n\n')
ret = eoh.run(quantum_instance)
self.log.debug('Evaluation result: {}'.format(ret))
def test_eoh(self, mode):
""" EOH test """
size = 2
aqua_globals.random_seed = 0
temp = aqua_globals.random.random((2 ** size, 2 ** size))
h_1 = temp + temp.T
qubit_op = MatrixOperator(matrix=h_1)
temp = aqua_globals.random.random((2 ** size, 2 ** size))
h_1 = temp + temp.T
evo_op = MatrixOperator(matrix=h_1)
if mode == 'initial_state':
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=DeprecationWarning)
state_in = Custom(size, state='random')
else:
random_state = aqua_globals.random.random(2 ** size)
random_state = random_state / np.linalg.norm(random_state)
state_in = QuantumCircuit(size)
state_in.initialize(random_state, range(size))
evo_time = 1
num_time_slices = 100
eoh = EOH(qubit_op, state_in, evo_op, evo_time=evo_time, num_time_slices=num_time_slices)
backend = BasicAer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend, shots=1)
# self.log.debug('state_out:\n\n')
ret = eoh.run(quantum_instance)
self.log.debug('Evaluation result: %s', ret)
def setUp(self):
super().setUp()
seed = 0
aqua_globals.random_seed = seed
self.num_qubits = 3
m_size = np.power(2, self.num_qubits)
matrix = aqua_globals.random.rand(m_size, m_size)
self.qubit_op = MatrixOperator(matrix=matrix)
def setUp(self):
super().setUp()
qubit_op_simple = MatrixOperator(matrix=TestIQPE.H1)
qubit_op_simple = op_converter.to_weighted_pauli_operator(qubit_op_simple)
qubit_op_h2_with_2_qubit_reduction = WeightedPauliOperator.from_dict(TestIQPE.PAULI_DICT)
qubit_op_zz = WeightedPauliOperator.from_dict(TestIQPE.PAULI_DICT_ZZ)
self._dict = {
'QUBIT_OP_SIMPLE': qubit_op_simple.to_opflow(),
'QUBIT_OP_ZZ': qubit_op_zz.to_opflow(),
'QUBIT_OP_H2_WITH_2_QUBIT_REDUCTION': qubit_op_h2_with_2_qubit_reduction.to_opflow()
}
def test_ee(self):
""" EE test """
dummy_operator = MatrixOperator([[1]])
ee = NumPyMinimumEigensolver()
output = ee.compute_minimum_eigenvalue(self.qubit_op)
self.assertAlmostEqual(output.eigenvalue, -1.85727503)
def test_vqe_reuse(self):
""" Test vqe reuse """
vqe = VQE()
with self.assertRaises(AquaError):
_ = vqe.run()
num_qubits = self.qubit_op.num_qubits
var_form = RY(num_qubits, depth=3)
vqe.var_form = var_form
with self.assertRaises(AquaError):
_ = vqe.run()
vqe.operator = self.qubit_op
with self.assertRaises(AquaError):
_ = vqe.run()
qinst = QuantumInstance(BasicAer.get_backend('statevector_simulator'))
vqe.quantum_instance = qinst
result = vqe.run()
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=5)
operator = MatrixOperator(np.array([[1, 0, 0, 0],
[0, -1, 0, 0],
[0, 0, 2, 0],
[0, 0, 0, 3]]))
vqe.operator = operator
result = vqe.run()
self.assertAlmostEqual(result.eigenvalue.real, -1.0, places=5)
def run_qpe_algo(self,
num_ancillae: int = 1,
backend: BaseBackend = None,
print_eig: bool = False,
shots: int = 1024) -> dict:
""" Runs the QPE algorithm directly.
Args:
num_ancillae (int, optional): ancillary qubit number, the higher the more accurate, but use more computing resources. Defaults to 1.
backend (BaseBackend, optional): Choose the backend to run this algorithm. Defaults to None.
print_eig (bool, optional): whether or not print the eigenvalue. Defaults to False.
shots (int, optional): Indicate how many shots to take. Defaults to 1024.
Returns:
dict: returns the results dictionary of the QPE algorithm. Use the 'energy' key to get the eigenvalue.
"""
if backend is None: # Default backend to Aer.get_backend('qasm_simulator').
backend = Aer.get_backend('qasm_simulator')
# QPE
m, n = self.matrix.shape
qpe = QPE(operator=MatrixOperator(matrix=self.matrix),
state_in=Custom(m),
iqft=Standard(num_ancillae),
num_time_slices=50,
num_ancillae=num_ancillae,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
results = qpe.run(
QuantumInstance(backend=backend,
skip_qobj_validation=False,
shots=shots))
if print_eig: print("ENERGY:", results['energy'])
return results
def calc_classical_eig(self,
print_results: bool = False,
solver: str = "exact_solver") -> list:
""" Prints Eigenvalues generated by the selected classical algorithm.
Args:
print_results (bool, optional): print the eigenvalues or not. Defaults to False.
solver (str, optional): can be "exact_solver" or "numpy". Defaults to "exact_solver"
"""
results = []
print("=======TRADITIONAL=======")
if solver == "exact_solver":
# Classical Eigensolver in Qiskit
eig_solver = ExactEigensolver(MatrixOperator(self.matrix), 2)
results = eig_solver.run()['eigvals']
print("EXACTSOLVER:", results)
elif solver == "numpy":
# Classical Eigenvalue Decomposition in NumPy
results = list(np.linalg.eig(self.matrix)[0])
print("EIGENVALUES:", results)
# print("EIGENVECTORS:", list(list(item) for item in np.linalg.eig(matrix)[1]))
else:
print("No solver found. Check your solver name.")
print("=========================")
return results
def execute_qpe_circuit(self,
num_ancillae: int = 1,
backend: BaseBackend = None,
shots: int = 1024,
print_eig: bool = False) -> Result:
"""Runs the QPE algorithm by constructing the circuit explicitly.
Args:
num_ancillae (int, optional): ancillary qubit number, the higher the more accurate, but use more computing resources. Defaults to 1.
backend (BaseBackend, optional): Choose the backend to run this algorithm. Defaults to None.
shots (int, optional): Indicate how many shots to take. Defaults to 1024.
print_eig (bool, optional): whether or not print the eigenvalue. Defaults to False.
Returns:
Result: returns a Qiskit.result object. Use get_counts() to get a dictionary for the qubits' probabilities.
"""
if backend is None: # Default backend to Aer.get_backend('qasm_simulator').
backend = Aer.get_backend('qasm_simulator')
# QPE Circuit
m, n = self.matrix.shape
qpe = QPE(operator=MatrixOperator(matrix=self.matrix),
state_in=Custom(m),
iqft=Standard(num_ancillae),
num_time_slices=50,
num_ancillae=num_ancillae,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
results = execute(qpe.construct_circuit(measurement=True),
backend=backend).result()
if print_eig: print(results.get_counts())
return results
def init_params(cls, params, matrix): # pylint: disable=arguments-differ
"""
Initialize via parameters dictionary and algorithm input instance
Args:
params (dict): parameters dictionary
matrix (numpy.ndarray): two dimensional array which represents the operator
Returns:
EigsQPE: instance of this class
Raises:
AquaError: Operator instance is required
"""
if matrix is None:
raise AquaError("Operator instance is required.")
if not isinstance(matrix, np.ndarray):
matrix = np.array(matrix)
eigs_params = params.get(Pluggable.SECTION_KEY_EIGS)
args = {k: v for k, v in eigs_params.items() if k != 'name'}
num_ancillae = eigs_params['num_ancillae']
negative_evals = eigs_params['negative_evals']
# Adding an additional flag qubit for negative eigenvalues
if negative_evals:
num_ancillae += 1
args['num_ancillae'] = num_ancillae
args['operator'] = MatrixOperator(matrix=matrix)
# Set up iqft, we need to add num qubits to params which is our num_ancillae bits here
iqft_params = params.get(Pluggable.SECTION_KEY_IQFT)
iqft_params['num_qubits'] = num_ancillae
args['iqft'] = get_pluggable_class(
PluggableType.IQFT, iqft_params['name']).init_params(params)
# For converting the encoding of the negative eigenvalues, we need two
# additional instances for QFT and IQFT
if negative_evals:
ne_params = params
qft_num_qubits = iqft_params['num_qubits']
ne_qft_params = params.get(Pluggable.SECTION_KEY_QFT)
ne_qft_params['num_qubits'] = qft_num_qubits - 1
ne_iqft_params = params.get(Pluggable.SECTION_KEY_IQFT)
ne_iqft_params['num_qubits'] = qft_num_qubits - 1
ne_params['qft'] = ne_qft_params
ne_params['iqft'] = ne_iqft_params
args['ne_qfts'] = [
get_pluggable_class(
PluggableType.QFT,
ne_qft_params['name']).init_params(ne_params),
get_pluggable_class(
PluggableType.IQFT,
ne_iqft_params['name']).init_params(ne_params)
]
else:
args['ne_qfts'] = [None, None]
return cls(**args)
def Generate_op(op,*args, **kwargs):
parameter = kwargs['parameter']
ham = kwargs['ham']
energy_step_tol = kwargs['energy_step_tol']
mat = np.identity(2**op.num_qubits)
Iden = to_weighted_pauli_operator(MatrixOperator(mat)) #creates random hamiltonian from random matrix "mat"
#return np.exp(1j*parameter*op)*ham*np.exp(-1j*parameter*op).chop(threshold=energy_step_tol, copy=True)
return (np.cos(parameter)*Iden + 1j*np.sin(parameter)*op)*ham*(np.cos(parameter)*Iden - 1j*np.sin(parameter)*op).chop(threshold=energy_step_tol, copy=True)
def to_matrix_operator_from_WeightedPauliOperator(operator):
"""
Copy and paste from https://github.com/Qiskit/qiskit-aqua/blob/master/qiskit/aqua/operators/op_converter.py of version 0.6.1
Converting a given operator to `MatrixOperator`
Args:
operator (WeightedPauliOperator):
one of supported operator type
Returns:
MatrixOperator: the converted matrix operator
Raises:
AquaError: Unsupported type to convert
"""
if operator.is_empty():
return MatrixOperator(None)
hamiltonian = 0
for weight, pauli in operator.paulis:
hamiltonian += weight * pauli.to_spmatrix()
return MatrixOperator(matrix=hamiltonian, z2_symmetries=operator.z2_symmetries,
name=operator.name)
def setUp(self):
super().setUp()
seed = 0
aqua_globals.random_seed = seed
self.num_qubits = 2
m_size = np.power(2, self.num_qubits)
matrix = aqua_globals.random.rand(m_size, m_size)
self.mat_op = MatrixOperator(matrix=matrix)
paulis = [Pauli.from_label(pauli_label)
for pauli_label in itertools.product('IXYZ', repeat=self.num_qubits)]
weights = aqua_globals.random.random_sample(len(paulis))
self.pauli_op = WeightedPauliOperator.from_list(paulis, weights)
def create_eigs(matrix, num_auxiliary, num_time_slices, negative_evals):
ne_qfts = [None, None]
if negative_evals:
num_auxiliary += 1
ne_qfts = [QFT(num_auxiliary - 1), QFT(num_auxiliary - 1).inverse()]
return EigsQPE(MatrixOperator(matrix=matrix),
QFT(num_auxiliary).inverse(),
num_time_slices=num_time_slices,
num_ancillae=num_auxiliary,
expansion_mode='suzuki',
expansion_order=2,
evo_time=None, # This is t, can set to: np.pi*3/4
negative_evals=negative_evals,
ne_qfts=ne_qfts)
def create_eigs(matrix, num_ancillae, num_time_slices, negative_evals):
ne_qfts = [None, None]
if negative_evals:
num_ancillae += 1
ne_qfts = [QFT(num_ancillae - 1), QFT(num_ancillae - 1).inverse()]
ret = EigsQPE(MatrixOperator(matrix=matrix),
QFT(num_ancillae).inverse(),
num_time_slices=num_time_slices,
num_ancillae=num_ancillae,
expansion_mode='suzuki',
expansion_order=2,
evo_time=None, # This is t, can set to: np.pi*3/4
negative_evals=negative_evals,
ne_qfts=ne_qfts)
#print(ret.construct_circuit(mode='circuit'))
return ret
def _create_eigs(matrix, num_ancillae, negative_evals):
# Adding an additional flag qubit for negative eigenvalues
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),
num_time_slices=1,
num_ancillae=num_ancillae,
expansion_mode='suzuki',
expansion_order=2,
evo_time=None,
negative_evals=negative_evals,
ne_qfts=ne_qfts)
def create_eigs(self, matrix, num_ancillae, num_time_slices,
negative_evals):
ne_qfts = [None, None]
if negative_evals:
num_ancillae += 1
ne_qfts = [QFT(num_ancillae - 1), QFT(num_ancillae - 1).inverse()]
return EigsQPE(MatrixOperator(matrix=matrix),
QFT(num_ancillae).inverse(),
num_time_slices=num_time_slices,
num_ancillae=num_ancillae,
expansion_mode='suzuki',
expansion_order=2,
evo_time=np.pi * 3 / 4,
negative_evals=negative_evals,
ne_qfts=ne_qfts)
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): sparsity of matrix < 1
Returns:
scipy.sparse.csr_matrix: matrix
"""
# pylint: disable=import-outside-toplevel
from qiskit.aqua.operators import MatrixOperator
from qiskit.aqua.operators.legacy.op_converter import to_weighted_pauli_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
# pylint: disable=invalid-name
op = MatrixOperator(matrix=mat)
op = to_weighted_pauli_operator(op)
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 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),
num_time_slices=50,
num_ancillae=num_ancillae,
expansion_mode='suzuki',
expansion_order=2,
evo_time=None,
negative_evals=negative_evals,
ne_qfts=ne_qfts)
def construct_wpo_operator(self):
"""Returns Weighted Pauli Operator (WPO) constructed from Hamiltonian
text file.
Args:
None
Returns:
qubit_op (QISKit WPO object): Weighted Pauli Operator
"""
# Loading matrix representation of Hamiltonian txt file
H = np.loadtxt(self.file_path)
# Converting Hamiltonian to Matrix Operator
qubit_op = MatrixOperator(matrix=H)
# Converting to Pauli Operator
qubit_op = to_weighted_pauli_operator(qubit_op)
self.num_qubits = qubit_op.num_qubits
self.num_paulis = len(qubit_op.paulis)
return qubit_op
def _create_eigs(matrix, num_ancillae, negative_evals):
# Adding an additional flag qubit for negative eigenvalues
ne_qfts = [None, None]
if negative_evals:
num_ancillae += 1
ne_qfts = [QFT(num_ancillae - 1), QFT(num_ancillae - 1).inverse()]
iqft = QFT(num_ancillae).inverse()
eigs_qpe = EigsQPE(MatrixOperator(matrix=matrix),
iqft,
num_time_slices=1,
num_ancillae=num_ancillae,
expansion_mode='suzuki',
expansion_order=2,
evo_time=None,
negative_evals=negative_evals,
ne_qfts=ne_qfts)
return eigs_qpe
def _create_eigs(matrix,
num_ancillae,
negative_evals,
use_circuit_library=True):
# Adding an additional flag qubit for negative eigenvalues
ne_qfts = [None, None]
if not use_circuit_library:
warnings.filterwarnings('ignore', category=DeprecationWarning)
if negative_evals:
num_ancillae += 1
if use_circuit_library:
ne_qfts = [
QFT(num_ancillae - 1),
QFT(num_ancillae - 1).inverse()
]
else:
ne_qfts = [
StandardQFTS(num_ancillae - 1),
StandardIQFTS(num_ancillae - 1)
]
if use_circuit_library:
iqft = QFT(num_ancillae).inverse()
else:
iqft = StandardIQFTS(num_ancillae)
eigs_qpe = EigsQPE(MatrixOperator(matrix=matrix),
iqft,
num_time_slices=1,
num_ancillae=num_ancillae,
expansion_mode='suzuki',
expansion_order=2,
evo_time=None,
negative_evals=negative_evals,
ne_qfts=ne_qfts)
if not use_circuit_library:
warnings.filterwarnings('always', category=DeprecationWarning)
return eigs_qpe
class TestMatrixOperator(QiskitAquaTestCase):
"""MatrixOperator tests."""
def setUp(self):
super().setUp()
seed = 0
np.random.seed(seed)
aqua_globals.random_seed = seed
self.num_qubits = 3
m_size = np.power(2, self.num_qubits)
matrix = np.random.rand(m_size, m_size)
self.qubit_op = MatrixOperator(matrix=matrix)
def test_num_qubits(self):
op = MatrixOperator(matrix=np.zeros((2, 2)))
self.assertEqual(op.num_qubits, 0)
self.assertEqual(self.qubit_op.num_qubits, self.num_qubits)
def test_is_empty(self):
op = MatrixOperator(matrix=np.zeros((2, 2)))
self.assertTrue(op.is_empty())
self.assertFalse(self.qubit_op.is_empty())
def test_invalid_primitive(self):
"""Test invalid MatrixOp construction"""
msg = "MatrixOp can only be instantiated with " \
"['list', 'ndarray', 'spmatrix', 'Operator'], not "
with self.assertRaises(TypeError) as cm:
_ = MatrixOp('invalid')
self.assertEqual(str(cm.exception), msg + "'str'")
with self.assertRaises(TypeError) as cm:
_ = MatrixOp(MatrixOperator(np.eye(2)))
self.assertEqual(str(cm.exception), msg + "'MatrixOperator'")
with self.assertRaises(TypeError) as cm:
_ = MatrixOp(None)
self.assertEqual(str(cm.exception), msg + "'NoneType'")
with self.assertRaises(TypeError) as cm:
_ = MatrixOp(2.0)
self.assertEqual(str(cm.exception), msg + "'float'")
def test_is_empty(self):
""" is empty test """
op = MatrixOperator(matrix=np.zeros((2, 2)))
self.assertTrue(op.is_empty())
self.assertFalse(self.qubit_op.is_empty())
def test_num_qubits(self):
""" num qubits test """
op = MatrixOperator(matrix=np.zeros((2, 2)))
self.assertEqual(op.num_qubits, 0)
self.assertEqual(self.qubit_op.num_qubits, self.num_qubits)
def run_exp(num_reps=1):
# choice of Hi basis
H_basis = [Pauli.from_label(p) for p in ['II', 'ZI', 'IZ', 'ZZ', 'YY', 'XX']]
num_qubits = 2
evo_time = 1
epsilon = 0.1
L = 32 ## number of local hamiltonian terms
############################################################
# Generate a random Hamiltonian H as the sum of m basis Hi operators
############################################################
hs = np.random.random(L)
indexes = np.random.randint(low=0, high=6, size=L)
## H in matrix form
H_matrix = np.zeros((2 ** num_qubits, 2 ** num_qubits))
## H as a list of pauli operators (unweighted)
H_list = []
for i in range(L):
H_matrix = H_matrix + hs[i] * H_basis[indexes[i]].to_matrix()
H_list.append(H_basis[indexes[i]])
print('matrix H: \n', H_matrix)
# H as a pauli operator
H_qubitOp = op_converter.to_weighted_pauli_operator(MatrixOperator(matrix=H_matrix))
# Generate an initial state
state_in = Custom(num_qubits, state='random')
############################################################
# Ground truth and benchmarks
############################################################
# Ground truth
state_in_vec = state_in.construct_circuit('vector')
groundtruth = expm(-1.j * H_matrix * evo_time) @ state_in_vec
print('The directly computed groundtruth evolution result state is')
print('{}\n.'.format(groundtruth))
# Build circuit using Qiskit's evolve algorithm, which based on Trotter-Suzuki.
quantum_registers = QuantumRegister(num_qubits)
circuit = state_in.construct_circuit('circuit', quantum_registers)
circuit += H_qubitOp.evolve(
None, evo_time, num_time_slices=10,
quantum_registers=quantum_registers,
expansion_mode='suzuki',
expansion_order=1
)
# Simulate Trotter-Suzuki circuit and print it
backend = BasicAer.get_backend('statevector_simulator')
job = q_execute(circuit, backend)
circuit_execution_result = np.asarray(job.result().get_statevector(circuit))
print('The simulated (suzuki) evolution result state is')
print('{}\n'.format(circuit_execution_result))
# The difference between the ground truth and the simulated state
# measured by "Fidelity"
fidelity_suzuki = state_fidelity(groundtruth, circuit_execution_result)
print('Fidelity between the groundtruth and the circuit result states is {}.'.format(fidelity_suzuki))
print('\n')
############################################################
# Our qdrift implementation
############################################################
quantum_registers = QuantumRegister(num_qubits)
circuit = state_in.construct_circuit('circuit', quantum_registers)
# Contruct the circuit which implements qdrift
circuit = time_evolve_qubits(quantum_registers, circuit, num_qubits, H_list, hs, evo_time, epsilon, num_reps)
# Simulate circuit and print it
backend = BasicAer.get_backend('statevector_simulator')
job = q_execute(circuit, backend)
circuit_execution_result = np.asarray(job.result().get_statevector(circuit))
print('The simulated (qdrift) evolution result state is\n{}.'.format(circuit_execution_result))
print('\n')
# Measure the fidelity
fidelity_qdrift = state_fidelity(groundtruth, circuit_execution_result)
print('Fidelity between the groundtruth and the circuit result states is {}.'.format(fidelity_qdrift))
print('\n')
print('benchmark, suzuki:', fidelity_suzuki)
print('qdrift:', fidelity_qdrift)
return fidelity_qdrift, fidelity_suzuki
from parameterized import parameterized
from qiskit import BasicAer
from qiskit.aqua import QuantumInstance
from qiskit.aqua.operators import MatrixOperator, WeightedPauliOperator, op_converter
from qiskit.aqua.utils import decimal_to_binary
from qiskit.aqua.algorithms import ExactEigensolver
from qiskit.aqua.algorithms import QPE
from qiskit.aqua.components.iqfts import Standard
from qiskit.aqua.components.initial_states import Custom
X = np.array([[0, 1], [1, 0]])
Y = np.array([[0, -1j], [1j, 0]])
Z = np.array([[1, 0], [0, -1]])
_I = np.array([[1, 0], [0, 1]])
H1 = X + Y + Z + _I
QUBIT_OP_SIMPLE = MatrixOperator(matrix=H1)
QUBIT_OP_SIMPLE = op_converter.to_weighted_pauli_operator(QUBIT_OP_SIMPLE)
PAULI_DICT = {
'paulis': [{
"coeff": {
"imag": 0.0,
"real": -1.052373245772859
},
"label": "II"
}, {
"coeff": {
"imag": 0.0,
"real": 0.39793742484318045
},
"label": "IZ"
from qiskit.aqua import QuantumInstance
from qiskit.aqua.operators import MatrixOperator, WeightedPauliOperator, op_converter
from qiskit.aqua.utils import decimal_to_binary
from qiskit.aqua.algorithms import ExactEigensolver
from qiskit.aqua.algorithms import QPE
from qiskit.aqua.components.iqfts import Standard
from qiskit.aqua.components.initial_states import Custom
from test.aqua.common import QiskitAquaTestCase
X = np.array([[0, 1], [1, 0]])
Y = np.array([[0, -1j], [1j, 0]])
Z = np.array([[1, 0], [0, -1]])
_I = np.array([[1, 0], [0, 1]])
h1 = X + Y + Z + _I
qubit_op_simple = MatrixOperator(matrix=h1)
qubit_op_simple = op_converter.to_weighted_pauli_operator(qubit_op_simple)
pauli_dict = {
'paulis': [
{"coeff": {"imag": 0.0, "real": -1.052373245772859}, "label": "II"},
{"coeff": {"imag": 0.0, "real": 0.39793742484318045}, "label": "IZ"},
{"coeff": {"imag": 0.0, "real": -0.39793742484318045}, "label": "ZI"},
{"coeff": {"imag": 0.0, "real": -0.01128010425623538}, "label": "ZZ"},
{"coeff": {"imag": 0.0, "real": 0.18093119978423156}, "label": "XX"}
]
}
qubit_op_h2_with_2_qubit_reduction = WeightedPauliOperator.from_dict(pauli_dict)
pauli_dict_zz = {
