def test_interaction_operator(self): for n_orbitals, real, _ in itertools.product((1, 2, 5), (True, False), range(5)): operator = random_interaction_operator(n_orbitals, real=real) normal_ordered_operator = normal_ordered(operator) expected_qubit_operator = jordan_wigner(operator) actual_qubit_operator = jordan_wigner(normal_ordered_operator) assert expected_qubit_operator == actual_qubit_operator two_body_tensor = normal_ordered_operator.two_body_tensor n_orbitals = len(two_body_tensor) ones = numpy.ones((n_orbitals, ) * 2) triu = numpy.triu(ones, 1) shape = (n_orbitals**2, 1) mask = (triu.reshape(shape) * ones.reshape(shape[::-1]) + ones.reshape(shape) * triu.reshape(shape[::-1])).reshape( (n_orbitals, ) * 4) assert numpy.allclose(mask * two_body_tensor, numpy.zeros((n_orbitals, ) * 4)) for term in normal_ordered_operator: order = len(term) // 2 left_term, right_term = term[:order], term[order:] assert all(i[1] == 1 for i in left_term) assert all(i[1] == 0 for i in right_term) assert left_term == tuple(sorted(left_term, reverse=True)) assert right_term == tuple(sorted(right_term, reverse=True))
def test_hermitian_conjugated_interaction_operator(self): for n_orbitals, _ in itertools.product((1, 2, 5), range(5)): operator = random_interaction_operator(n_orbitals) qubit_operator = jordan_wigner(operator) conjugate_operator = hermitian_conjugated(operator) conjugate_qubit_operator = jordan_wigner(conjugate_operator) assert hermitian_conjugated( qubit_operator) == conjugate_qubit_operator
def test_exception(self): n_qubits = 6 random_operator = get_fermion_operator( random_interaction_operator(n_qubits)) bad_term = ((2, 1), (3, 1)) random_operator += FermionOperator(bad_term) with self.assertRaises(OperatorSpecificationError): chemist_operator = chemist_ordered(random_operator)
def test_convert_forward_back(self): n_qubits = 6 random_operator = get_fermion_operator( random_interaction_operator(n_qubits)) chemist_operator = chemist_ordered(random_operator) normalized_chemist = normal_ordered(chemist_operator) difference = normalized_chemist - normal_ordered(random_operator) self.assertAlmostEqual(0., difference.induced_norm())
def test_one_body_square_decomposition(self): # Initialize a random two-body FermionOperator. n_qubits = 4 random_operator = get_fermion_operator( random_interaction_operator(n_qubits, seed=17004)) # Convert to chemist tensor. constant, one_body_coefficients, chemist_tensor = ( get_chemist_two_body_coefficients(random_operator)) # Perform decomposition. eigenvalues, one_body_squares, trunc_error = ( low_rank_two_body_decomposition(chemist_tensor)) # Build back two-body component. for l in range(n_qubits**2): # Get the squared one-body operator. one_body_operator = FermionOperator() for p, q in itertools.product(range(n_qubits), repeat=2): term = ((p, 1), (q, 0)) coefficient = one_body_squares[l, p, q] one_body_operator += FermionOperator(term, coefficient) one_body_squared = one_body_operator**2 # Get the squared one-body operator via one-body decomposition. density_density_matrix, basis_transformation_matrix = ( prepare_one_body_squared_evolution(one_body_squares[l])) two_body_operator = FermionOperator() for p, q in itertools.product(range(n_qubits), repeat=2): term = ((p, 1), (p, 0), (q, 1), (q, 0)) coefficient = density_density_matrix[p, q] two_body_operator += FermionOperator(term, coefficient) # Confirm that the rotations diagonalize the one-body squares. hopefully_diagonal = basis_transformation_matrix.dot( numpy.dot( one_body_squares[l], numpy.transpose( numpy.conjugate(basis_transformation_matrix)))) diagonal = numpy.diag(hopefully_diagonal) difference = hopefully_diagonal - numpy.diag(diagonal) self.assertAlmostEqual(0., numpy.amax(numpy.absolute(difference))) density_density_alternative = numpy.outer(diagonal, diagonal) difference = density_density_alternative - density_density_matrix self.assertAlmostEqual(0., numpy.amax(numpy.absolute(difference))) # Test spectra. one_body_squared_spectrum = eigenspectrum(one_body_squared) two_body_spectrum = eigenspectrum(two_body_operator) difference = two_body_spectrum - one_body_squared_spectrum self.assertAlmostEqual(0., numpy.amax(numpy.absolute(difference)))
def test_exception(self): # Initialize a bad FermionOperator. n_qubits = 4 random_interaction = random_interaction_operator(n_qubits, seed=36229) random_fermion = get_fermion_operator(random_interaction) bad_term = ((1, 1), (2, 1)) random_fermion += FermionOperator(bad_term) # Check for exception. with self.assertRaises(TypeError): fo_constant, fo_one_body_coefficients, fo_chemist_tensor = ( get_chemist_two_body_coefficients(random_fermion))
def test_operator_consistency_w_spin(self): # Initialize a random InteractionOperator and FermionOperator. n_orbitals = 3 n_qubits = 2 * n_orbitals random_interaction = random_interaction_operator(n_orbitals, expand_spin=True, real=False, seed=8) random_fermion = get_fermion_operator(random_interaction) # Convert to chemist ordered tensor. one_body_correction, chemist_tensor = \ get_chemist_two_body_coefficients( random_interaction.two_body_tensor, spin_basis=True) # Convert output to FermionOperator. output_operator = FermionOperator((), random_interaction.constant) # Convert one-body. one_body_coefficients = (random_interaction.one_body_tensor + one_body_correction) for p, q in itertools.product(range(n_qubits), repeat=2): term = ((p, 1), (q, 0)) coefficient = one_body_coefficients[p, q] output_operator += FermionOperator(term, coefficient) # Convert two-body. for p, q, r, s in itertools.product(range(n_orbitals), repeat=4): coefficient = chemist_tensor[p, q, r, s] # Mixed spin. term = ((2 * p, 1), (2 * q, 0), (2 * r + 1, 1), (2 * s + 1, 0)) output_operator += FermionOperator(term, coefficient) term = ((2 * p + 1, 1), (2 * q + 1, 0), (2 * r, 1), (2 * s, 0)) output_operator += FermionOperator(term, coefficient) # Same spin. term = ((2 * p, 1), (2 * q, 0), (2 * r, 1), (2 * s, 0)) output_operator += FermionOperator(term, coefficient) term = ((2 * p + 1, 1), (2 * q + 1, 0), (2 * r + 1, 1), (2 * s + 1, 0)) output_operator += FermionOperator(term, coefficient) # Check that difference is small. difference = normal_ordered(random_fermion - output_operator) self.assertAlmostEqual(0., difference.induced_norm())
def test_form(self): n_qubits = 6 random_operator = get_fermion_operator( random_interaction_operator(n_qubits)) chemist_operator = chemist_ordered(random_operator) for term, coefficient in chemist_operator.terms.items(): if len(term) == 2 or not len(term): pass else: self.assertTrue(term[0][1]) self.assertTrue(term[2][1]) self.assertFalse(term[1][1]) self.assertFalse(term[3][1]) self.assertTrue(term[0][0] > term[2][0]) self.assertTrue(term[1][0] > term[3][0])
def test_operator_consistency(self): # Initialize a random InteractionOperator and FermionOperator. n_qubits = 4 random_interaction = random_interaction_operator(n_qubits, real=False, seed=34281) random_fermion = get_fermion_operator(random_interaction) # Convert to chemist ordered tensor. io_constant, io_one_body_coefficients, io_chemist_tensor = \ get_chemist_two_body_coefficients(random_interaction) fo_constant, fo_one_body_coefficients, fo_chemist_tensor = \ get_chemist_two_body_coefficients(random_fermion) # Ensure consistency between FermionOperator and InteractionOperator. self.assertAlmostEqual(io_constant, fo_constant) one_body_difference = numpy.sum( numpy.absolute(io_one_body_coefficients - fo_one_body_coefficients)) self.assertAlmostEqual(0., one_body_difference) two_body_difference = numpy.sum( numpy.absolute(io_chemist_tensor - fo_chemist_tensor)) self.assertAlmostEqual(0., two_body_difference) # Convert output to FermionOperator. output_operator = FermionOperator() output_operator += FermionOperator((), fo_constant) # Convert one-body. for p, q in itertools.product(range(n_qubits), repeat=2): term = ((p, 1), (q, 0)) coefficient = fo_one_body_coefficients[p, q] output_operator += FermionOperator(term, coefficient) # Convert two-body. for p, q, r, s in itertools.product(range(n_qubits), repeat=4): term = ((p, 1), (q, 0), (r, 1), (s, 0)) coefficient = fo_chemist_tensor[p, q, r, s] output_operator += FermionOperator(term, coefficient) # Check that difference is small. difference = normal_ordered(random_fermion - output_operator) self.assertAlmostEqual(0., difference.induced_norm())
def test_operator_consistency(self): # Initialize a random two-body FermionOperator. n_qubits = 4 random_operator = get_fermion_operator( random_interaction_operator(n_qubits, seed=28644)) # Convert to chemist tensor. constant, one_body_coefficients, chemist_tensor = ( get_chemist_two_body_coefficients(random_operator)) # Build back operator constant and one-body components. decomposed_operator = FermionOperator((), constant) for p, q in itertools.product(range(n_qubits), repeat=2): term = ((p, 1), (q, 0)) coefficient = one_body_coefficients[p, q] decomposed_operator += FermionOperator(term, coefficient) # Perform decomposition. eigenvalues, one_body_squares, trunc_error = ( low_rank_two_body_decomposition(chemist_tensor)) self.assertFalse(trunc_error) # Check for exception. with self.assertRaises(ValueError): eigenvalues, one_body_squares, trunc_error = ( low_rank_two_body_decomposition(chemist_tensor, truncation_threshold=1., final_rank=1)) # Build back two-body component. for l in range(n_qubits**2): one_body_operator = FermionOperator() for p, q in itertools.product(range(n_qubits), repeat=2): term = ((p, 1), (q, 0)) coefficient = one_body_squares[l, p, q] one_body_operator += FermionOperator(term, coefficient) decomposed_operator += eigenvalues[l] * (one_body_operator**2) # Test for consistency. difference = normal_ordered(decomposed_operator - random_operator) self.assertAlmostEqual(0., difference.induced_norm())
def test_random_operator_consistency(self): # Initialize a random InteractionOperator and FermionOperator. n_orbitals = 3 n_qubits = 2 * n_orbitals random_interaction = random_interaction_operator(n_orbitals, expand_spin=True, real=True, seed=8) random_fermion = get_fermion_operator(random_interaction) # Decompose. eigenvalues, one_body_squares, one_body_correction, error = ( low_rank_two_body_decomposition( random_interaction.two_body_tensor)) self.assertFalse(error) # Build back operator constant and one-body components. decomposed_operator = FermionOperator((), random_interaction.constant) one_body_coefficients = (random_interaction.one_body_tensor + one_body_correction) for p, q in itertools.product(range(n_qubits), repeat=2): term = ((p, 1), (q, 0)) coefficient = one_body_coefficients[p, q] decomposed_operator += FermionOperator(term, coefficient) # Build back two-body component. for l in range(n_orbitals**2): one_body_operator = FermionOperator() for p, q in itertools.product(range(n_qubits), repeat=2): term = ((p, 1), (q, 0)) coefficient = one_body_squares[l, p, q] one_body_operator += FermionOperator(term, coefficient) decomposed_operator += eigenvalues[l] * (one_body_operator**2) # Test for consistency. difference = normal_ordered(decomposed_operator - random_fermion) self.assertAlmostEqual(0., difference.induced_norm())