def test_save_expval_var_nonstabilizer_hermitian(self, qubits):
"""Test expval_var for non-stabilizer circuit and Hermitian operator"""
SUPPORTED_METHODS = [
'automatic', 'statevector', 'statevector_gpu', 'statevector_thrust',
'density_matrix', 'density_matrix_gpu', 'density_matrix_thrust',
'matrix_product_state'
]
SEED = 8124
# Stabilizer test circuit
state_circ = QuantumVolume(3, 1, seed=SEED)
oper = qi.random_hermitian(4, traceless=True, seed=SEED)
state = qi.Statevector(state_circ)
expval = state.expectation_value(oper, qubits).real
variance = state.expectation_value(oper ** 2, qubits).real - expval ** 2
target = [expval, variance]
# Snapshot circuit
opts = self.BACKEND_OPTS.copy()
method = opts.get('method', 'automatic')
circ = transpile(state_circ, basis_gates=['u1', 'u2', 'u3', 'cx', 'swap'])
circ.save_expectation_value_variance('expval', oper, qubits)
qobj = assemble(circ)
result = self.SIMULATOR.run(qobj, **opts).result()
if method not in SUPPORTED_METHODS:
self.assertFalse(result.success)
else:
self.assertTrue(result.success)
value = result.data(0)['expval']
self.assertTrue(allclose(value, target))
def test_save_expval_stabilizer_hermitian(self, qubits):
"""Test expval for stabilizer circuit and Hermitian operator"""
SUPPORTED_METHODS = [
'automatic', 'statevector', 'statevector_gpu', 'statevector_thrust',
'density_matrix', 'density_matrix_gpu', 'density_matrix_thrust',
'matrix_product_state', 'stabilizer'
]
SEED = 7123
# Stabilizer test circuit
state_circ = qi.random_clifford(3, seed=SEED).to_circuit()
oper = qi.random_hermitian(4, traceless=True, seed=SEED)
state = qi.Statevector(state_circ)
target = state.expectation_value(oper, qubits).real
# Snapshot circuit
opts = self.BACKEND_OPTS.copy()
method = opts.get('method', 'automatic')
circ = transpile(state_circ, basis_gates=[
'id', 'x', 'y', 'z', 'h', 's', 'sdg', 'cx', 'cz', 'swap'])
circ.save_expectation_value('expval', oper, qubits)
qobj = assemble(circ)
result = self.SIMULATOR.run(qobj, **opts).result()
if method not in SUPPORTED_METHODS:
self.assertFalse(result.success)
else:
self.assertTrue(result.success)
value = result.data(0)['expval']
self.assertAlmostEqual(value, target)
def test_diagonalizing_bogoliubov_transform_non_particle_number_conserving(self, n_orbitals):
"""Test diagonalizing Bogoliubov transform, non-particle-number-conserving case."""
hermitian_part = random_hermitian(n_orbitals).data
antisymmetric_part = _random_antisymmetric(n_orbitals)
constant = np.random.uniform(-10, 10)
quad_ham = QuadraticHamiltonian(hermitian_part, antisymmetric_part, constant=constant)
(
transformation_matrix,
orbital_energies,
transformed_constant,
) = quad_ham.diagonalizing_bogoliubov_transform()
left = transformation_matrix[:, :n_orbitals]
right = transformation_matrix[:, n_orbitals:]
full_transformation_matrix = np.block([[left, right], [right.conj(), left.conj()]])
eye = np.eye(n_orbitals, dtype=complex)
majorana_basis = np.block([[eye, eye], [1j * eye, -1j * eye]]) / np.sqrt(2)
basis_change = majorana_basis @ full_transformation_matrix @ majorana_basis.T.conj()
majorana_matrix, majorana_constant = quad_ham.majorana_form()
canonical = basis_change @ majorana_matrix @ basis_change.T
zero = np.zeros((n_orbitals, n_orbitals))
diagonal = np.diag(orbital_energies)
expected = np.block([[zero, diagonal], [-diagonal, zero]])
np.testing.assert_allclose(orbital_energies, np.sort(orbital_energies))
np.testing.assert_allclose(canonical, expected, atol=1e-7)
np.testing.assert_allclose(
transformed_constant, majorana_constant - 0.5 * np.sum(orbital_energies)
)
def test_save_expval_nonstabilizer_hermitian(self, qubits):
"""Test expval for non-stabilizer circuit and Hermitian operator"""
SUPPORTED_METHODS = [
'automatic', 'statevector', 'statevector_gpu', 'statevector_thrust',
'density_matrix', 'density_matrix_gpu', 'density_matrix_thrust',
'matrix_product_state'
]
SEED = 8124
# Stabilizer test circuit
state = QuantumVolume(3, 1, seed=SEED)
oper = qi.random_hermitian(4, traceless=True, seed=SEED)
target = qi.Statevector(state).expectation_value(oper, qubits).real
# Snapshot circuit
opts = self.BACKEND_OPTS.copy()
circ = transpile(state, self.SIMULATOR)
circ.save_expectation_value('expval', oper, qubits)
qobj = assemble(circ)
result = self.SIMULATOR.run(qobj, **opts).result()
method = opts.get('method', 'automatic')
if method not in SUPPORTED_METHODS:
self.assertFalse(result.success)
else:
self.assertTrue(result.success)
value = result.data(0)['expval']
self.assertAlmostEqual(value, target)
def test_save_expval_nonstabilizer_hermitian(self, method, device, qubits):
"""Test expval for non-stabilizer circuit and Hermitian operator"""
SEED = 8124
circ = QuantumVolume(3, 1, seed=SEED)
oper = qi.random_hermitian(4, traceless=True, seed=SEED)
self._test_save_expval(circ,
oper,
qubits,
False,
method=method,
device=device)
def test_save_expval_stabilizer_hermitian(self, method, device, qubits):
"""Test expval for stabilizer circuit and Hermitian operator"""
SEED = 7123
circ = qi.random_clifford(3, seed=SEED).to_circuit()
oper = qi.random_hermitian(4, traceless=True, seed=SEED)
self._test_save_expval(circ,
oper,
qubits,
False,
method=method,
device=device)
def test_no_side_effects(self):
"""Test that the routines don't mutate the input array."""
n_orbitals = 5
hermitian_part = random_hermitian(n_orbitals).data
constant = np.random.uniform(-10, 10)
quad_ham = QuadraticHamiltonian(hermitian_part, constant=constant)
transformation_matrix, _, _ = quad_ham.diagonalizing_bogoliubov_transform(
)
original = transformation_matrix.copy()
_ = BogoliubovTransform(transformation_matrix)
np.testing.assert_allclose(transformation_matrix, original, atol=1e-8)
def test_diagonalizing_bogoliubov_transform_particle_number_conserving(self, n_orbitals):
"""Test diagonalizing Bogoliubov transform, particle-number-conserving case."""
hermitian_part = random_hermitian(n_orbitals).data
constant = np.random.uniform(-10, 10)
quad_ham = QuadraticHamiltonian(hermitian_part, constant=constant)
(
transformation_matrix,
orbital_energies,
transformed_constant,
) = quad_ham.diagonalizing_bogoliubov_transform()
diagonalized = transformation_matrix @ hermitian_part.T @ transformation_matrix.T.conj()
np.testing.assert_allclose(orbital_energies, np.sort(orbital_energies))
np.testing.assert_allclose(diagonalized, np.diag(orbital_energies), atol=1e-7)
np.testing.assert_allclose(transformed_constant, constant)
def random_quadratic_hamiltonian(n_orbitals: int,
num_conserving: bool = False,
seed: Any = None) -> QuadraticHamiltonian:
"""Generate a random instance of QuadraticHamiltonian.
Args:
n_orbitals: the number of orbitals
num_conserving: whether the Hamiltonian should conserve particle number
seed: The pseudorandom number generator or seed. Should be an
instance of `np.random.Generator` or else a valid input to
`np.random.default_rng`
Returns:
The sampled QuadraticHamiltonian
"""
rng = parse_random_seed(seed)
hermitian_part = np.array(random_hermitian(n_orbitals, seed=rng))
antisymmetric_part = (None if num_conserving else
random_antisymmetric_matrix(n_orbitals, seed=rng))
constant = rng.standard_normal()
return QuadraticHamiltonian(hermitian_part=hermitian_part,
antisymmetric_part=antisymmetric_part,
constant=constant)
