def test_index_permutations_with_dummies(): a, b, c, d = symbols('a b c d') p, q, r, s = symbols('p q r s', cls=Dummy) f, g = map(Function, 'fg') P = PermutationOperator # No dummy substitution necessary expr = f(a, b, p, q) - f(b, a, p, q) assert simplify_index_permutations( expr, [P(a, b)]) == P(a, b)*f(a, b, p, q) # Cases where dummy substitution is needed expected = P(a, b)*substitute_dummies(f(a, b, p, q)) expr = f(a, b, p, q) - f(b, a, q, p) result = simplify_index_permutations(expr, [P(a, b)]) assert expected == substitute_dummies(result) expr = f(a, b, q, p) - f(b, a, p, q) result = simplify_index_permutations(expr, [P(a, b)]) assert expected == substitute_dummies(result) # A case where nothing can be done expr = f(a, b, q, p) - g(b, a, p, q) result = simplify_index_permutations(expr, [P(a, b)]) assert expr == result
def test_PermutationOperator(): p, q, r, s = symbols("p,q,r,s") f, g, h, i = map(Function, "fghi") P = PermutationOperator assert P(p, q).get_permuted(f(p) * g(q)) == -f(q) * g(p) assert P(p, q).get_permuted(f(p, q)) == -f(q, p) assert P(p, q).get_permuted(f(p)) == f(p) expr = f(p) * g(q) * h(r) * i(s) - f(q) * g(p) * h(r) * i(s) - f(p) * g(q) * h(s) * i(r) + f(q) * g(p) * h(s) * i(r) perms = [P(p, q), P(r, s)] assert simplify_index_permutations(expr, perms) == P(p, q) * P(r, s) * f(p) * g(q) * h(r) * i(s)
def test_PermutationOperator(): p,q,r,s = symbols('pqrs') f,g,h,i = map(Function, 'fghi') P = PermutationOperator assert (P(p,q).get_permuted(f(p)*g(q)) == -f(q)*g(p)) expr = (f(p)*g(q)*h(r)*i(s) - f(q)*g(p)*h(r)*i(s) - f(p)*g(q)*h(s)*i(r) + f(q)*g(p)*h(s)*i(r)) perms = [P(p,q),P(r,s)] assert (simplify_index_permutations(expr,perms) == P(p,q)*P(r,s)*f(p)*g(q)*h(r)*i(s))
def main(): print() print("Calculates the Coupled-Cluster energy- and amplitude equations") print("See 'An Introduction to Coupled Cluster Theory' by") print("T. Daniel Crawford and Henry F. Schaefer III") print("http://www.ccc.uga.edu/lec_top/cc/html/review.html") print() # setup hamiltonian p, q, r, s = symbols('p,q,r,s', cls=Dummy) f = AntiSymmetricTensor('f', (p,), (q,)) pr = NO((Fd(p)*F(q))) v = AntiSymmetricTensor('v', (p, q), (r, s)) pqsr = NO(Fd(p)*Fd(q)*F(s)*F(r)) H = f*pr + Rational(1, 4)*v*pqsr print("Using the hamiltonian:", latex(H)) print("Calculating 4 nested commutators") C = Commutator T1, T2 = get_CC_operators() T = T1 + T2 print("commutator 1...") comm1 = wicks(C(H, T)) comm1 = evaluate_deltas(comm1) comm1 = substitute_dummies(comm1) T1, T2 = get_CC_operators() T = T1 + T2 print("commutator 2...") comm2 = wicks(C(comm1, T)) comm2 = evaluate_deltas(comm2) comm2 = substitute_dummies(comm2) T1, T2 = get_CC_operators() T = T1 + T2 print("commutator 3...") comm3 = wicks(C(comm2, T)) comm3 = evaluate_deltas(comm3) comm3 = substitute_dummies(comm3) T1, T2 = get_CC_operators() T = T1 + T2 print("commutator 4...") comm4 = wicks(C(comm3, T)) comm4 = evaluate_deltas(comm4) comm4 = substitute_dummies(comm4) print("construct Hausdoff expansion...") eq = H + comm1 + comm2/2 + comm3/6 + comm4/24 eq = eq.expand() eq = evaluate_deltas(eq) eq = substitute_dummies(eq, new_indices=True, pretty_indices=pretty_dummies_dict) print("*********************") print() print("extracting CC equations from full Hbar") i, j, k, l = symbols('i,j,k,l', below_fermi=True) a, b, c, d = symbols('a,b,c,d', above_fermi=True) print() print("CC Energy:") print(latex(wicks(eq, simplify_dummies=True, keep_only_fully_contracted=True))) print() print("CC T1:") eqT1 = wicks(NO(Fd(i)*F(a))*eq, simplify_kronecker_deltas=True, keep_only_fully_contracted=True) eqT1 = substitute_dummies(eqT1) print(latex(eqT1)) print() print("CC T2:") eqT2 = wicks(NO(Fd(i)*Fd(j)*F(b)*F(a))*eq, simplify_dummies=True, keep_only_fully_contracted=True, simplify_kronecker_deltas=True) P = PermutationOperator eqT2 = simplify_index_permutations(eqT2, [P(a, b), P(i, j)]) print(latex(eqT2))
T = T1+ T2 print "comm4..." comm4 = wicks(C(comm3,T),simplify_dummies=True, simplify_kronecker_deltas=True) print "construct Hausdoff expansion..." eq = H + comm1+comm2/2+comm3/6+comm4/24 eq = eq.expand() eq = evaluate_deltas(eq) eq = substitute_dummies(eq, new_indices=True, reverse_order=False) print "*********************" print print "extracting CC equations from full Hbar" i,j,k,l = symbols('ijkl',below_fermi=True) a,b,c,d = symbols('abcd',above_fermi=True) print print "CC Energy:" print latex(wicks(eq, simplify_dummies=True, keep_only_fully_contracted=True)) print print "CC T1:" eqT1 = wicks(NO(Fd(i)*F(a))*eq, simplify_kronecker_deltas=True, keep_only_fully_contracted=True) eqT1 = substitute_dummies(eqT1,reverse_order=False) print latex(eqT1) print print "CC T2:" eqT2 = wicks(NO(Fd(i)*Fd(j)*F(b)*F(a))*eq,simplify_dummies=True, keep_only_fully_contracted=True, simplify_kronecker_deltas=True) P = PermutationOperator eqT2 = simplify_index_permutations(eqT2,[P(a,b),P(i,j)]) print latex(eqT2)
def main(): print print "Calculates the Coupled-Cluster energy- and amplitude equations" print "See 'An Introduction to Coupled Cluster Theory' by" print "T. Daniel Crawford and Henry F. Schaefer III" print "http://www.ccc.uga.edu/lec_top/cc/html/review.html" print # setup hamiltonian p, q, r, s = symbols('p,q,r,s', cls=Dummy) f = AntiSymmetricTensor('f', (p, ), (q, )) pr = NO((Fd(p) * F(q))) v = AntiSymmetricTensor('v', (p, q), (r, s)) pqsr = NO(Fd(p) * Fd(q) * F(s) * F(r)) H = f * pr + Rational(1, 4) * v * pqsr print "Using the hamiltonian:", latex(H) print "Calculating 4 nested commutators" C = Commutator T1, T2 = get_CC_operators() T = T1 + T2 print "commutator 1..." comm1 = wicks(C(H, T)) comm1 = evaluate_deltas(comm1) comm1 = substitute_dummies(comm1) T1, T2 = get_CC_operators() T = T1 + T2 print "commutator 2..." comm2 = wicks(C(comm1, T)) comm2 = evaluate_deltas(comm2) comm2 = substitute_dummies(comm2) T1, T2 = get_CC_operators() T = T1 + T2 print "commutator 3..." comm3 = wicks(C(comm2, T)) comm3 = evaluate_deltas(comm3) comm3 = substitute_dummies(comm3) T1, T2 = get_CC_operators() T = T1 + T2 print "commutator 4..." comm4 = wicks(C(comm3, T)) comm4 = evaluate_deltas(comm4) comm4 = substitute_dummies(comm4) print "construct Hausdoff expansion..." eq = H + comm1 + comm2 / 2 + comm3 / 6 + comm4 / 24 eq = eq.expand() eq = evaluate_deltas(eq) eq = substitute_dummies(eq, new_indices=True, pretty_indices=pretty_dummies_dict) print "*********************" print print "extracting CC equations from full Hbar" i, j, k, l = symbols('i,j,k,l', below_fermi=True) a, b, c, d = symbols('a,b,c,d', above_fermi=True) print print "CC Energy:" print latex( wicks(eq, simplify_dummies=True, keep_only_fully_contracted=True)) print print "CC T1:" eqT1 = wicks(NO(Fd(i) * F(a)) * eq, simplify_kronecker_deltas=True, keep_only_fully_contracted=True) eqT1 = substitute_dummies(eqT1) print latex(eqT1) print print "CC T2:" eqT2 = wicks(NO(Fd(i) * Fd(j) * F(b) * F(a)) * eq, simplify_dummies=True, keep_only_fully_contracted=True, simplify_kronecker_deltas=True) P = PermutationOperator eqT2 = simplify_index_permutations(eqT2, [P(a, b), P(i, j)]) print latex(eqT2)
def TPDM(L, R, flavor): display( Markdown( rf""" Computing TPDM for {flavor} (skipping summation for dummy variables)""" )) i, j, k, l = symbols('i,j,k,l', below_fermi=True) a, b, c, d = symbols('a,b,c,d', above_fermi=True) oooo = Fd(i) * Fd(j) * F(l) * F(k) cc = BCH.level(oooo, "SD") g_oooo = evaluate_deltas(wicks(L * cc * R, keep_only_fully_contracted=True)) PermutList = [PermutationOperator(i,j),PermutationOperator(i,k), \ PermutationOperator(i,l),PermutationOperator(j,k), \ PermutationOperator(j,l),PermutationOperator(k,l)] g_oooo = simplify_index_permutations(g_oooo, PermutList) index_rule = {'below': 'mnop', 'above': 'abcde'} g_oooo = substitute_dummies(g_oooo, new_indices=True, pretty_indices=index_rule) gamma = Symbol('\gamma_{ijkl}') final_eq = Eq(gamma, g_oooo) display(final_eq) ooov = Fd(i) * Fd(j) * F(a) * F(k) cc = BCH.level(ooov, "SD") g_ooov = evaluate_deltas(wicks(L * cc * R, keep_only_fully_contracted=True)) PermutList = [PermutationOperator(i,j),PermutationOperator(i,k), \ PermutationOperator(j,k)] g_ooov = simplify_index_permutations(g_ooov, PermutList) index_rule = {'below': 'lmnop', 'above': 'bcdef'} g_ooov = substitute_dummies(g_ooov, new_indices=True, pretty_indices=index_rule) gamma = Symbol('\gamma_{ijka}') final_eq = Eq(gamma, g_oo) display(final_eq) ooov = Fd(i) * Fd(a) * F(k) * F(j) cc = BCH.level(ooov, "SD") g_ovoo = evaluate_deltas(wicks(L * cc * R, keep_only_fully_contracted=True)) PermutList = [PermutationOperator(i,j),PermutationOperator(i,k), \ PermutationOperator(j,k)] g_ovoo = simplify_index_permutations(g_ovoo, PermutList) index_rule = {'below': 'lmnop', 'above': 'bcdef'} g_ovoo = substitute_dummies(g_ovoo, new_indices=True, pretty_indices=index_rule) gamma = Symbol('\gamma_{iajk}') final_eq = Eq(gamma, g_ovoo) display(final_eq) ovov = Fd(i) * Fd(a) * F(b) * F(j) cc = BCH.level(ovov, "SD") g_ovov = evaluate_deltas(wicks(L * cc * R, keep_only_fully_contracted=True)) PermutList = [PermutationOperator(i, j), PermutationOperator(a, b)] g_ovov = simplify_index_permutations(g_ovov, PermutList) index_rule = {'below': 'klmno', 'above': 'cdef'} g_ovov = substitute_dummies(g_ovov, new_indices=True, pretty_indices=index_rule) gamma = Symbol('\gamma_{iajb}') final_eq = Eq(gamma, g_ovov) display(final_eq) ovvv = Fd(i) * Fd(a) * F(c) * F(b) cc = BCH.level(ovvv, "SD") g_ovvv = evaluate_deltas(wicks(L * cc * R, keep_only_fully_contracted=True)) PermutList = [PermutationOperator(a,b),PermutationOperator(a,c), \ PermutationOperator(b,c)] g_ovvv = simplify_index_permutations(g_ovvv, PermutList) index_rule = {'below': 'jklmn', 'above': 'defg'} g_ovvv = substitute_dummies(g_ovvv, new_indices=True, pretty_indices=index_rule) gamma = Symbol('\gamma_{iabc}') final_eq = Eq(gamma, g_ovvv) display(final_eq) oovv = Fd(i) * Fd(j) * F(b) * F(a) cc = BCH.level(oovv, "SD") g_oovv = evaluate_deltas(wicks(L * cc * R, keep_only_fully_contracted=True)) PermutList = [PermutationOperator(i, j), PermutationOperator(a, b)] g_oovv = simplify_index_permutations(g_oovv, PermutList) index_rule = {'below': 'klmn', 'above': 'cdefg'} g_oovv = substitute_dummies(g_oovv, new_indices=True, pretty_indices=index_rule) gamma = Symbol('\gamma_{ijab}') final_eq = Eq(gamma, g_oovv) display(final_eq)
def LVECTORS(L0, L1, L2, flavor): display( Markdown( rf""" Computing left sigma amplitudes for {flavor} (skipping summation for dummy variables)""" )) p, q, r, s = symbols('p,q,r,s', cls=Dummy) f = AntiSymmetricTensor('f', (p, ), (q, )) pr = NO((Fd(p) * F(q))) v = AntiSymmetricTensor('v', (p, q), (r, s)) pqsr = NO(Fd(p) * Fd(q) * F(s) * F(r)) ham = f * pr + Rational(1, 4) * v * pqsr cc = BCH.level(ham, "SD") E_cc = evaluate_deltas(wicks(cc, keep_only_fully_contracted=True)) i, j, k = symbols('i,j,k', below_fermi=True) a, b, c = symbols('a,b,c', above_fermi=True) if flavor == "IP": sig11 = evaluate_deltas( wicks(L1 * (cc - E_cc) * F(i), keep_only_fully_contracted=True)) index_rule = {'below': 'jklmno', 'above': 'abcdefg'} sig11 = substitute_dummies(sig11, new_indices=True, pretty_indices=index_rule) if flavor == "EA": sig11 = evaluate_deltas( wicks(L1 * (cc - E_cc) * Fd(a), keep_only_fully_contracted=True)) index_rule = {'below': 'ijklmno', 'above': 'bcdefg'} sig11 = substitute_dummies(sig11, new_indices=True, pretty_indices=index_rule) if flavor == "DIP": PermutList = [PermutationOperator(i, j)] sig11 = evaluate_deltas( wicks(L1 * (cc - E_cc) * F(j) * F(i), keep_only_fully_contracted=True)) index_rule = {'below': 'klmno', 'above': 'abcdefg'} sig11 = substitute_dummies(sig11, new_indices=True, pretty_indices=index_rule) sig11 = simplify_index_permutations(sig11, PermutList) if flavor == "DEA": PermutList = [PermutationOperator(a, b)] sig11 = evaluate_deltas( wicks(L1 * (cc - E_cc) * Fd(a) * Fd(b), keep_only_fully_contracted=True)) index_rule = {'below': 'ijklmno', 'above': 'cdefg'} sig11 = substitute_dummies(sig11, new_indices=True, pretty_indices=index_rule) sig11 = simplify_index_permutations(sig11, PermutList) sigma_11 = Symbol('(L_{1}(\overline{H}_{SS}-E_{cc}))') final_eq = Eq(sigma_11, sig11) display(final_eq) if flavor == "IP": PermutList = [PermutationOperator(i, j)] sig12 = evaluate_deltas( wicks((L2 * cc) * F(i), keep_only_fully_contracted=True)) index_rule = {'below': 'jklmno', 'above': 'abcdefg'} sig12 = substitute_dummies(sig12, new_indices=True, pretty_indices=index_rule) sig12 = simplify_index_permutations(sig12, PermutList) if flavor == "EA": PermutList = [PermutationOperator(a, b)] sig12 = evaluate_deltas( wicks((L2 * cc) * Fd(a), keep_only_fully_contracted=True)) index_rule = {'below': 'ijklmno', 'above': 'bcdefg'} sig12 = substitute_dummies(sig12, new_indices=True, pretty_indices=index_rule) sig12 = simplify_index_permutations(sig12, PermutList) if flavor == "DIP": PermutList = [ PermutationOperator(i, j), PermutationOperator(j, k), PermutationOperator(i, k) ] sig12 = evaluate_deltas( wicks(L2 * cc * F(j) * F(i), keep_only_fully_contracted=True)) index_rule = {'below': 'klmno', 'above': 'abcdefg'} sig12 = substitute_dummies(sig12, new_indices=True, pretty_indices=index_rule) sig12 = simplify_index_permutations(sig12, PermutList) if flavor == "DEA": PermutList = [ PermutationOperator(a, b), PermutationOperator(b, c), PermutationOperator(a, c) ] sig12 = evaluate_deltas( wicks((L2 * cc) * Fd(a) * Fd(b), keep_only_fully_contracted=True)) index_rule = {'below': 'ijklmno', 'above': 'cdefg'} sig12 = substitute_dummies(sig12, new_indices=True, pretty_indices=index_rule) sig12 = simplify_index_permutations(sig12, PermutList) sigma_12 = Symbol('(L_{2}\overline{H}_{DS})') final_eq = Eq(sigma_12, sig12) display(final_eq) if flavor == "IP": sig21 = evaluate_deltas( wicks((L1 * cc) * Fd(a) * F(j) * F(i), keep_only_fully_contracted=True)) index_rule = {'below': 'klmno', 'above': 'bcdefgh'} sig21 = substitute_dummies(sig21, new_indices=True, pretty_indices=index_rule) if flavor == "EA": sig21 = evaluate_deltas( wicks((L1 * cc) * Fd(a) * Fd(b) * F(i), keep_only_fully_contracted=True)) index_rule = {'below': 'jklmno', 'above': 'cdefgh'} sig21 = substitute_dummies(sig21, new_indices=True, pretty_indices=index_rule) if flavor == "DIP": PermutList = [PermutationOperator(i, j)] sig21 = evaluate_deltas( wicks(L1 * cc * Fd(a) * F(k) * F(j) * F(i), keep_only_fully_contracted=True)) index_rule = {'below': 'lmno', 'above': 'bcdefgh'} sig21 = substitute_dummies(sig21, new_indices=True, pretty_indices=index_rule) sig21 = simplify_index_permutations(sig21, PermutList) if flavor == "DEA": PermutList = [PermutationOperator(a, b)] sig21 = evaluate_deltas( wicks((L1 * cc) * Fd(a) * Fd(b) * Fd(c) * F(i), keep_only_fully_contracted=True)) index_rule = {'below': 'jklmno', 'above': 'defgh'} sig21 = substitute_dummies(sig21, new_indices=True, pretty_indices=index_rule) sig21 = simplify_index_permutations(sig21, PermutList) sigma_21 = Symbol('(L_{1}\overline{H}_{SD})') final_eq = Eq(sigma_21, sig21) display(final_eq) if flavor == "IP": PermutList = [PermutationOperator(i, j)] sig22 = evaluate_deltas( wicks(L2 * (cc - E_cc) * Fd(a) * F(j) * F(i), keep_only_fully_contracted=True)) index_rule = {'below': 'klmno', 'above': 'bcdefgh'} sig22 = substitute_dummies(sig22, new_indices=True, pretty_indices=index_rule) sig22 = simplify_index_permutations(sig22, PermutList) if flavor == "EA": PermutList = [PermutationOperator(a, b)] sig22 = evaluate_deltas( wicks(L2 * (cc - E_cc) * Fd(a) * Fd(b) * F(i), keep_only_fully_contracted=True)) index_rule = {'below': 'jklmno', 'above': 'cdefgh'} sig22 = substitute_dummies(sig22, new_indices=True, pretty_indices=index_rule) sig22 = simplify_index_permutations(sig22, PermutList) if flavor == "DIP": PermutList = [ PermutationOperator(i, j), PermutationOperator(j, k), PermutationOperator(i, k) ] sig22 = evaluate_deltas( wicks(L2 * (cc - E_cc) * Fd(a) * F(k) * F(j) * F(i), keep_only_fully_contracted=True)) index_rule = {'below': 'lmno', 'above': 'bcdefgh'} sig22 = substitute_dummies(sig22, new_indices=True, pretty_indices=index_rule) sig22 = simplify_index_permutations(sig22, PermutList) if flavor == "DEA": PermutList = [ PermutationOperator(a, b), PermutationOperator(b, c), PermutationOperator(a, c) ] sig22 = evaluate_deltas( wicks(L2 * (cc - E_cc) * Fd(a) * Fd(b) * Fd(c) * F(i), keep_only_fully_contracted=True)) index_rule = {'below': 'jklmno', 'above': 'defgh'} sig22 = substitute_dummies(sig22, new_indices=True, pretty_indices=index_rule) sig22 = simplify_index_permutations(sig22, PermutList) sigma_22 = Symbol('(L_{2}(\overline{H}_{DD}-E_{cc}))') final_eq = Eq(sigma_22, sig22) display(final_eq)
def main(): print print "Calculates the Coupled-Cluster energy- and amplitude equations" print "See 'An Introduction to Coupled Cluster Theory' by" print "T. Daniel Crawford and Henry F. Schaefer III" print "http://www.ccc.uga.edu/lec_top/cc/html/review.html" print # setup hamiltonian p, q, r, s = symbols("pqrs", dummy=True) f = AntiSymmetricTensor("f", (p,), (q,)) pr = NO((Fd(p) * F(q))) v = AntiSymmetricTensor("v", (p, q), (r, s)) pqsr = NO(Fd(p) * Fd(q) * F(s) * F(r)) H = f * pr # Uncomment the next line to use a 2-body hamiltonian: # H=f*pr + Number(1,4)*v*pqsr print "Using the hamiltonian:", latex(H) print "Calculating nested commutators" C = Commutator T1, T2 = get_CC_operators() T = T1 + T2 print "comm1..." comm1 = wicks(C(H, T), simplify_dummies=True, simplify_kronecker_deltas=True) T1, T2 = get_CC_operators() T = T1 + T2 print "comm2..." comm2 = wicks(C(comm1, T), simplify_dummies=True, simplify_kronecker_deltas=True) T1, T2 = get_CC_operators() T = T1 + T2 print "comm3..." comm3 = wicks(C(comm2, T), simplify_dummies=True, simplify_kronecker_deltas=True) T1, T2 = get_CC_operators() T = T1 + T2 print "comm4..." comm4 = wicks(C(comm3, T), simplify_dummies=True, simplify_kronecker_deltas=True) print "construct Hausdoff expansion..." eq = H + comm1 + comm2 / 2 + comm3 / 6 + comm4 / 24 eq = eq.expand() eq = evaluate_deltas(eq) eq = substitute_dummies(eq, new_indices=True, reverse_order=False, pretty_indices=pretty_dummies_dict) print "*********************" print print "extracting CC equations from full Hbar" i, j, k, l = symbols("ijkl", below_fermi=True) a, b, c, d = symbols("abcd", above_fermi=True) print print "CC Energy:" print latex(wicks(eq, simplify_dummies=True, keep_only_fully_contracted=True)) print print "CC T1:" eqT1 = wicks(NO(Fd(i) * F(a)) * eq, simplify_kronecker_deltas=True, keep_only_fully_contracted=True) eqT1 = substitute_dummies(eqT1, reverse_order=False) print latex(eqT1) print print "CC T2:" eqT2 = wicks( NO(Fd(i) * Fd(j) * F(b) * F(a)) * eq, simplify_dummies=True, keep_only_fully_contracted=True, simplify_kronecker_deltas=True, ) P = PermutationOperator eqT2 = simplify_index_permutations(eqT2, [P(a, b), P(i, j)]) print latex(eqT2)
i, j, k, l = symbols('i,j,k,l', below_fermi=True) a, b, c, d = symbols('a,b,c,d', above_fermi=True) print("Compute CCD energy and amplitude equations term by term") #BCH: HN + [HN,T] + 0.5*[[HN,T],T] + 1/6 * [[[HN,T],T],T] + 1/24 * [[[[HN,T],T],T],T] print("zero-order term") print("<Phi|HN|Phi> = ", latex(wicks(HN, simplify_dummies=True, keep_only_fully_contracted=True))) eqT2 = wicks(NO(Fd(i) * Fd(j) * F(b) * F(a)) * HN, simplify_dummies=True, keep_only_fully_contracted=True, simplify_kronecker_deltas=True) P = PermutationOperator eqT2 = simplify_index_permutations(eqT2, [P(a, b), P(i, j)]) print("<Phi|HN|Phi_ij^ab = ", latex(eqT2)) print() C = Commutator T1, T2 = get_CC_operators() T = T2 print("[HN,T]-term") comm1 = wicks(C(HN, T)) comm1 = evaluate_deltas(comm1) comm1 = substitute_dummies(comm1, new_indices=True, pretty_indices=pretty_dummies_dict) print( "<Phi|[HN,T]|Phi> = ",
def main(): print() print("Calculates the Coupled-Cluster energy- and amplitude equations") print("See 'An Introduction to Coupled Cluster Theory' by") print("T. Daniel Crawford and Henry F. Schaefer III") print( "Reference to a Lecture Series: http://vergil.chemistry.gatech.edu/notes/sahan-cc-2010.pdf" ) print() # setup hamiltonian p, q, r, s = symbols("p,q,r,s", cls=Dummy) f = AntiSymmetricTensor("f", (p,), (q,)) pr = NO((Fd(p) * F(q))) v = AntiSymmetricTensor("v", (p, q), (r, s)) pqsr = NO(Fd(p) * Fd(q) * F(s) * F(r)) H = f * pr + Rational(1, 4) * v * pqsr print("Using the hamiltonian:", latex(H)) print("Calculating 4 nested commutators") C = Commutator T1, T2 = get_CC_operators() T = T1 + T2 print("commutator 1...") comm1 = wicks(C(H, T)) comm1 = evaluate_deltas(comm1) comm1 = substitute_dummies(comm1) T1, T2 = get_CC_operators() T = T1 + T2 print("commutator 2...") comm2 = wicks(C(comm1, T)) comm2 = evaluate_deltas(comm2) comm2 = substitute_dummies(comm2) T1, T2 = get_CC_operators() T = T1 + T2 print("commutator 3...") comm3 = wicks(C(comm2, T)) comm3 = evaluate_deltas(comm3) comm3 = substitute_dummies(comm3) T1, T2 = get_CC_operators() T = T1 + T2 print("commutator 4...") comm4 = wicks(C(comm3, T)) comm4 = evaluate_deltas(comm4) comm4 = substitute_dummies(comm4) print("construct Hausdorff expansion...") eq = H + comm1 + comm2 / 2 + comm3 / 6 + comm4 / 24 eq = eq.expand() eq = evaluate_deltas(eq) eq = substitute_dummies(eq, new_indices=True, pretty_indices=pretty_dummies_dict) print("*********************") print() print("extracting CC equations from full Hbar") i, j, k, l = symbols("i,j,k,l", below_fermi=True) a, b, c, d = symbols("a,b,c,d", above_fermi=True) print() print("CC Energy:") print(latex(wicks(eq, simplify_dummies=True, keep_only_fully_contracted=True))) print() print("CC T1:") eqT1 = wicks( NO(Fd(i) * F(a)) * eq, simplify_kronecker_deltas=True, keep_only_fully_contracted=True, ) eqT1 = substitute_dummies(eqT1) print(latex(eqT1)) print() print("CC T2:") eqT2 = wicks( NO(Fd(i) * Fd(j) * F(b) * F(a)) * eq, simplify_dummies=True, keep_only_fully_contracted=True, simplify_kronecker_deltas=True, ) P = PermutationOperator eqT2 = simplify_index_permutations(eqT2, [P(a, b), P(i, j)]) print(latex(eqT2))