Trying an alternative approach to dealing with the algebra of qft computationally based on wick contraction. We can easily find an algorithm that finds all possible pairs. Then we just reduce it all accordingly. Some problems: The combinatorics are going to freak out pretty fast.

I think my use of functional stuff like maps and lambdas is intensely unclarifying the code.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
import numpy as np #Needs to return a list of lists of pairs def pair(mylist): #Base case if len(mylist) == 2: return [[(mylist[0], mylist[1])]] #popoff the first element element1 = mylist[0] pairs = [] for i in range(1,len(mylist)): #Pick one element2 = mylist[i] #get all the pairs expluidng the already picked pair subpairs = pair(mylist[1:i] + mylist[i+1:]) #Put the picked pair back in x is a list of pairs. pairs = pairs + map(lambda x: [(element1,element2)] + x ,subpairs) return pairs #For Fermionic pairing, it might be conveneitn to extend pairs to (element1,element2,+-1) #With the sign depending on wheter i is even or odd ''' pairing = pair([1,2,3,4]) print pairing print len(pairing) ''' #Here's an idea, I can use a and adag as objects with indices #and return functions (two point green's functions) # or could return matrcies that are discretized green's functions. def contract(twoguys): if twoguys[0] == 'a' and twoguys[1] == 'adag': return 1 else: return 0 #Confusing, but what pairings = pair(['a','a','a','adag','adag','adag']) print pairings #could abstract out multiplication as a function passed in. Then if contraction returns functions, I could #return a new function that multiplies the inner functions #or could replace multiply with np.dot if returning matrices def multiplyup(pairing): return reduce(lambda acc, val: acc * val,map(contract,pairing)) print sum(map(multiplyup,pairings)) |