hossi said:
Hi vanesh,
I am sorry cause I can't use the mathematica stuff. I can open the files but can't execute them.
Yes, with the reader you can only view them, but as I executed them in Mathematica, you can read the results of the commands...
Although it is a bit clumsy, the expressions should speak for themselves if you are used to Mathematica. (and with a bit more effort and guess work, even if you are not).
I'll try to explain the gist of the approach: I use two kinds of objects: matrices (nested lists with depth 2 - standard convention in Mathematica), and functions.
On the first line, g, for instance, is a matrix. To address elements of a matrix, one writes g[[ a, b]] where a and b are the number of the row and the column, respectively (from 1 to 4).
On the next line, I print it out in "matrixform".
Same for eta: it's a matrix.
Now, E1 is your famous E matrix (but E exists in mathematica). Now, I think there's a bug there (or, better, a limitation), in that I'm not sure that Sqrt takes the MATRIX square root, should check it. But for diagonal matrices as we are using here, that doesn't matter.
So E1 is a matrix too.
tau1 is calculated from E1 (Inverse is the instruction for matrix inversion, Transpose for transposition, should be evident), and printed out.
I print out the result of tau1 in "matrix form". Tau1 is the matrix of the form of tau as in your equation (22) second paper.
gunder is the inverse matrix of g (and hence also the matrix of g^{a,b}).
I print it out.
tau2 is the other form of tau, which is the inverse transposed of tau1. It is also a matrix, and printed out.
And then things get a bit more involved.
First, var is a list of 4 symbols, which represent the 4 coordinates (in which the elements of all these matrices are expressed). I need this in order to be able to translate something like partial_3 (g_{1,1}):
I take g_{1,1}, which is, in mathematica, g[[1,1]], and then I have to compute its derivative wrt the third variable. The symbol of the third variable is var[[3]], so this derivative becomes:
D[g[[1,1]] , var[[3]] ]
(D is the derivative function in mathematica: D[f(x,y),x] is \partial_x f )
Mathematica doesn't know the Einstein summation convention, so I have to explicitly sum over, eh, sums:
Sum[expression,{i,1,4}] will be the sum of expression, 4 times, where i takes on respectively the values 1,2,3, and 4.
gammaunder[nu_,lambda_,kappa_] is NOT a matrix, but a function (of 3 numbers, all within range 1 to 4). That is, if you type gammaunder[1,3,3], it will return you an expression, supposed to be the Christoffel symbols of the kind you give in appendix A.
In its description, one has to imagine that at the moment of calling, the nu, lambda and kappa take on the numerical values given by the caller.
I first need to sum over the index alpha for the entire expression and will need to further sum in certain terms over k and aa.
With what I've explained, you should be able to verify that this implements your expression (10) of the second paper.
Proof of the pudding is the eating:
I next construct the list of all the possible calls to the function gammaunder, in the big list gams. I do this by looping over the three call parameters, from 1 to 4.
Then I print out the result, together with the corresponding call parameters:
So the first line is 1 1 1 0, which means that gamma^t_{t,t} = 0
(1 = first variable, = t).
As such I reconstruct the list you give in appendix A (equation (83)).
You can check it, we are in agreement, which is also a proof that this approach works well.
Next, I apply the same technique to calculate the normal Christoffel symbols, and I print out the list.
The function deltau1 is made in a similar way. It is the implementation of equation (19) of your first paper. And then I realized I didn't need it.
deltau2 is again build up in a similar way. It is the implementation of the covariant derivative of tau2, as in my previous message. It is the equivalent of equation (19), but for this form of tau which appears in the last term of equation (39), first paper.
Next step, I define a list of 4 functions, which is going to represent the t in equation (39): t1[lambda], t2[lambda], t3[lambda] and t4[lambda].
These are abstract functions in mathematica, it only says that they are functions of lambda (will be nice to take the derivative to lambda).
speedequation[alpha_] is a function that will write out explicitly equation (39) for a given numerical value of alpha (1 to 4), in the form described in my previous message.
speed[[nu]] stands for t^{nu}. For instance, speed[[3]] is t3[lambda].
I make the list of the 4 equations (by calling speedequation[ww] for ww 1,2, 3 and 4), which gives me the set of 4 equations, and this list of equations is called speedeqs.
In it, we have the expression of the derivatives of t1, t2,... to lambda, the functions t1, t2... themselves, and expressions as a function of the coordinates.
I next use a replacement rule in which I replace the functions t1, t2, t3 and t4 themselves (but not their derivatives) by 1, 0, 0, and 0.
This comes down to setting d x^0 / dlambda = 1, and d x^1/d lambda ... = 0, in other words, a particle which is initially, as a function of lambda, at rest in the coordinate frame. The d x^0 / dlambda = 1 makes that the rate of change of x^0 (the frame time coordinate) equals the curve parameter lambda change (so initially, the curve is parametrised in coordinate time).
As such, the derivatives of t1, t2 and t3 represent the "accelerations" in the given coordinate system (the second derivatives to time = curve parameter of the coordinate values).
There are not many "personal feelings" mixed into this, so there's no vengence. It's just that it is probably more productive to do explicit calculations than repeating my argument for the 25th time.