hendriksdf5

65 Reputation

4 Badges

0 years, 273 days

MaplePrimes Activity


These are questions asked by hendriksdf5

I would like to calculate the following quantity: 

 

Where F is the SU(2) field strength tensor given by:

The gauge field V (in my code A) is defined as

 

where rj is the unit vector in spherical coordinates.

I tried to calculate it with maple, however, the result is not correct. I should get a scalar function, but my result still contains dependencies on x,y,z. And I really don't know why. I have defined the gauge field in (11) and the field strength tensor in (14). I could imagine that SumOverRepeatedIndices() in (16) does not work as I think (For each a = (1,2,3) I would like a summation over mu and nu). Greek letters are my spacetime indices and lowercase letters are my space indices. Do I perhaps have to use SU(2) indices instead of the space indices? But how exactly does a SU(2) index differ from a space index?    

restart

with(Physics)

__________________________________________________________________

(1)

with(Vectors)NULL

Setup(spacetimeindices = greek, spaceindices = lowercaselatin, su2indices = uppercaselatin, signature = `+++-`, coordinates = spherical)

[coordinatesystems = {X}, signature = `+ + + -`, spaceindices = lowercaselatin, spacetimeindices = greek, su2indices = uppercaselatin]

(2)

Setup(realobjects = {g, diff(x, x), diff(y(x), x), diff(z(x), x), f__A(X[1])})

[realobjects = {g, phi, r, rho, theta, x, `x'`, y, `y'`, z, `z'`, f__A(r)}]

(3)

"x'(r,theta,phi)  :=  r * sin(theta) * cos(phi)"

proc (r, theta, phi) options operator, arrow, function_assign; Physics:-`*`(r, sin(theta), cos(phi)) end proc

(4)

"y'(r,theta,phi) := r * sin(theta) * sin(phi)"

proc (r, theta, phi) options operator, arrow, function_assign; Physics:-`*`(r, sin(theta), sin(phi)) end proc

(5)

"z'(r,theta,phi)  := r * cos(theta)"

proc (r, theta, phi) options operator, arrow, function_assign; Physics:-`*`(r, cos(theta)) end proc

(6)

 

This ist my unit vector:

Define(R[a] = [(diff(x, x))/r, (diff(y(x), x))/r, (diff(z(x), x))/r]) 

{Physics:-Dgamma[mu], Physics:-Psigma[mu], R[a], Physics:-d_[mu], Physics:-g_[mu, nu], Physics:-gamma_[a, b], Physics:-LeviCivita[alpha, beta, mu, nu], Physics:-SpaceTimeVector[mu](X)}

(7)

R[definition]

R[a] = [`x'`/r, `y'`/r, `z'`/r]

(8)

Parse:-ConvertTo1D, "first argument to _Inert_ASSIGN must be assignable"

r^2

(9)

"Define(A[mu,~a] =(1-`f__A`(X[1]) )/(g*X[1])*LeviCivita[a, mu,j,4]* R[j] )  "

{A[mu, `~a`], Physics:-Dgamma[mu], F[mu, nu, a], Physics:-Psigma[mu], R[a], Physics:-d_[mu], Physics:-g_[mu, nu], Physics:-gamma_[a, b], Physics:-LeviCivita[alpha, beta, mu, nu], Physics:-SpaceTimeVector[mu](X)}

(10)

A[definition]

A[mu, `~a`] = (1-f__A(r))*Physics:-LeviCivita[4, a, j, mu]*R[j]/(g*r)

(11)

A[]

A[mu, a] = Matrix(%id = 36893489989479580364)

(12)

Define(F[mu, nu, a] = d_[nu](A[mu, a])-d_[mu](A[nu, a])+LeviCivita[a, b, c, 4]*A[mu, `~b`]*A[nu, `~c`])

{A[i, `~a`], Physics:-Dgamma[mu], F[mu, nu, a], Physics:-Psigma[mu], R[a], Physics:-d_[mu], Physics:-g_[mu, nu], Physics:-gamma_[a, b], Physics:-LeviCivita[alpha, beta, mu, nu], Physics:-SpaceTimeVector[mu](X)}

(13)

F[definition]

F[mu, nu, a] = -Physics:-d_[nu](A[a, mu], [X])+Physics:-d_[mu](A[a, nu], [X])-Physics:-LeviCivita[4, a, b, c]*A[mu, `~b`]*A[nu, `~c`]

(14)

simplify(F[])

F[mu, nu, a] = _rtable[36893489989585113204]

(15)

"-1/(4)Simplify(SumOverRepeatedIndices(F[mu,nu,a]*F[~mu,~nu,a])); "

-(1/4)*((2*(-1+f__A(r))*`z'`*r*g-(diff(f__A(r), r))*`z'`*r^2*g-(-1+f__A(r))^2*`z'`*`x'`)^2+4*(-1+f__A(r))^4*`y'`^2*`z'`^2+((diff(f__A(r), r))*`x'`*r^2*g+2*(1-f__A(r))*`x'`*r*g+(1-f__A(r))*(-1+f__A(r))*`z'`^2)^2+((diff(f__A(r), r))*`y'`*r^2*g+2*(1-f__A(r))*`y'`*r*g+(-1+f__A(r))^2*`y'`*`x'`)^2+(2*(-1+f__A(r))*`x'`*r*g-(diff(f__A(r), r))*`x'`*r^2*g-(-1+f__A(r))*(1-f__A(r))*`y'`^2)^2+(-2*(-1+f__A(r))*`z'`*r*g+(diff(f__A(r), r))*`z'`*r^2*g+(-1+f__A(r))^2*`z'`*`x'`)^2+(-(diff(f__A(r), r))*`x'`*r^2*g-2*(1-f__A(r))*`x'`*r*g-(1-f__A(r))*(-1+f__A(r))*`z'`^2)^2+2*(-1+f__A(r))^4*`x'`^4+2*(-1+f__A(r))^4*`y'`^2*`x'`^2+2*(-1+f__A(r))^4*`z'`^2*`x'`^2+(-(diff(f__A(r), r))*`y'`*r^2*g-2*(1-f__A(r))*`y'`*r*g-(-1+f__A(r))^2*`y'`*`x'`)^2+(-2*(-1+f__A(r))*`x'`*r*g+(diff(f__A(r), r))*`x'`*r^2*g+(-1+f__A(r))*(1-f__A(r))*`y'`^2)^2)/(r^8*g^4)

(16)

L__FST := simplify(-(1/4)*((2*(-1+f__A(r))*`z'`*r*g-(diff(f__A(r), r))*`z'`*r^2*g-(-1+f__A(r))^2*`z'`*`x'`)^2+4*(-1+f__A(r))^4*`y'`^2*`z'`^2+((diff(f__A(r), r))*`x'`*r^2*g+2*(1-f__A(r))*`x'`*r*g+(1-f__A(r))*(-1+f__A(r))*`z'`^2)^2+((diff(f__A(r), r))*`y'`*r^2*g+2*(1-f__A(r))*`y'`*r*g+(-1+f__A(r))^2*`y'`*`x'`)^2+(2*(-1+f__A(r))*`x'`*r*g-(diff(f__A(r), r))*`x'`*r^2*g-(-1+f__A(r))*(1-f__A(r))*`y'`^2)^2+(-2*(-1+f__A(r))*`z'`*r*g+(diff(f__A(r), r))*`z'`*r^2*g+(-1+f__A(r))^2*`z'`*`x'`)^2+(-(diff(f__A(r), r))*`x'`*r^2*g-2*(1-f__A(r))*`x'`*r*g-(1-f__A(r))*(-1+f__A(r))*`z'`^2)^2+2*(-1+f__A(r))^4*`x'`^4+2*(-1+f__A(r))^4*`y'`^2*`x'`^2+2*(-1+f__A(r))^4*`z'`^2*`x'`^2+(-(diff(f__A(r), r))*`y'`*r^2*g-2*(1-f__A(r))*`y'`*r*g-(-1+f__A(r))^2*`y'`*`x'`)^2+(-2*(-1+f__A(r))*`x'`*r*g+(diff(f__A(r), r))*`x'`*r^2*g+(-1+f__A(r))*(1-f__A(r))*`y'`^2)^2)/(r^8*g^4))

(-g^2*r^4*(`x'`^2+(1/2)*`y'`^2+(1/2)*`z'`^2)*(diff(f__A(r), r))^2+4*g^2*r^3*(`x'`^2+(1/2)*`y'`^2+(1/2)*`z'`^2)*(-1+f__A(r))*(diff(f__A(r), r))-4*((1/8)*(`x'`^2+`y'`^2+`z'`^2)^2*f__A(r)^2-(1/4)*(`x'`^2+`y'`^2+`z'`^2)^2*f__A(r)+(1/8)*`x'`^4+(g^2*r^2+(1/4)*`y'`^2+(1/4)*`z'`^2)*`x'`^2+(1/2)*(g^2*r^2+(1/4)*`y'`^2+(1/4)*`z'`^2)*(`y'`^2+`z'`^2))*(-1+f__A(r))^2)/(r^8*g^4)

(17)

 

Download SU(2)-field-strength-tensor_.mw

Is there a way to apply Intc() and Fundiff() in spherical coordinates? If I initialize a spherical coordinate system X and then want to calculate the effect with Intc(), r, theta phi and t are integrated from -inf to inf but  thtea:(0, pi) phi:(0, 2Pi). I would also need a second spherical coordinate system Y, if I have understood Fundiff() correctly, but how can I define this Coordinates(X = spherical, Y = spherical) does not work.  

I would like to vary my Lagrange density (16) with respect to f_A(r). Where r is the radial coordinate of the spherical coordinate system.

YANG-MILLS-Theorie.mw

Context of My Code:

I want to determine the SU(2) field strength tensor for a specific field configuration(later the equations of motion). I have managed to implement the covariant derivative and the gauge field, but now I am encountering problems with the field strength tensor. When substituting the definitions of my gauge field (7) and my covariant derivative (13) into my field strength tensor (14), the following problems occur:

  1. The derivatives do not act on f(r) or r (r should be the radial component of my coordinate system).
  2. The unit vectors are not explicitly multiplied together. Mixed terms should vanish and quadratic terms should result in one.

I am not even sure if I can properly form F[]^2 due to my definition in (4). I have seen in the setup that there are SU(2) indices, but I couldn't find anything helpful on how to handle this. Is it better to use SU(2) indexing?

It would be nice if someone could tell me why my terms are not simplifying or direct me to where I need to look to understand it.

Here is my code: 

SU(2)_Field_Strength.mw

I have the following problem, I want to define my own covariant derivative. This mixes my gauge fields with the Pauli matrices. My Setup() looks like this:   

restart;
with(Physics);
Setup(spacetimeindices = greek, spaceindices = lowercaselatin_ah);
Setup(signature = `-++ +`);
Setup(coordinates = spherical);

 

And this is my covariant derivative: 

Define(D[mu] = d_[mu] + 1/2*ig*Psigma[a]*A[mu, a])

If I output the tensor, MAPLE should automatically perform a summation over the spatial indices a, right? It looks like this in my case: 

I find the indexing a bit strange. When I look at the first entry, for example. Why does a in A[mu,a] go from 1-3 and the a of Psigma[a] from 2-4? They should both be spatial indices, right? Can I change the indexing in Setup() or am I doing something wrong here?  

Is there a way to define tensor components without addressing each component individually? Suppose I define a tensor A[a, mu], where Latin letters are space coordinates and Greek letters are space-time coordinates. Is there an easy way to define multiple components without having to define each component separately. For example, A[a,0] = 0 and A[a,i] = LeviCevita[a,i,j].

restart;
with(Physics);
Setup(spaceindices = lowercaselatin_ah)
g_[]
Define(A[a, mu])
A[a, 1] := 0
A[a, b] := LeviCivita[a, b, c]
TensorArray(A[a, mu]) 
A[1, 2] := 0
A[2, 3] := LeviCivita[2, 3, c]
TensorArray(A[a, mu])

The general writing method does not seem to change the tensor components, but the writing method in which I address the components individually does. What exactly am I doing wrong? 

1 2 Page 2 of 2