def test_fully_contracted(): i, j, k, l = symbols('i j k l', below_fermi=True) a, b, c, d = symbols('a b c d', above_fermi=True) p, q, r, s = symbols('p q r s', cls=Dummy) Fock = (AntiSymmetricTensor('f', (p, ), (q, )) * NO(Fd(p) * F(q))) V = (AntiSymmetricTensor('v', (p, q), (r, s)) * NO(Fd(p) * Fd(q) * F(s) * F(r))) / 4 Fai = wicks(NO(Fd(i) * F(a)) * Fock, keep_only_fully_contracted=True, simplify_kronecker_deltas=True) assert Fai == AntiSymmetricTensor('f', (a, ), (i, )) Vabij = wicks(NO(Fd(i) * Fd(j) * F(b) * F(a)) * V, keep_only_fully_contracted=True, simplify_kronecker_deltas=True) assert Vabij == AntiSymmetricTensor('v', (a, b), (i, j))
def get_CC_operators(): """ Returns a tuple (T1,T2) of unique operators. """ i = symbols('i', below_fermi=True, cls=Dummy) a = symbols('a', above_fermi=True, cls=Dummy) t_ai = AntiSymmetricTensor('t', (a, ), (i, )) ai = NO(Fd(a) * F(i)) i, j = symbols('i,j', below_fermi=True, cls=Dummy) a, b = symbols('a,b', above_fermi=True, cls=Dummy) t_abij = AntiSymmetricTensor('t', (a, b), (i, j)) abji = NO(Fd(a) * Fd(b) * F(j) * F(i)) T1 = t_ai * ai T2 = Rational(1, 4) * t_abij * abji return (T1, T2)
def R2(expr): i1,i2,i3,i4,i5 = symbols('i1,i2,i3,i4,i5' ,below_fermi=True, cls=Dummy) a1,a2,a3,a4,a5 = symbols('a1,a2,a3,a4,a5' ,above_fermi=True, cls=Dummy) if expr == "IP": R2 = Fraction(1, 2)*AntiSymmetricTensor('r',(a1,),(i2,i3))*Fd(a1)*F(i3)*F(i2) return R2 elif expr == "DIP": R2 = Fraction(1, 6)*AntiSymmetricTensor('r',(a1,),(i3,i4,i5))*Fd(a1)*F(i5)*F(i4)*F(i3) return R2 elif expr == "EA": R2 = Fraction(1, 2)*AntiSymmetricTensor('r',(a2,a3),(i1,))*Fd(a2)*Fd(a3)*F(i1) return R2 elif expr == "DEA": R2 = Fraction(1, 6)*AntiSymmetricTensor('r',(a3,a4,a5),(i1,))*NO(Fd(a3)*Fd(a4)*Fd(a5)*F(i1)) return R2 elif expr == "EE": R2 = Fraction(1, 4)*AntiSymmetricTensor('r',(a2,a3),(i2,i3))*Fd(a2)*Fd(a3)*F(i3)*F(i2) return R2 elif expr == "CCSD": R2 = 0 return R2
def R1(expr): i1,i2,i3 = symbols('i1,i2,i3' ,below_fermi=True, cls=Dummy) a1,a2,a3 = symbols('a1,a2,i3' ,above_fermi=True, cls=Dummy) if expr == "IP": R1 = Fraction(1, 1)*AntiSymmetricTensor('r',(),(i1,))*(F(i1)) return R1 elif expr == "DIP": R1 = Fraction(1, 2)*AntiSymmetricTensor('r',(),(i1,i2))*F(i2)*F(i1) return R1 elif expr == "EA": R1 = Fraction(1, 1)*AntiSymmetricTensor('r',(a1,),())*Fd(a1) return R1 elif expr == "DEA": R1 = Fraction(1, 2)*AntiSymmetricTensor('r',(a1,a2),())*NO(Fd(a1)*Fd(a2)) return R1 elif expr == "EE": R1 = Fraction(1, 1)*AntiSymmetricTensor('r',(a1,),(i1,))*Fd(a1)*F(i1) return R1 elif expr == "CCSD": R1 = 0 return R1
def R0(expr): if expr == "IP": R0 = 0 return R0 elif expr == "DIP": R0 = 0 return R0 elif expr == "EA": R0 = 0 return R0 elif expr == "DEA": R0 = 0 return R0 elif expr == "EE": R0 = Fraction(1, 1)*AntiSymmetricTensor('R0',(),()) return R0 elif expr == "CCSD": R0 = 1 return R0
def L2(expr): j1,j2,j3,j4,j5 = symbols('j1,j2,j3,j4,j5' ,below_fermi=True, cls=Dummy) b1,b2,b3,b4,b5 = symbols('b1,b2,b3,b4,b5' ,above_fermi=True, cls=Dummy) if expr == "IP": L2 = Fraction(1, 2)*AntiSymmetricTensor('l',(j2,j3),(b1,))*Fd(j2)*Fd(j3)*F(b1) return L2 elif expr == "DIP": L2 = Fraction(1, 6)*AntiSymmetricTensor('l',(j3,j4,j5),(b1,))*Fd(j3)*Fd(j4)*Fd(j5)*F(b1) return L2 elif expr == "EA": L2 = Fraction(1, 2)*AntiSymmetricTensor('l',(j1,),(b2,b3))*Fd(j1)*F(b3)*F(b2) return L2 elif expr == "DEA": L2 = Fraction(1, 6)*AntiSymmetricTensor('l',(j1,),(b3,b4,b5))*Fd(j1)*F(b5)*F(b4)*F(b3) return L2 elif expr == "EE": L2 = Fraction(1, 4)*AntiSymmetricTensor('l',(j2,j3),(b2,b3))*Fd(j2)*Fd(j3)*F(b3)*F(b2) return L2 elif expr == "CCSD": L2 = Fraction(1, 4)*AntiSymmetricTensor('l',(j2,j3),(b2,b3))*Fd(j2)*Fd(j3)*F(b3)*F(b2) return L2
def L1(expr): j1,j2,j3 = symbols('j1,j2,j3' ,below_fermi=True, cls=Dummy) b1,b2,b3 = symbols('b1,b2,b3' ,above_fermi=True, cls=Dummy) if expr == "IP": L1 = Fraction(1, 1)*AntiSymmetricTensor('l',(j1,),())*Fd(j1) return L1 elif expr == "DIP": L1 = Fraction(1, 2)*AntiSymmetricTensor('l',(j1,j2),())*Fd(j1)*Fd(j2) return L1 elif expr == "EA": L1 = Fraction(1, 1)*AntiSymmetricTensor('l',(),(b1,))*F(b1) return L1 elif expr == "DEA": L1 = Fraction(1, 2)*AntiSymmetricTensor('l',(),(b1,b2))*F(b2)*F(b1) return L1 elif expr == "EE": L1 = Fraction(1, 1)*AntiSymmetricTensor('l',(j1,),(b1,))*Fd(j1)*F(b1) return L1 elif expr == "CCSD": L1 = Fraction(1, 1)*AntiSymmetricTensor('l',(j1,),(b1,))*Fd(j1)*F(b1) return L1
def att(*args): if len(args) == 4: return AntiSymmetricTensor("t", args[:2], args[2:]) elif len(args) == 2: return AntiSymmetricTensor("t", (args[0],), (args[1],))
def atv(*args): return AntiSymmetricTensor("v", args[:2], args[2:])
def test_sympy__physics__secondquant__AntiSymmetricTensor(): from sympy.physics.secondquant import AntiSymmetricTensor i, j = symbols('i j', below_fermi=True) a, b = symbols('a b', above_fermi=True) assert _test_args(AntiSymmetricTensor('v', (a, i), (b, j)))
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 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("HERE") # print("HERE") # print("HERE") # print(pycode(wicks(eq, simplify_dummies=True, # keep_only_fully_contracted=True))) # with open("cc_energy.py", "w") as f: # f. with open("ccsd.jl", "w") as f: eq_energy = wicks(eq, simplify_dummies=True, keep_only_fully_contracted=True) f.write(julia_code(eq_energy)) 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)) print(latex(simplify(eqT2)))
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)
i, j = symbols('i,j', below_fermi=True, cls=Dummy) a, b = symbols('a,b', above_fermi=True, cls=Dummy) t_abij = AntiSymmetricTensor('t', (a, b), (i, j)) abji = NO(Fd(a) * Fd(b) * F(j) * F(i)) T1 = t_ai * ai T2 = Rational(1, 4) * t_abij * abji return (T1, T2) p, q, r, s = symbols('p,q,r,s', cls=Dummy) #Setup Hamiltonian on normal ordered form E0 = symbols('Eref', real=True, constant=True) #Reference energy f = AntiSymmetricTensor('f', (p, ), (q, )) pq = NO((Fd(p) * F(q))) Fock = f * pq #F is reserved by sympy V = AntiSymmetricTensor('V', (p, q), (r, s)) pqsr = NO(Fd(p) * Fd(q) * F(s) * F(r)) HI = Rational(1, 4) * V * pqsr HN = E0 + F + HI 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]
from sympy import symbols, latex, WildFunction, collect, Rational, simplify from sympy.physics.secondquant import F, Fd, wicks, AntiSymmetricTensor, substitute_dummies, NO, evaluate deltas """ Define Hamiltonian and the second-quantized representation of a three-body Slater determinant. """ # Define Hamiltonian p, q, r, s = symbols("p q r s", dummy=True) f = AntiSymmetricTensor("f", (p,), (q,)) pr = Fd(p) * F(q) v = AntiSymmetricTensor("v", (p, q), (r, s)) pqsr = Fd(p) * Fd(q) * F(s) * F(r) Hamiltonian = f * pr + Rational(1) / Rational(4) * v * pqsr a, b, c, d, e, f = symbols("a, b, c, d, e, f", above_fermi=True) # Create teh representatoin expression = wicks(F(c) * F(b) * F(a) * Hamiltonian * Fd(d) * Fd(e) * Fd(f), keep_only_fully_contracted=True, simplify_kronecker_deltas=True) expression = evaluate_deltas(expression) expression = simplify(expression) print(latex(expression))