Computational Challenges in Heat Kernel Calculations

This is an unevaluated Mathematica notebook. If you do not have a copy of Mathematica handy, you may want to also view the evaluated version

Steve Christensen

MathSolutions, Inc. & UNC-Chapel Hill
Winnipeg, August, 1994

Historical Introduction

I first came upon heat kernel calculations in 1971 when starting out as a student of Bryce DeWitt and reading Dynamical Theory of Groups and Fields - section 17. He was convinced that a computer eventually could be taught to do these calculations. At the time I had had about 8 years of
programming experience with FORTRAN, FORMAC, and a little
Schoonschip. None of these seemed appropriate for quantum gravity
calculations and in any case, no computer had enough memory or
disk space to store results of the really large calculations. I did what
I could by hand over the next few years - mostly by brute force.
(Protests to Bryce about the horrible length of such calculations would
usually get a - "Come on, it's a straightforward calculation - Just Do It!"
If I didn't want him to go away over the weekend and do it himself, I
just did.)

In 1974, I took on the project to carefully carry out "point splitting"
regularization for stress tensors. The majority of the calculations involved the computation of coincidence limits of the bi-scalar of geodetic
interval $\sigma (x,x')$ and expansions of other bi-scalar and bi-tensor
objects in terms of the tangent to the geodesic at the point x.

In the early 1980's, working on fourth order gravity theories, I found
that I would no longer be able to carry out most of the renormalization
calculations I wanted to do - at least not by brute force. Macsyma or Reduce held out some hope, but were LISP-based, only ran on mainframes or mini-computers, and usually took all of the resources of those
expensive and hard-to-find machines. The advent of the 68000-based
UNIX computers and C-compilers from Sun Microsystems and Berkeley
encouraged new developments in computer algebra.

In 1982, I contacted Steve Wolfram in the hope that he would agree to
move his SMP system - then running on VAX's - to a Sun workstation.
I also ordered a workstation - one of the first Sun-1's (It had a 6 MHz
68000 16/8-bit processor with 1 megabyte of RAM and 60 megabytes
of disk - and weighed a "ton". This little notebook computer has a lot
more power.) While waiting for SMP, I wrote some of my own programs
which did some of the coincidence limit calculations I wanted to do, but
quickly overwhelmed the initial configuration of my Sun-1.

After 1985, with the advent of the Sun-3 machine, it finally became
possible to run SMP and C programs on a personal machine that could really
do a large computation. Parker, Fulling, and I independently were working
on designing tensor analysis systems for specific purposes. Wolfram
had dropped SMP development due to legal hassles and at the University
of Illinois started creating Mathematica. I got the first copy of this from
him to experiment on moving my coincidence limit programs from C
to Mathematica. Eventually, Parker and I joined forces to create
a general purpose tensor analysis system - now called MathTensor.
Fulling focused on the deeper Mathematical analysis of pseudo-differential
operators and a study of the normal forms for tensor polynomials.

Computers have now reached a level where calculations beyond human
hand-calculations can be done with some strong belief that they are bug-
free and reproducible in more than one way. The work outlined here
was done on a 2-processor Sun SPARCstation 10 with 64 megabytes of
RAM and 1-gigabyte of disk.

My philosophy for doing large calculations

Try doing a calculation in the most straigthforward and brute
force way before getting "clever."

Alway be able to show intermediate steps in a calculation - whether
done by hand or computer.

Do any large calculation in two different ways when possible.

Calculations - To Do List

There are a number of very large, very challanging, problems to
carry out by computer - some already being done - that I am
interested in doing or checking with new calculations:

Coincidence limits of sigma up to 12 derivatives.

Coincidence limits of I(x,x'), the bi-tensor of parallel transport, and
its derivatives for various fields up to 10 derivatives.

Coincidence limits for the HaMiDew coefficients and their derivatives for all interesting operators.

Use above results in deriving point splitting expansions for all two-point objects - including Green functions and stress tensors.

To do these calculations, we must define minimal sets of Riemann tensor products, derivatives, and coupling objects.

Repeat the above calculations adding in torsion and/or other background fields - Yang-Mills, for example.


It is probable that a group of people will have to be formed to act as a
"standard" group to define and archive the calculations above - and to
test all results obtained.

Today, I will take time only to look at the first two calculations where
I have made some progress in the last few months.

How big can the calculations get?

Steve Fulling has written a C program called sig which is very good
at computing coincidence limits of sigma. He has created a formula that relates the coincidence limit of p derivatives of sigma to a complicated
sum of terms with products of derivatives of the Riemann tensor and lower derivative coincidence limits of sigma.



The program computes all possible legal terms that can appear in the pth-derivative coincidence limit and then computes which ones actually appear and then the coefficient of that term. Here are a few typical runs:

The output gives a list of Riemann tensors and derivatives suitable for loading back into MathTensor. It also lists the number of terms checked and the ones with non-zero coefficients.

The next table shows in the numbers for higher derivative runs on my SPARC 10:


Order Indices Gen. Terms Non-Zero Minimal Time Size (bytes)
2 4 24 2 2 0:00 141
3 5 120 6 5 0:00 288
4 6 12,240 92 49 1:30 4,406
5 7 206,640 790 364 19:80 43,666
6 8 14,595,840 16,572 3,023 31:11 1,141,977
7 9 477,912,960 261,198 ??? 17:18:39 16,800,403
8 10 32,793,465,600 ??? ??? ??? ???
9 11 1,505,781,446,400 ??? ??? ??? ???
10 12 86,189,631,897,600 ??? ??? ??? ???


Order = number of derivatives of the metric in each term.
Indices = number of free indices on the terms.
Gen. Terms = number of terms generated by the SIGTREE routine.
Non-Zero = number of terms with non-zero coefficients.
Minimal = actual number of independent terms after Riemann symmetries.
Time = run time on SPARC 10 in hours:minutes:seconds
Size = size of result file in bytes.
??? = currently unknown or unavailable.

We can see that beyond order 6 we begin to deal with an extraordinary number of terms. Even at that order, reducing 16,522 terms down to a minimal set will be non-trivial initially.

The order 8 case creates some difficulties since the integers go beyond
machine precision. This is being looked into.

Step by step calculation of sigma coincidence limits

I now want to show how coincidence limits can be done in a step-by-step brute force way beginning from first principles. This is a Mathematica and MathTensor session run on the SPARC 10.

Start up

We start out by setting up a timer and loading the software.


  timestart = SessionTime[];


  <<MathTensor.m

Due to the huge number of loops and substitutions in these calculations, the default value of the recursion limit has to be changed.


  $RecursionLimit = 512000;

I enter the expression which defines sigma when set equal to zero. I also enter the first three well known coincidence limits of covariant derivatives of sigma.


  DefineSigma :=
          Canonicalize[sigma - (1/2) CD[sigma,ua] CD[sigma,la]]


  RuleUnique[sigmaonerule,CD[sigma,la_],0]


  RuleUnique[sigmatworule,CD[sigma,la_,lb_],Metricg[la,lb]]


  RuleUnique[sigmathreerule,CD[sigma,la_,lb_,lc_],0]

Four Derivative Case

I start by taking four derivatives of the sigma defining equation and then applying the known lower derivative rules:


  DefineSigma


  CD[%,la,lb,lc,ld]


  Expand[%]


  ApplyRules[%,{sigmaonerule,sigmatworule,sigmathreerule}]

The OrderCD function looks at the derivatives, sees that they are not in lexical order, and then commutes derivatives until they are. This generates more lower derivative terms that are eliminated by applying the sigmaonerule and sigmatworule:


  OrderCD[%]


  ApplyRules[%,{sigmaonerule,sigmatworule}]

Finally, I solve for the coincidence limit of four derivatives of sigma and then define sigmafourrule using the RuleUnique function. This is saved to
a file later and can be used immediately.


  Solve[%==0,CD[sigma,la,lb,lc,ld]]


  RuleUnique[sigmafourrule,CD[sigma,la_,lb_,lc_,ld_],
  %[[1]][[1]][[2]]]

Five Derivative Case

The five derivative case is done the same way as the four derivative case:


  DefineSigma


  Expand[CD[%,la,lb,lc,ld,le]]


  ApplyRules[%,{sigmaonerule,sigmatworule,sigmathreerule}]


  OrderCD[%]


  ApplyRules[%,{sigmaonerule,sigmatworule,sigmathreerule}]


  Solve[%==0,CD[sigma,la,lb,lc,ld,le]]


  RuleUnique[sigmafiverule,CD[sigma,la_,lb_,lc_,ld_,le_],
  %[[1]][[1]][[2]]]

Six Derivative Case


  DefineSigma


  Expand[CD[%,la,lb,lc,ld,le,lf]]


  Expand[%]


  ApplyRules[%,
  {sigmaonerule,sigmatworule,sigmathreerule,sigmafourrule}]


  OrderCD[%]


  ApplyRules[%,
  {sigmaonerule,sigmatworule,sigmathreerule,sigmafourrule}]


  Solve[%==0,CD[sigma,la,lb,lc,ld,le,lf]]


  RuleUnique[sigmasixrule,CD[sigma,la_,lb_,lc_,ld_,le_,lf_],
  %[[1]][[1]][[2]]]

Seven Derivative Case


  DefineSigma


  Expand[CD[%,la,lb,lc,ld,le,lf,lg]]


  ApplyRules[%,
  {sigmaonerule,sigmatworule,sigmathreerule,sigmafourrule,
  sigmafiverule}]


  OrderCD[%]


  ApplyRules[%,
  {sigmaonerule,sigmatworule,sigmathreerule,sigmafourrule,
  sigmafiverule}]


  Solve[%==0,CD[sigma,la,lb,lc,ld,le,lf,lg]]


  RuleUnique[sigmasevenrule,CD[sigma,la_,lb_,lc_,ld_,le_,lf_,lg_],
  %[[1]][[1]][[2]]]

Saving the Results

Since these calculations only need to be done once, we can save them
to a common file which can be loaded in other sessions. The entire
process of computing and saving these derivatives took about 40 minutes.
Is can be made faster by not printing the formatted results to the
screen.


  Definition[$RecursionLimit] >> sigmarules.m


  Definition[DefineSigma] >>> sigmarules.m


  Definition[sigmaonerule] >>> sigmarules.m


  Definition[sigmatworule] >>> sigmarules.m


  Definition[sigmathreerule] >>> sigmarules.m


  Definition[sigmafourrule] >>> sigmarules.m


  Definition[sigmafiverule] >>> sigmarules.m


  Definition[sigmasixrule] >>> sigmarules.m


  Definition[sigmasevenrule] >>> sigmarules.m


  timefinal = Expand[(SessionTime[] - timestart)/60]

Eight Derivative Case

The eight derivative case requires a few different commands due to its
extreme size.


  DefineSigma


  Expand[CD[%,la,lb,lc,ld,le,lf,lg,lh]]


  ApplyRules[%,{sigmaonerule,sigmatworule,sigmathreerule}]

It is necessary to canonicalize this expression to reduce the number of
terms - here from 189 to 98.


  Canonicalize[%]


  Length[%%]


  Length[%%]

It is also correct to split out the pure covariant derivative terms so that OrderCD will not look at them. There are seven pure derivative terms that appear at the end of the equation.


  eightderivterms = Take[%%%,-7]


  mixedderivterms = Drop[%%%%,-7]


  mixedderivtermsfinal = 
  ApplyRules[%,{sigmaonerule,sigmatworule,sigmathreerule,
  sigmafourrule,sigmafiverule,sigmasixrule}]


  Clear[mixedderivterms]


  OrderCD[eightderivterms]


  eightderivtermsfinal = 
  ApplyRules[%,{sigmaonerule,sigmatworule,sigmathreerule,
  sigmafourrule,sigmafiverule,sigmasixrule}]


  Clear[eightderivterms]


  Clear["sigma*"]


  Expand[-(mixedderivtermsfinal + eightderivtermsfinal)/7]


  % >> sigma8.m

Index Sums

Now that we have the unsummed index terms, we can easily compute examples with index pair summations:


  CD[sigma,la,ua,lc,uc,le,ue]


  ApplyRules[%,sigmasixrule]


  Canonicalize[%]

Some built in rules about Riemann tensor help to simplify the results. Ultimately, a very large list of rules will need to be produced so that the smallest possible results occur. Note that one possible invariant R^2
does not occur.


  ApplyRules[%,RiemannRules]

A final important note - It would be possible to compute this result from DefineSigma as was done with the non-sum cases. This proves to be
more time consuming for all cases than doing the sums on the non-summed
result stored in sigmarules.m.

Bi-vector Example

It is easy to consider other coincidence limits - like the bi-vector of parallel displacement. Here we need indices at the point x' and get
them by loading alternate indices.


  AddIndexTypes


  DefineTensor[bi,"I",{{1,2},1}]

The define equation is defineI == 0 from:


  defineI = Canonicalize[CD[bi[li,auj],uc] CD[sigma,lc]]


  RuleUnique[bizerorule,bi[li1_,auj],Metricg[li1,uj],!SameQ[li1,li]]


  CD[defineI,la]


  ApplyRules[%,{sigmaonerule,sigmatworule}]


  RuleUnique[bionerule,CD[bi[li_,auj],la_],0]


  CD[defineI,la,lb]


  ApplyRules[%,{sigmaonerule,sigmatworule,sigmathreerule}]


  OrderCD[%]


  % /. bizerorule


  Solve[%==0,CD[bi[li,auj],la,lb]]


  RuleUnique[bitworule,CD[bi[li_,auj],la_,lb_],%[[1]][[1]][[2]]]


  CD[defineI,la,lb,lc]


  ApplyRules[%,{sigmaonerule,sigmatworule,sigmathreerule,sigmafourrule}]


  ApplyRules[%,bionerule]


  OrderCD[%]


  ApplyRules[%,{bizerorule,bionerule}]


  Solve[%==0,CD[bi[li,auj],la,lb,lc]]


  RuleUnique[bithreerule,CD[bi[li_,auj],la_,lb_,lc_],
  %[[1]][[1]][[2]]]

Potential solutions to problem size

Faster Microprocessors

Multiprocessors or multiple computers in parallel

Faster Algorithms

Diagramatic representations of results

Minimize the size of all intermedicate expressions

Define what problems actually need to be solved

Find a general pattern from lower order results