예제 #1
0
    def test_identity_recognized_as_potential_term(self):
        potential_terms, kinetic_terms = (
            diagonal_coulomb_potential_and_kinetic_terms_as_arrays(
                FermionOperator.identity()))

        self.assertListEqual(list(potential_terms),
                             [FermionOperator.identity()])
        self.assertListEqual(list(kinetic_terms), [])
예제 #2
0
    def test_diagonal_coulomb_hamiltonian_class(self):
        hamiltonian = DiagonalCoulombHamiltonian(
            numpy.array([[1, 1], [1, 1]], dtype=float),
            numpy.array([[0, 1], [1, 0]], dtype=float),
            constant=2.3)

        potential_terms, kinetic_terms = (
            diagonal_coulomb_potential_and_kinetic_terms_as_arrays(
                hamiltonian))

        potential = sum(potential_terms, FermionOperator.zero())
        kinetic = sum(kinetic_terms, FermionOperator.zero())

        expected_potential = (2.3 * FermionOperator.identity() +
                              FermionOperator('0^ 0') +
                              FermionOperator('1^ 1') -
                              FermionOperator('1^ 0^ 1 0', 2.0))
        expected_kinetic = FermionOperator('0^ 1') + FermionOperator('1^ 0')

        self.assertEqual(potential, expected_potential)
        self.assertEqual(kinetic, expected_kinetic)
예제 #3
0
    def test_split_operator_error_operator_VT_order_against_definition(self):
        hamiltonian = (normal_ordered(fermi_hubbard(3, 3, 1., 4.0)) -
                       2.3 * FermionOperator.identity())
        potential_terms, kinetic_terms = (
            diagonal_coulomb_potential_and_kinetic_terms_as_arrays(
                hamiltonian))
        potential = sum(potential_terms, FermionOperator.zero())
        kinetic = sum(kinetic_terms, FermionOperator.zero())

        error_operator = (
            split_operator_trotter_error_operator_diagonal_two_body(
                hamiltonian, order='V+T'))

        # V-then-T ordered double commutators: [V, [T, V]] + [T, [T, V]] / 2
        inner_commutator = normal_ordered(commutator(kinetic, potential))
        error_operator_definition = normal_ordered(
            commutator(potential, inner_commutator))
        error_operator_definition += normal_ordered(
            commutator(kinetic, inner_commutator)) / 2.0
        error_operator_definition /= 12.0

        self.assertEqual(error_operator, error_operator_definition)
예제 #4
0
def construct_exact_ham(orbprop, orb_qubit_map=None):
    ham = FermionOperator.identity() * orbprop.hcore
    ham += construct_ham_1body(orbprop.hint, orb_qubit_map)
    ham += construct_ham_2body(orbprop.gint, orb_qubit_map)
    return ham