Very general sketch of ideas which will hopefully get focused soon

(this is a work in heavy progress)

About me

My name is Peter Petrov and I am in my second year of a PhD program in physics at SUNY at Stony Brook. My focus is on string theory. I am from Bulgaria, where I did a lot of physics in high school, went to international competitions and got accepted at Princeton University in the US. I continued with physics and focused heavily on theoretical courses in physics and math, which led me to string theory and the PhD program I am currently enrolled in. I have very little official computer science experience (one introductory course in Java and some computational science courses), but I started using linux in college and got hooked on all the open source hype so I started picking up some knowledge. Recently I decided I need a more formal education in CS since I am considering a career in it, if I do not stay in academia, so I started doing online courses (Algorithms and Data Structures on Coursera, some codeacademy tutorials as well). I am also currently taking a seminar on python from our physics department, which focuses on scientific applications and I have been playing around with numPy and SymPy.

My current vague ideas

The big picture I had in mind almost immediately when I started thinking about a project was to have a way to do all the annoying and lengthy computations I went through when learning Quantum Field Theory. That is quite a broad functionality, which I am trying to still define, but I have gotten some concrete ideas. The fundamental principle I want to see implemented is for a way to symbolically solve a field theory, from start and finish by going through all the logical steps one goes through when using paper. In terms of the physics I would like to:

1. Start from a Lagrangian and the respective symmetries of the theory as input.
2. Deduce the Feynman rules (vertices and propagators)
3. Find the possible diagrams by loop order for processes of interest (vacuum bubbles, tadpoles, self energies, scattering)
4. Compute analytically the amplitudes for desired processes up to 1 loop
5. Renormalize the theory (or find if it is unrenormalizable)
6. Show unitarity (or absence of)
7. Extend to Super Gravity (that is expand the functionality to deal with supersymmetry).

Obviously all of this is quite an extensive project well beyond my scope, but I want to start somewhere. Some motivation on why this would be useful. There is an enormous number of efficient algorithms for numerical solutions to many of these problems, so why bother with symbolic solutions, which are also only realistically achievable to 2 - loop for most systems? Apart from "I find it extremely interesting to try and do", the very important application I see is for learning QFT through using this functionality. Having the ability to go through these steps logically, without manually doing all the computations, for any theory we want would in my supplement the learning process immensely. I have a better and more involved argument about why this will help significantly, but will elaborate later.

The other interesting question is why would this be needed for SymPy and its goals and principles. Dealing with any one of the steps outlined above will involve mathematical constructs, which are quite general and the functionality could be used for numerous applications outside my expertise, hopefully bringing more to the table than just a really cool way to learn Field Theory. I still need to do more digging to see exactly which of the concepts have the functionality I want and what needs work, but here I offer a general outline of what I see that needs to be done to achieve the above. Any specific feedback on what you might think I should look into in depth would be greatly appreciated, since there far too many things for me to explore in the time I have

1. SymPy needs to know about Lie groups and their specific representations. While I saw quite a lot of work on implementing group theoretic concepts I feel like some functionality is missing (I know this is vague, but I am still wrapping my head around how groups are treated, and still have not encountered representations). There is a nice computational problem of finding all representations of a group in any allowed dimension. Relating then a tensor object (the field) and its index structure to a given representation. The tensor package from what I managed to understand deals with Lorentz indices and doesn't seem to know about indices lying on a group manifold. This might be a simple problem of hard coding symmetry properties (functionality I saw) of indices based on groups and representations, but I feel work along these lines might lead to better integration of different modules across sympy (the differential geometry package seems to not know anything about tensors, which is a possible step for progress). Implementing supersymmetry would expand this to super algebras, which suggests possible work in treating algebras in a nice way.

2. Computing Feynman diagrams will involve several interesting computational problems. Fist is Gamma matrix technology, which I only found reasonably implemented for 4 dimensions. As a whole the Gamma matrix seems to be treated in several different modules completely differently, so there is some room for improvement there. Also even though general tensor simplification seems to be reasonably developed, I can't see how it would deal with multiple indices of different groups. A universal trace() for example which is equipped to recognize the different index structure based on the representation and the group the field lies in would do wonders.

3. Regularizing loop integrals would involve an implementation of Dimensional Regularization. We also would need to implement technology such as the Feynman Combine, Wick Rotations, and dealing with divergences in an analytic way.

4. Unitarity could be approached from Ward Identities, which means we can implement a functionality to deal with path integrals in a nice analytic way and implement variational derivatives and also some algorithm to generate the sources required to have a nice path integral formulation.

5. One might also think of implementing BRST transformation rules in some manner.

This is what I have so far as ideas. I know they are quite vague and undefined, but I am working towards making a connected set of them more concrete and to fit them logically in what is currently available in SymPy. I am really lacking in hands on experience with SymPy, so if anyone with more experience can point me to some small problem related to anything I just sketched out I can go and dig there and try to figure out an actual proposal for something concrete and doable.