ecterrab

14540 Reputation

24 Badges

20 years, 21 days

MaplePrimes Activity


These are answers submitted by ecterrab

Hi mwahab

Unfortunately, Mapleprime's mechanism for uploading and displaying the contents of a worksheet is not working, so below, you have only the link to this reply.

In brief, what you have done incorrectly is to assume that splitting the determining system into cases concerning k (so, not pde, but its determining system) would take you to the symmetries of each case of splitting pde into cases with respect to k. Although that may work in some cases, it is not assured that it will work in all cases.

In the worksheet attached I show three things: 1) and 2) are concretely different -however equivalent - approaches to split the symmetries into cases with respect to parameters, then 3) is how to tell when the approach you used will work. 

When the Mapleprimes mechanism to upload and display the contents of a worksheet is restored, I will repost this answer with the contents visible. Your question is indeed interesting for a wider audience, I think.

Download How_to_split_symmetries_into_cases.mw

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

 


 

I can't help you with a grtensor issue but Maple already comes with routines more advanced and easier to use than grtensor; what follows then illustrates how you could do your computation using the official-Maple Physics package; for more info you can take a look to its help page, ?Physics

"f(t):=a(t)^(2);"

proc (t) options operator, arrow, function_assign; a(t)^2 end proc

(1)

with(Physics)

Setup(signature = `+---`, coord = cartesian, metric = dt^2-f(t)*(dx^2+dy^2+dz^2))

[coordinatesystems = {X}, metric = {(1, 1) = 1, (2, 2) = -a(t)^2, (3, 3) = -a(t)^2, (4, 4) = -a(t)^2}, signature = `+ - - -`]

(2)

Check the metric

g_[]

Physics:-g_[mu, nu] = Matrix(%id = 18446744078320164726)

(3)

The Ricci tensor is Ricci[mu,nu]. Its definition, one component, all the nonzero, and its matrix form

Ricci[definition]

Physics:-Ricci[mu, nu] = Physics:-d_[alpha](Physics:-Christoffel[`~alpha`, mu, nu], [X])-Physics:-d_[nu](Physics:-Christoffel[`~alpha`, mu, alpha], [X])+Physics:-Christoffel[`~beta`, mu, nu]*Physics:-Christoffel[`~alpha`, beta, alpha]-Physics:-Christoffel[`~beta`, mu, alpha]*Physics:-Christoffel[`~alpha`, nu, beta]

(4)

With compact display, derivatives are displayed indexed (to have them displayed in non-compact form, input OFF for details see CompactDisplay )

Ricci[1, 1]

-3*(diff(diff(a(t), t), t))/a(t)

(5)

Ricci[nonzero]

Physics:-Ricci[mu, nu] = {(1, 1) = -3*(diff(diff(a(t), t), t))/a(t), (2, 2) = 2*(diff(a(t), t))^2+a(t)*(diff(diff(a(t), t), t)), (3, 3) = 2*(diff(a(t), t))^2+a(t)*(diff(diff(a(t), t), t)), (4, 4) = 2*(diff(a(t), t))^2+a(t)*(diff(diff(a(t), t), t))}

(6)

Ricci[]

Physics:-Ricci[mu, nu] = Matrix(%id = 18446744078320134734)

(7)

"Ricci[~]"

Physics:-Ricci[`~mu`, `~nu`] = Matrix(%id = 18446744078195215886)

(8)

Define a tensor as the product of a scalar and a covariant derivative (following your worksheet)

fyr[mu, nu] = fY(t)*Ricci[mu, nu]

fyr[mu, nu] = fY(t)*Physics:-Ricci[mu, nu]

(9)

Define(fyr[mu, nu] = fY(t)*Physics[Ricci][mu, nu])

`Defined objects with tensor properties`

 

{Physics:-D_[mu], Physics:-Dgamma[mu], Physics:-Psigma[mu], Physics:-Ricci[mu, nu], Physics:-Riemann[mu, nu, alpha, beta], Physics:-Weyl[mu, nu, alpha, beta], Physics:-d_[mu], fyr[mu, nu], Physics:-g_[mu, nu], Physics:-Christoffel[mu, nu, alpha], Physics:-Einstein[mu, nu], Physics:-LeviCivita[alpha, beta, mu, nu], Physics:-SpaceTimeVector[mu](X)}

(10)

Check it out

fyr[definition]

fyr[mu, nu] = fY(t)*Physics:-Ricci[mu, nu]

(11)

fyr[1, 1]

-3*fY(t)*(diff(diff(a(t), t), t))/a(t)

(12)

fyr[nonzero]

fyr[mu, nu] = {(1, 1) = -3*fY(t)*(diff(diff(a(t), t), t))/a(t), (2, 2) = fY(t)*(2*(diff(a(t), t))^2+a(t)*(diff(diff(a(t), t), t))), (3, 3) = fY(t)*(2*(diff(a(t), t))^2+a(t)*(diff(diff(a(t), t), t))), (4, 4) = fY(t)*(2*(diff(a(t), t))^2+a(t)*(diff(diff(a(t), t), t)))}

(13)

fyr[]

fyr[mu, nu] = Matrix(%id = 18446744078328236022)

(14)

"fyr[~]"

fyr[`~mu`, `~nu`] = Matrix(%id = 18446744078328191686)

(15)

The covariant derivative is D_[mu]

D_[mu](fyr[mu, beta])

Physics:-D_[mu](fyr[beta, `~mu`], [X])

(16)

The components of arbitrary tensorial expressions are visible using TensorArray

TensorArray(Physics[D_][mu](fyr[beta, `~mu`], [X]))

Array(%id = 18446744078349157910)

(17)

"simplify(?)"

Array(%id = 18446744078349166342)

(18)

The double contraction

D_[mu](D_[nu](fyr[mu, nu]))

Physics:-D_[mu](Physics:-D_[nu](fyr[`~mu`, `~nu`]), [X])

(19)

Summing over the repeated indices

SumOverRepeatedIndices(Physics[D_][mu](Physics[D_][nu](fyr[`~mu`, `~nu`]), [X]), simplifier = simplify)

(-3*(diff(diff(diff(diff(a(t), t), t), t), t))*fY(t)*a(t)^2+(-6*a(t)^2*(diff(fY(t), t))-9*a(t)*fY(t)*(diff(a(t), t)))*(diff(diff(diff(a(t), t), t), t))-3*fY(t)*(diff(diff(a(t), t), t))^2*a(t)+(-3*a(t)^2*(diff(diff(fY(t), t), t))-9*a(t)*(diff(a(t), t))*(diff(fY(t), t))+15*fY(t)*(diff(a(t), t))^2)*(diff(diff(a(t), t), t))+6*(diff(a(t), t))^3*(diff(fY(t), t)))/a(t)^3

(20)

Simplifying properties (first set indicates symmetires, second set antisimmetries)

Library:-GetTensorSymmetryProperties(fyr)

{[1, 2]}, {}

(21)

LeviCivita[mu, nu, alpha, beta]*fyr[alpha, beta]

Physics:-LeviCivita[alpha, beta, mu, nu]*fyr[alpha, beta]

(22)

Simplify(Physics[LeviCivita][alpha, beta, mu, nu]*fyr[alpha, beta])

0

(23)

Raising and lowering indices

"g_[~mu,~nu]  fyr[nu,alpha]"

Physics:-g_[`~mu`, `~nu`]*fyr[alpha, nu]

(24)

Simplify(Physics[g_][`~mu`, `~nu`]*fyr[alpha, nu])

fyr[alpha, `~mu`]

(25)

Or in one go using the `.` product operator instead of `*`

"g_[~mu,~nu] .  fyr[nu,alpha]"

fyr[alpha, `~mu`]

(26)

I imagine the above suffices for you to develop your computation; if not, could you please give more details (that do not require having grtensor installed).

 

NULL

NULL

Warning: grOptionMetricPath has not been assigned.

Default metric is now fr.

 

grcalc(R(dn, dn))

`CPU Time ` = 0.16e-1

(27)

NULL

grdef("fyr{c d}:=R{c d}*fY(t) ")

Created definition for fyr(dn,dn)

 

 

grcalc(fyr(dn, dn))

`CPU Time ` = 0.

(28)

 

NULLgrdisplay(fyr(dn, dn))

fyr[a]*``[b] = (array( 1 .. 4, 1 .. 4, [( 2, 1 ) = (0), ( 4, 1 ) = (0), ( 1, 4 ) = (0), ( 1, 2 ) = (0), ( 2, 4 ) = (0), ( 3, 2 ) = (0), ( 3, 4 ) = (0), ( 3, 1 ) = (0), ( 4, 3 ) = (0), ( 3, 3 ) = ((2*(diff(a(t), t))^2+a(t)*(diff(diff(a(t), t), t)))*fY(t)), ( 2, 2 ) = ((2*(diff(a(t), t))^2+a(t)*(diff(diff(a(t), t), t)))*fY(t)), ( 2, 3 ) = (0), ( 4, 2 ) = (0), ( 1, 3 ) = (0), ( 4, 4 ) = ((2*(diff(a(t), t))^2+a(t)*(diff(diff(a(t), t), t)))*fY(t)), ( 1, 1 ) = (-3*(diff(diff(a(t), t), t))*fY(t)/a(t))  ] ))

(29)

grcalc(Box[fyr(dn, dn)])

`CPU Time ` = 0.63e-1

(30)

NULL

NULL

grcalc(fyr(dn, dn, cup, cup))

`CPU Time ` = 0.63e-1

(31)

NULLNULL

Parse could not create a functional expression for:

  "Tensor_(rc,[dn,dn,dn],[c,d,e],0)≔Tensor_(R,[dn,dn,cdn],[c,d,e],0)"
Please recheck the definition.

Error, (in grtensor:-grF_strToDef) parse() failed

 

This is generic definition of the generic VcVd (fY·Rab)

grdef("kt2{a b c d}:=fyr{a b;c d}")

This object is already defined. The new definition has been ignored.

 

grdisplay(kt2(dn, dn, up, up))

Created definition for kt2(dn,dn,up,up)

kt2(dn,dn,up,up) has not been calculated.

 

grcalc(kt2(up, up, dn, dn))

`CPU Time ` = 0.

(32)

now i want to define contracted quantity  using contraction with upper metrics g^{cd}

grdef("kt3:=kt2{abcd}*g{^cd}*g{^ab}")

Indices in name: [[], []]

Indices in definition: [[c], []]

Error, (in grtensor:-grdef) lhs/rhs index conflict.

 

NULL 

grdef("kt4{a c}:=kt2{abcd}*g{^bd}")

Indices in name: [[], [a, c]]

Indices in definition: [[b], [a]]

Error, (in grtensor:-grdef) lhs/rhs index conflict.

 

``


 

Download grtensor_v2_(reviewed).mw

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

It suffices to equate to 0 the functional derivative, which you can compute with Physics:-Fundiff. Now, the Maple input line you show is not correct on several counts; for one you are using [] as () (in Maple, [] are used to enter lists of objects), then e^ is probably meant to be exp(). I'd suggest you to try to write the problem correctly, then give a look at the help page ?Physics,Fundiff.

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

Hi WouterSe
I adjusted the solution you posted to be, in 1D Maple input syntax,

sol_Wouter := `ξr`(r,t) = sin(1/2*Pi*r)*cos(1/2*(kappa/Mu)^(1/2)*Pi*t);

Then tried

pdetest(sol_Wouter, [eqn, ic, bc]);

              [      /1     \      /Pi \         ]
              [0, sin|- Pi r| - sin|---|, 0, 0, 0]
              [      \2     /      \2 r/         ]

So the first ic is not satisfied. Indeed, your first ic reads  `ξr`(r, 0) = sin(Pi/(2*r)), not sin(Pi*r/2). Of course, if you change  sin(Pi/(2*r)) by sin(Pi*r/2) in sol_Wouter, then the PDE (your eqn) does not cancel. 

So, the solution you are expecting is not correct for the problem you posted.

Guessing what could be wrong in your post, from the output by pdetest above, if you change the right-hand side of your first ic from sin(Pi/(2*r)) to sin(Pi*r/2), then the (corrected above) solution you posted cancels all of eqn, ic and bc. But then pdsolve also returns the simpler solution:

# change your ic from sin(Pi/(2*r) to sin(Pi*r/2)

ic := `ξr`(r, 0) = sin(Pi*r/2), D[2](`ξr`)(r, 0) = 0:

pdsolve([eqn, ic, bc], Zeta(r, t));

        `ξr`(r,t) = sin(1/2*Pi*r) * cos(1/2*kappa^(1/2)*Pi*t/Mu^(1/2))

In summary: to get from pdsolve the "simple" solution, you need to correct your input (the first ic). For the input you presented, there is no simple solution that I could see, and the infinite sum solution returned by pdsolve is correct.

 

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

Hi

I don't fully understand the formulation you are trying to do - I mean the problem itself, not how to represent it in Maple.

 

Generally speaking, using Physics is probably simpler for this kind of problem, what I understood from your post is that you are working with cartesian coordinates, in two dimensions, with this metric

with(Physics)

Setup(coordinates = cartesian, dimension = 2, metric = -dx^2*t^2+dt^2)

 

`Default differentiation variables for d_, D_ and dAlembertian are:`*{X = (x, t)}

 

`Systems of spacetime coordinates are:`*{X = (x, t)}

 

_______________________________________________________

 

[coordinatesystems = {X}, dimension = 2, metric = {(1, 1) = -t^2, (2, 2) = 1}]

(1)

Check it out

g_[]

Physics:-g_[mu, nu] = Matrix(%id = 18446744078362563758)

(2)

and you want to compute the geodesics for this spacetime, ie the solutions of

Geodesics()

[diff(diff(t(tau), tau), tau) = -t(tau)*(diff(x(tau), tau))^2, diff(diff(x(tau), tau), tau) = -2*(diff(x(tau), tau))*(diff(t(tau), tau))/t(tau)]

(3)

You can call dsolve on these equations, or directly:

Geodesics(output = solutions)

{t(tau) = _C2*tau+_C3, x(tau) = _C1}, {t(tau) = _C4*((_C1*_C2+_C1*tau+4)*(_C1*_C2+_C1*tau-4))^(1/2), x(tau) = -(1/2)*ln(_C1*_C2+_C1*tau+4)+(1/2)*ln(_C1*_C2+_C1*tau-4)+_C3}

(4)

Now, what do you mean by "plotting these geodesics in polar coordinates using the time as the radius" and what do you mean by "[the time] normalized to our current time equal to unity". You say "to plot starting at "x = 0, t = 1. X is the polar angle" but there is no X here, only the cartesian x and the image does not suffice to understand what you actually want. And, you know, to plot any of the solutions (4) you'd need initial conditions (not just a starting point [x__0, t__0]) fixing the arbitrary constants present in these solutions.

 

If you could give a clear-cut description of what you want - mathematically speaking, disregard for now the Maple way of representing the problem - it can most probably be done with ease, departing from the input/output above, either using plots:-polaplot  or Physics:-TransformCoordinates  and the commands of the plots  package.


 

Download polar_plot_of_geodesics.mw

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

Hi

I am curious about your question ... No, you cannot define a 'tensor of rank 0' because that is a scalar, and everything in Maple is already a scalar. I mean: from the computational point of view, what distinguishes a tensor from everything else are two things: 1) its behaviour under a transformation of coordinates (only applicable to tensors of rank > 0, see ?Physics:-TransformCoordinates) and 2) the sum rule for repeated indices (also for tensors of rank > 0). So, in Maple, you do not need to define a 'scalar' (tensor of rank 0) because, generally speaking, everything is a scalar unless you indicate it is a tensor (of rank > 0).

Trying to figure out what you intend to do with Theta = varepsilon[mu, ~mu](X) , maybe you want to have Theta as a computational representation for varepsilon[mu, ~mu](X) ... ? You can achieve that also via alias(Theta = varepsilon[mu, ~mu](X) ) or assigning as in  Theta := varepsilon[mu, ~mu](X). Or if you want to compute with a scalar function, e.g. Theta(X), just use Theta(X). If you don't want to have the display showing the (X) dependency, use Physics:-CompactDisplay, or even alias(Theta = Theta(X)).

Or perhaps I am not understanding what you have in mind - if that is the case could you please give more details to frame your question and understand what you intend to do with Theta(X) that would require a tensor (of rank 0) definition?

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

Hi

Thanks to all for the feedback. The sense of community grows with that. The problem is fixed and the fix is available to everybody within the Physics Updates v.430 and higher.

Comments: this problem fixed is not related to the Physics Updates or any of its versions - for instance, without it, you get the same result posted by nm. The problem was actually a combination of two facts. 

  1. int(Sum(0, j = 1 .. infinity), tau = 0 .. t) returns Sum(0, j = 1 .. infinity)*t instead of 0. Although not incorrect, this is what I'd call an inconvenient weakness.
  2. Unfortunately, that was happening in a place where the code checks for 0, and Sum(0, j = 1 .. infinity)*t is syntactically different from 0, an then the flow moved forward in a case where it should have stopped.

This is now tracked in the internal database as an issue in int, and it is always good to detect these cases, no matter how surprising they could seem.

Investigating this problem also helped to detect another place where the flow could be streamlined, so now pdsolve works faster in some examples. But for this problem, the result we get with v.430 is still NULL, not a solution.

I will give a look at the suggestion by Rouben, he always has good ideas; anyway, this is what I think is a general approach for this kind of problem: change variables avoiding symmetric bc's, as shown in the worksheet below.

NOTE AFTER POSTING: The approach explained in the worksheet below is already implemented within the Physics Updates version 431, so that the solution shown below as (6) is the current output for pdsolve([pde, ic, bc]).

Physics:-Version()

`The "Physics Updates" version in the MapleCloud is 430 and is the same as the version installed in this computer, created 2019, September 23, 13:35 hours, found in the directory /Users/ecterrab/maple/toolbox/2019/Physics Updates/lib/`

(1)

pde := diff(u(x, t), `$`(t, 2)) = 4*(diff(u(x, t), `$`(x, 2))); ic := u(x, 0) = 0, (D[2](u))(x, 0) = sin(x)^2; bc := u(-Pi, t) = 0, u(Pi, t) = 0

diff(diff(u(x, t), t), t) = 4*(diff(diff(u(x, t), x), x))

 

u(x, 0) = 0, (D[2](u))(x, 0) = sin(x)^2

 

u(-Pi, t) = 0, u(Pi, t) = 0

(2)

With the Physics Updates v.430 we still get no solution

pdsolve([pde, ic, bc])

So change variables removing the symmetric bcs; ie proc (x) options operator, arrow; xi-Pi end proc

tr := {t = tau, x = xi-Pi, u(x, t) = upsilon(xi, tau)}

itr := solve(tr, {tau, xi, upsilon(xi, tau)})

{tau = t, xi = x+Pi, upsilon(xi, tau) = u(x, t)}

(3)

PDEtools:-dchange(tr, [pde, ic, bc])

[diff(diff(upsilon(xi, tau), tau), tau) = 4*(diff(diff(upsilon(xi, tau), xi), xi)), upsilon(xi, 0) = 0, (D[2](upsilon))(xi, 0) = sin(xi)^2, upsilon(0, tau) = 0, upsilon(2*Pi, tau) = 0]

(4)

Solve this problem

pdsolve([diff(diff(upsilon(xi, tau), tau), tau) = 4*(diff(diff(upsilon(xi, tau), xi), xi)), upsilon(xi, 0) = 0, (D[2](upsilon))(xi, 0) = sin(xi)^2, upsilon(0, tau) = 0, upsilon(2*Pi, tau) = 0])

upsilon(xi, tau) = (1/315)*(315*(Sum(16*sin((1/2)*n*xi)*sin(n*tau)*((-1)^n-1)/(Pi*n^2*(n^2-16)), n = 5 .. infinity))*Pi+672*sin(tau)*sin((1/2)*xi)+160*sin((3/2)*xi)*sin(3*tau))/Pi

(5)

Change variables back

PDEtools:-dchange(itr, upsilon(xi, tau) = (1/315)*(315*(Sum(16*sin((1/2)*n*xi)*sin(n*tau)*((-1)^n-1)/(Pi*n^2*(n^2-16)), n = 5 .. infinity))*Pi+672*sin(tau)*sin((1/2)*xi)+160*sin((3/2)*xi)*sin(3*tau))/Pi)

u(x, t) = (1/315)*(315*(Sum(16*sin((1/2)*n*(x+Pi))*sin(t*n)*((-1)^n-1)/(Pi*n^2*(n^2-16)), n = 5 .. infinity))*Pi+672*sin(t)*cos((1/2)*x)-160*cos((3/2)*x)*sin(3*t))/Pi

(6)

And that is it. Verify this solution

pdetest(u(x, t) = (1/315)*(315*(Sum(16*sin((1/2)*n*(x+Pi))*sin(t*n)*((-1)^n-1)/(Pi*n^2*(n^2-16)), n = 5 .. infinity))*Pi+672*sin(t)*cos((1/2)*x)-160*cos((3/2)*x)*sin(3*t))/Pi, [pde, ic, bc])

[0, 0, (1/210)*(105*Pi*cos(2*x)-105*Pi+3360*(Sum(sin((1/2)*n*(x+Pi))*((-1)^n-1)/(n^3-16*n), n = 5 .. infinity))-320*cos((3/2)*x)+448*cos((1/2)*x))/Pi, 0, 0]

(7)

So we have one ic that needs a plotting test:

zero := [0, 0, (1/210)*(105*Pi*cos(2*x)-105*Pi+3360*(Sum(sin((1/2)*n*(x+Pi))*((-1)^n-1)/(n^3-16*n), n = 5 .. infinity))-320*cos((3/2)*x)+448*cos((1/2)*x))/Pi, 0, 0][3]

(1/210)*(105*Pi*cos(2*x)-105*Pi+3360*(Sum(sin((1/2)*n*(x+Pi))*((-1)^n-1)/(n^3-16*n), n = 5 .. infinity))-320*cos((3/2)*x)+448*cos((1/2)*x))/Pi

(8)

From the bc, the relevant interval is x = -Pi .. Pi. and indeed in that interval zero is numerically sufficiently close to 0 up to Digits (= 10)

plot(eval(zero, [infinity = 1000, Sum = add]), x = -Pi .. Pi)

 

``


 

Download fixed_in_v.440_and_approach_to_solve_the_problem.mw

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

I may not be understanding your question precisely - what do you mean by "ignoring the Christoffel symbols with coefficients of order Omega(r)^2". Given the metric g[mu, nu], you cannot force the Christoffel symbols be something different than their definition

Christoffel[definition]

Physics:-Christoffel[alpha, mu, nu] = (1/2)*Physics:-d_[nu](Physics:-g_[alpha, mu], [X])+(1/2)*Physics:-d_[mu](Physics:-g_[alpha, nu], [X])-(1/2)*Physics:-d_[alpha](Physics:-g_[mu, nu], [X])

(1)

So assuming you meant to depart from GAMMA[alpha, mu, nu] and create another tensor, say `Ѓ`[alpha, mu, nu] with the same dimensions and components but where all the ones with degree > 1 in Omega(r) are equal to 0, below you see one way of doing that. Using the definition of other tensors that are functions of GAMMA[alpha, mu, nu] you can compute the equivalent ones based on `Ѓ`[alpha, mu, nu].

with(Physics)

[`*`, `.`, Annihilation, AntiCommutator, Antisymmetrize, Assume, Bra, Bracket, Check, Christoffel, Coefficients, Commutator, CompactDisplay, Coordinates, Creation, D_, Dagger, Decompose, Define, Dgamma, Einstein, EnergyMomentum, Expand, ExteriorDerivative, Factor, FeynmanDiagrams, Fundiff, Geodesics, GrassmannParity, Gtaylor, Intc, Inverse, Ket, KillingVectors, KroneckerDelta, LeviCivita, Library, LieBracket, LieDerivative, Normal, NumericalRelativity, Parameters, PerformOnAnticommutativeSystem, Projector, Psigma, Redefine, Ricci, Riemann, Setup, Simplify, SortProducts, SpaceTimeVector, StandardModel, SubstituteTensor, SubstituteTensorIndices, SumOverRepeatedIndices, Symmetrize, TensorArray, Tetrads, ThreePlusOne, ToFieldComponents, ToSuperfields, Trace, TransformCoordinates, Vectors, Weyl, `^`, dAlembertian, d_, diff, g_, gamma_]

(2)

In the worksheet, you posted you forgot to set the coordinates, and from trial an error I can see you also changed the signature to be (+ - - -). I am adding that line here:

 

Setup(signature = `+---`, coordinates = spherical)

[coordinatesystems = {X}, signature = `+ - - -`]

(3)

This is the metric you indicated

Setup(metric = -exp(2*alpha(r))*%d_(t)^2+exp(2*beta(r))*%d_(r)^2+r^2*%d_(theta)^2+r^2*sin(theta)^2*(%d_(phi)-Omega(r)*%d_(t))^2)

[metric = {(1, 1) = -exp(2*alpha(r))+(-r^2*cos(theta)^2+r^2)*Omega(r)^2, (1, 4) = -r^2*sin(theta)^2*Omega(r), (2, 2) = exp(2*beta(r)), (3, 3) = r^2, (4, 4) = r^2*sin(theta)^2}]

(4)

g_[]

Physics:-g_[mu, nu] = Matrix(%id = 18446744078451462142)

(5)

These are the nonzero components

Christoffel[nonzero]

Physics:-Christoffel[alpha, mu, nu] = {(1, 1, 2) = -(diff(alpha(r), r))*exp(2*alpha(r))-r*Omega(r)*(cos(theta)-1)*(cos(theta)+1)*(r*(diff(Omega(r), r))+Omega(r)), (1, 1, 3) = r^2*sin(theta)*Omega(r)^2*cos(theta), (1, 2, 1) = -(diff(alpha(r), r))*exp(2*alpha(r))-r*Omega(r)*(cos(theta)-1)*(cos(theta)+1)*(r*(diff(Omega(r), r))+Omega(r)), (1, 2, 4) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (1, 3, 1) = r^2*sin(theta)*Omega(r)^2*cos(theta), (1, 3, 4) = -r^2*sin(theta)*Omega(r)*cos(theta), (1, 4, 2) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (1, 4, 3) = -r^2*sin(theta)*Omega(r)*cos(theta), (2, 1, 1) = (diff(alpha(r), r))*exp(2*alpha(r))+r*Omega(r)*(cos(theta)-1)*(cos(theta)+1)*(r*(diff(Omega(r), r))+Omega(r)), (2, 1, 4) = (1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (2, 2, 2) = (diff(beta(r), r))*exp(2*beta(r)), (2, 3, 3) = -r, (2, 4, 1) = (1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (2, 4, 4) = -r*sin(theta)^2, (3, 1, 1) = -r^2*sin(theta)*Omega(r)^2*cos(theta), (3, 1, 4) = r^2*sin(theta)*Omega(r)*cos(theta), (3, 2, 3) = r, (3, 3, 2) = r, (3, 4, 1) = r^2*sin(theta)*Omega(r)*cos(theta), (3, 4, 4) = -r^2*sin(theta)*cos(theta), (4, 1, 2) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (4, 1, 3) = -r^2*sin(theta)*Omega(r)*cos(theta), (4, 2, 1) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (4, 2, 4) = r*sin(theta)^2, (4, 3, 1) = -r^2*sin(theta)*Omega(r)*cos(theta), (4, 3, 4) = r^2*sin(theta)*cos(theta), (4, 4, 2) = r*sin(theta)^2, (4, 4, 3) = r^2*sin(theta)*cos(theta)}

(6)

You can tell the system to make equal to zero the components having degree > 1 in Omega(r), and use that Array to define another tensor, `Ѓ`[alpha, mu, nu]. For that purpose, take a closer look at the structure (6): you want to operate on all algebraic expressions (note that equations `=` are not of type algebraic). Also, the degree command will get confused with diff(Omega(r), r) but not with (D(Omega))(r) which is the same derivative but represented using D  notation. You switch from the diff  and D notations using convert . The command is subsindets . Puting all together,

convert(subsindets(convert(Physics:-Christoffel[alpha, mu, nu] = {(1, 1, 2) = -(diff(alpha(r), r))*exp(2*alpha(r))-r*Omega(r)*(cos(theta)-1)*(cos(theta)+1)*(r*(diff(Omega(r), r))+Omega(r)), (1, 1, 3) = r^2*sin(theta)*Omega(r)^2*cos(theta), (1, 2, 1) = -(diff(alpha(r), r))*exp(2*alpha(r))-r*Omega(r)*(cos(theta)-1)*(cos(theta)+1)*(r*(diff(Omega(r), r))+Omega(r)), (1, 2, 4) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (1, 3, 1) = r^2*sin(theta)*Omega(r)^2*cos(theta), (1, 3, 4) = -r^2*sin(theta)*Omega(r)*cos(theta), (1, 4, 2) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (1, 4, 3) = -r^2*sin(theta)*Omega(r)*cos(theta), (2, 1, 1) = (diff(alpha(r), r))*exp(2*alpha(r))+r*Omega(r)*(cos(theta)-1)*(cos(theta)+1)*(r*(diff(Omega(r), r))+Omega(r)), (2, 1, 4) = (1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (2, 2, 2) = (diff(beta(r), r))*exp(2*beta(r)), (2, 3, 3) = -r, (2, 4, 1) = (1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (2, 4, 4) = -r*sin(theta)^2, (3, 1, 1) = -r^2*sin(theta)*Omega(r)^2*cos(theta), (3, 1, 4) = r^2*sin(theta)*Omega(r)*cos(theta), (3, 2, 3) = r, (3, 3, 2) = r, (3, 4, 1) = r^2*sin(theta)*Omega(r)*cos(theta), (3, 4, 4) = -r^2*sin(theta)*cos(theta), (4, 1, 2) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (4, 1, 3) = -r^2*sin(theta)*Omega(r)*cos(theta), (4, 2, 1) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (4, 2, 4) = r*sin(theta)^2, (4, 3, 1) = -r^2*sin(theta)*Omega(r)*cos(theta), (4, 3, 4) = r^2*sin(theta)*cos(theta), (4, 4, 2) = r*sin(theta)^2, (4, 4, 3) = r^2*sin(theta)*cos(theta)}, D), algebraic, proc (u) options operator, arrow; if 1 < degree(u, Omega(r)) then 0 else u end if end proc), diff)

Physics:-Christoffel[alpha, mu, nu] = {(1, 1, 2) = -(diff(alpha(r), r))*exp(2*alpha(r)), (1, 1, 3) = 0, (1, 2, 1) = -(diff(alpha(r), r))*exp(2*alpha(r)), (1, 2, 4) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (1, 3, 1) = 0, (1, 3, 4) = -r^2*sin(theta)*Omega(r)*cos(theta), (1, 4, 2) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (1, 4, 3) = -r^2*sin(theta)*Omega(r)*cos(theta), (2, 1, 1) = (diff(alpha(r), r))*exp(2*alpha(r)), (2, 1, 4) = (1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (2, 2, 2) = (diff(beta(r), r))*exp(2*beta(r)), (2, 3, 3) = -r, (2, 4, 1) = (1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (2, 4, 4) = -r*sin(theta)^2, (3, 1, 1) = 0, (3, 1, 4) = r^2*sin(theta)*Omega(r)*cos(theta), (3, 2, 3) = r, (3, 3, 2) = r, (3, 4, 1) = r^2*sin(theta)*Omega(r)*cos(theta), (3, 4, 4) = -r^2*sin(theta)*cos(theta), (4, 1, 2) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (4, 1, 3) = -r^2*sin(theta)*Omega(r)*cos(theta), (4, 2, 1) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (4, 2, 4) = r*sin(theta)^2, (4, 3, 1) = -r^2*sin(theta)*Omega(r)*cos(theta), (4, 3, 4) = r^2*sin(theta)*cos(theta), (4, 4, 2) = r*sin(theta)^2, (4, 4, 3) = r^2*sin(theta)*cos(theta)}

(7)

In the above you see, for instance, that the component (1,1,3) is now equal to 0. As said, you cannot define GAMMA[alpha, mu, nu] to be something different than its definition, but you can  Define  another tensor with these components.

Define(`&GJcy;`[alpha, mu, nu] = Array(`$`(1 .. 4, 3), rhs(Physics:-Christoffel[alpha, mu, nu] = {(1, 1, 2) = -(diff(alpha(r), r))*exp(2*alpha(r)), (1, 1, 3) = 0, (1, 2, 1) = -(diff(alpha(r), r))*exp(2*alpha(r)), (1, 2, 4) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (1, 3, 1) = 0, (1, 3, 4) = -r^2*sin(theta)*Omega(r)*cos(theta), (1, 4, 2) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (1, 4, 3) = -r^2*sin(theta)*Omega(r)*cos(theta), (2, 1, 1) = (diff(alpha(r), r))*exp(2*alpha(r)), (2, 1, 4) = (1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (2, 2, 2) = (diff(beta(r), r))*exp(2*beta(r)), (2, 3, 3) = -r, (2, 4, 1) = (1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (2, 4, 4) = -r*sin(theta)^2, (3, 1, 1) = 0, (3, 1, 4) = r^2*sin(theta)*Omega(r)*cos(theta), (3, 2, 3) = r, (3, 3, 2) = r, (3, 4, 1) = r^2*sin(theta)*Omega(r)*cos(theta), (3, 4, 4) = -r^2*sin(theta)*cos(theta), (4, 1, 2) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (4, 1, 3) = -r^2*sin(theta)*Omega(r)*cos(theta), (4, 2, 1) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (4, 2, 4) = r*sin(theta)^2, (4, 3, 1) = -r^2*sin(theta)*Omega(r)*cos(theta), (4, 3, 4) = r^2*sin(theta)*cos(theta), (4, 4, 2) = r*sin(theta)^2, (4, 4, 3) = r^2*sin(theta)*cos(theta)})))

{Physics:-D_[mu], Physics:-Dgamma[mu], Physics:-Psigma[mu], Physics:-Ricci[mu, nu], Physics:-Riemann[mu, nu, alpha, beta], Physics:-Weyl[mu, nu, alpha, beta], Physics:-d_[mu], Physics:-g_[mu, nu], Ѓ[alpha, mu, nu], Physics:-Christoffel[mu, nu, alpha], Physics:-Einstein[mu, nu], Physics:-LeviCivita[alpha, beta, mu, nu], Physics:-SpaceTimeVector[mu](X)}

(8)

Set a macro for `&GJcy;` to avoid having to use the palette all the time

macro(G = `&GJcy;`)

Check it out

G[1, 1, 3]

0

(9)

G[nonzero]

Ѓ[mu, nu, alpha] = {(1, 1, 2) = -(diff(alpha(r), r))*exp(2*alpha(r)), (1, 2, 1) = -(diff(alpha(r), r))*exp(2*alpha(r)), (1, 2, 4) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (1, 3, 4) = -r^2*sin(theta)*Omega(r)*cos(theta), (1, 4, 2) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (1, 4, 3) = -r^2*sin(theta)*Omega(r)*cos(theta), (2, 1, 1) = (diff(alpha(r), r))*exp(2*alpha(r)), (2, 1, 4) = (1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (2, 2, 2) = (diff(beta(r), r))*exp(2*beta(r)), (2, 3, 3) = -r, (2, 4, 1) = (1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (2, 4, 4) = -r*sin(theta)^2, (3, 1, 4) = r^2*sin(theta)*Omega(r)*cos(theta), (3, 2, 3) = r, (3, 3, 2) = r, (3, 4, 1) = r^2*sin(theta)*Omega(r)*cos(theta), (3, 4, 4) = -r^2*sin(theta)*cos(theta), (4, 1, 2) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (4, 1, 3) = -r^2*sin(theta)*Omega(r)*cos(theta), (4, 2, 1) = -(1/2)*r*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r)), (4, 2, 4) = r*sin(theta)^2, (4, 3, 1) = -r^2*sin(theta)*Omega(r)*cos(theta), (4, 3, 4) = r^2*sin(theta)*cos(theta), (4, 4, 2) = r*sin(theta)^2, (4, 4, 3) = r^2*sin(theta)*cos(theta)}

(10)

Of course, you can do the same with Ricci, Riemann, etc. to have versions of them where all the terms with degree > 2 in Omega(r) are discarded. The following is also not something you asked but illustrates well how to work with `&GJcy;` and reusing definitions of other tensors; take for instance Ricci

Ricci[definition]

Physics:-Ricci[mu, nu] = Physics:-d_[alpha](Physics:-Christoffel[`~alpha`, mu, nu], [X])-Physics:-d_[nu](Physics:-Christoffel[`~alpha`, mu, alpha], [X])+Physics:-Christoffel[`~beta`, mu, nu]*Physics:-Christoffel[`~alpha`, beta, alpha]-Physics:-Christoffel[`~beta`, mu, alpha]*Physics:-Christoffel[`~alpha`, nu, beta]

(11)

You can now define an alternative R[mu, nu], say `&Rscr;`[mu, nu]based on `&GJcy;`[mu, nu, alpha]:

subs(Christoffel = G, Ricci = `&Rscr;`, Physics:-Ricci[mu, nu] = Physics:-d_[alpha](Physics:-Christoffel[`~alpha`, mu, nu], [X])-Physics:-d_[nu](Physics:-Christoffel[`~alpha`, mu, alpha], [X])+Physics:-Christoffel[`~beta`, mu, nu]*Physics:-Christoffel[`~alpha`, beta, alpha]-Physics:-Christoffel[`~beta`, mu, alpha]*Physics:-Christoffel[`~alpha`, nu, beta])

`&Rscr;`[mu, nu] = Physics:-d_[alpha](Ѓ[`~alpha`, mu, nu], [X])-Physics:-d_[nu](Ѓ[`~alpha`, alpha, mu], [X])+Ѓ[`~beta`, mu, nu]*Ѓ[`~alpha`, alpha, beta]-Ѓ[`~beta`, alpha, mu]*Ѓ[`~alpha`, beta, nu]

(12)

Define(`&Rscr;`[mu, nu] = Physics:-d_[alpha](Ѓ[`~alpha`, mu, nu], [X])-Physics:-d_[nu](Ѓ[`~alpha`, alpha, mu], [X])+Ѓ[`~beta`, mu, nu]*Ѓ[`~alpha`, alpha, beta]-Ѓ[`~beta`, alpha, mu]*Ѓ[`~alpha`, beta, nu])

`Defined objects with tensor properties`

 

{`&Rscr;`[mu, nu], Physics:-D_[mu], Physics:-Dgamma[mu], Physics:-Psigma[mu], Physics:-Ricci[mu, nu], Physics:-Riemann[mu, nu, alpha, beta], Physics:-Weyl[mu, nu, alpha, beta], Physics:-d_[mu], Physics:-g_[mu, nu], Ѓ[alpha, mu, nu], Physics:-Christoffel[mu, nu, alpha], Physics:-Einstein[mu, nu], Physics:-LeviCivita[alpha, beta, mu, nu], Physics:-SpaceTimeVector[mu](X)}

(13)

Create a macro for R to skip the palette

macro(R = `&Rscr;`)

R[1, 1]

(1/2)*(2*(-2*(diff(beta(r), r))+2*(diff(alpha(r), r)))*exp(-2*beta(r)+2*alpha(r))*(diff(alpha(r), r))*r+2*exp(-2*beta(r)+2*alpha(r))*(diff(diff(alpha(r), r), r))*r+exp(-2*beta(r)+2*alpha(r))*(diff(alpha(r), r))*(-2*cos(theta)^2*Omega(r)*(diff(Omega(r), r))*r^3*exp(-2*alpha(r))-2*cos(theta)^2*Omega(r)^2*r^2*exp(-2*alpha(r))+2*Omega(r)*(diff(Omega(r), r))*r^3*exp(-2*alpha(r))+2*r^2*Omega(r)^2*exp(-2*alpha(r))+2*(diff(alpha(r), r))*r+2*(diff(beta(r), r))*r+4)-2*(-cos(theta)^2*(diff(Omega(r), r))*Omega(r)*r^2*exp(-2*alpha(r))-2*cos(theta)^2*Omega(r)^2*r*exp(-2*alpha(r))+r^2*Omega(r)*(diff(Omega(r), r))*exp(-2*alpha(r))+2*r*Omega(r)^2*exp(-2*alpha(r))+2*(diff(alpha(r), r)))*exp(-2*beta(r)+2*alpha(r))*(diff(alpha(r), r))*r+exp(-2*beta(r))*sin(theta)^2*(r*(diff(Omega(r), r))+2*Omega(r))*(cos(theta)^2*Omega(r)^2*(diff(Omega(r), r))*exp(-2*alpha(r))*r^3+2*cos(theta)^2*Omega(r)^3*exp(-2*alpha(r))*r^2-Omega(r)^2*(diff(Omega(r), r))*exp(-2*alpha(r))*r^3-2*Omega(r)^3*exp(-2*alpha(r))*r^2-2*Omega(r)*(diff(alpha(r), r))*r+r*(diff(Omega(r), r))+2*Omega(r))*r+4*Omega(r)^2*cos(theta)^2*(cos(theta)^2*Omega(r)^2*r^2*exp(-2*alpha(r))-r^2*Omega(r)^2*exp(-2*alpha(r))+1)*r)/r

(14)

From Riemann[definition]

Riemann[definition]

Physics:-Riemann[alpha, beta, mu, nu] = Physics:-g_[alpha, lambda]*(Physics:-d_[mu](Physics:-Christoffel[`~lambda`, beta, nu], [X])-Physics:-d_[nu](Physics:-Christoffel[`~lambda`, beta, mu], [X])+Physics:-Christoffel[`~lambda`, upsilon, mu]*Physics:-Christoffel[`~upsilon`, beta, nu]-Physics:-Christoffel[`~lambda`, upsilon, nu]*Physics:-Christoffel[`~upsilon`, beta, mu])

(15)

applying the same procedure you can get one defined in terms of `&GJcy;`, and using the approach to discard terms used for Christoffel you can discard terms in this one too.

 

``


 

Download Alternative_Christoffel_without_some_terms.mw

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

This is fixed in V.428 or higher of the Physics Updates; you get

restart; pde := diff(u(x, t), t) = diff(u(x, t), `$`(x, 2)); bc := u(-Pi, t) = u(Pi, t), (D[1](u))(-Pi, t) = (D[1](u))(Pi, t); pdsolve([pde, bc], u(x, t))

diff(u(x, t), t) = diff(diff(u(x, t), x), x)

 

u(-Pi, t) = u(Pi, t), (D[1](u))(-Pi, t) = (D[1](u))(Pi, t)

 

u(x, t) = exp(-t)*_C3*(exp(I*x)*_C1+exp(-I*x)*_C2), u(x, t) = _C3*(_C1+_C2)

(1)

map(pdetest, [u(x, t) = exp(-t)*_C3*(exp(I*x)*_C1+exp(-I*x)*_C2), u(x, t) = _C3*(_C1+_C2)], [pde, bc])

[[0, 0, 0], [0, 0, 0]]

(2)

``

 

NOTE AFTER  THE POST: by installing the Physics Updates v.433 or higher, you get a more general form of the solution.
 

Download fixed_in_v.428.mw

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functuions, Maplesoft

Hi

This is fixed in the Physics Updates version 427 or higher. In version 426, unfortunately a file of the version under development got loaded inadvertently, creating an out of sync issue. Thanks for posting the problem.

Best
Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

Below I intercalated comments italized, showing how to use casesplit to tackle the problem. Note also that through casesplit you can choose to use rifsimp, DifferentialAlgebra or DifferentialThomas as differential elimination engines. By default, for this problem it uses rifsimp (the non-integer powers are replaced by auxiliary functions satisfying differential equations).

restart; with(PDEtools); declare(u(t, x), A(t), B(t), F(t))

` u`(t, x)*`will now be displayed as`*u

 

` A`(t)*`will now be displayed as`*A

 

` B`(t)*`will now be displayed as`*B

 

` F`(t)*`will now be displayed as`*F

(1)

det_eqs := [2*(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx)) = 0, 2*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx), x))+2*uxx*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), ux), uxx), uxx))+2*ux*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx), uxx)) = 0, 2*(diff(Lambda1(t, x, u, ux, uxx), uxx))*B(t)+(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx))*B(t)*uxx+(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx))*F(t)*u+(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx))*A(t)*u^n*ux = 0, 2*(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx))*ux+2*(diff(diff(Lambda1(t, x, u, ux, uxx), ux), uxx))*uxx-2*(diff(Lambda1(t, x, u, ux, uxx), ux))+2*(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), x)) = 0, 3*(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx))*B(t)+(diff(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx), uxx))*B(t)*uxx+(diff(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx), uxx))*F(t)*u+(diff(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx), uxx))*A(t)*u^n*ux = 0, ux^2*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), u), u), uxx))+2*ux*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx), x))-ux*(diff(diff(Lambda1(t, x, u, ux, uxx), u), ux))-uxx*(diff(diff(Lambda1(t, x, u, ux, uxx), ux), ux))+uxx^2*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), ux), ux), uxx))+uxx*(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx))+2*uxx*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), ux), uxx), x))+2*uxx*ux*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), u), ux), uxx))-(diff(diff(Lambda1(t, x, u, ux, uxx), ux), x))+diff(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), x), x) = 0, 2*uxx*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), ux), uxx), uxx))*A(t)*u^n*ux+4*(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), x))*B(t)+4*(diff(diff(Lambda1(t, x, u, ux, uxx), ux), uxx))*B(t)*uxx+2*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), ux), uxx), uxx))*B(t)*uxx^2+4*ux*(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx))*B(t)+2*ux*(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx))*F(t)+2*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx), x))*B(t)*uxx+2*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx), x))*F(t)*u+2*(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx))*A(t)*u^n*n*ux^2/u+2*uxx*(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx))*A(t)*u^n+2*uxx*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), ux), uxx), uxx))*F(t)*u+2*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx), uxx))*A(t)*u^n*ux^2+2*ux*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx), uxx))*B(t)*uxx+2*ux*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx), uxx))*F(t)*u+2*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx), x))*A(t)*u^n*ux = 0, 2*ux*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx), x))*B(t)*uxx+2*ux*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx), x))*F(t)*u+(diff(diff(diff(Lambda1(t, x, u, ux, uxx), u), u), uxx))*A(t)*u^n*ux^3+ux^2*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), u), u), uxx))*B(t)*uxx+ux^2*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), u), u), uxx))*F(t)*u+2*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx), x))*A(t)*u^n*ux^2-(diff(diff(Lambda1(t, x, u, ux, uxx), u), ux))*A(t)*u^n*ux^2-ux*(diff(diff(Lambda1(t, x, u, ux, uxx), u), ux))*F(t)*u-2*uxx*(diff(Lambda1(t, x, u, ux, uxx), ux))*A(t)*u^n+2*ux^2*(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx))*F(t)+(diff(diff(diff(Lambda1(t, x, u, ux, uxx), ux), ux), uxx))*B(t)*uxx^3+ux^2*(diff(diff(Lambda1(t, x, u, ux, uxx), u), u))*B(t)-(diff(Lambda1(t, x, u, ux, uxx), x))*A(t)*u^n+2*ux*(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), x))*F(t)-ux*(diff(Lambda1(t, x, u, ux, uxx), ux))*F(t)+2*ux*(diff(diff(Lambda1(t, x, u, ux, uxx), u), x))*B(t)+(diff(diff(Lambda1(t, x, u, ux, uxx), ux), x))*B(t)*uxx+2*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), ux), uxx), x))*B(t)*uxx^2+(diff(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), x), x))*F(t)*u-(diff(diff(Lambda1(t, x, u, ux, uxx), ux), x))*F(t)*u+(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx))*B(t)*uxx^2+uxx*(diff(Lambda1(t, x, u, ux, uxx), uxx))*F(t)+(diff(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), x), x))*B(t)*uxx+(diff(Lambda1(t, x, u, ux, uxx), u))*F(t)*u+2*(diff(Lambda1(t, x, u, ux, uxx), u))*B(t)*uxx-uxx*(diff(diff(Lambda1(t, x, u, ux, uxx), ux), ux))*F(t)*u+uxx*ux*(diff(diff(Lambda1(t, x, u, ux, uxx), u), ux))*B(t)+uxx*(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx))*F(t)*u+2*ux*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), u), ux), uxx))*B(t)*uxx^2+2*uxx*ux*(diff(diff(Lambda1(t, x, u, ux, uxx), ux), uxx))*F(t)+2*uxx*(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), x))*A(t)*u^n+2*uxx*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), ux), uxx), x))*F(t)*u+2*uxx*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), u), ux), uxx))*A(t)*u^n*ux^2+2*uxx*ux*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), u), ux), uxx))*F(t)*u+3*uxx*(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx))*A(t)*u^n*ux+2*uxx*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), ux), uxx), x))*A(t)*u^n*ux+uxx^2*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), ux), ux), uxx))*A(t)*u^n*ux-uxx*(diff(diff(Lambda1(t, x, u, ux, uxx), ux), ux))*A(t)*u^n*ux+Lambda1(t, x, u, ux, uxx)*F(t)+2*uxx*(diff(diff(Lambda1(t, x, u, ux, uxx), ux), uxx))*A(t)*u^n*n*ux^2/u+3*uxx*(diff(Lambda1(t, x, u, ux, uxx), uxx))*A(t)*u^n*n*ux/u+(diff(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), x), x))*A(t)*u^n*ux-(diff(diff(Lambda1(t, x, u, ux, uxx), ux), x))*A(t)*u^n*ux+(diff(diff(Lambda1(t, x, u, ux, uxx), x), x))*B(t)-(diff(Lambda1(t, x, u, ux, uxx), t))+2*uxx^2*(diff(diff(Lambda1(t, x, u, ux, uxx), ux), uxx))*A(t)*u^n+uxx^2*(diff(diff(diff(Lambda1(t, x, u, ux, uxx), ux), ux), uxx))*F(t)*u+2*(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx))*A(t)*u^n*n*ux^3/u+(diff(Lambda1(t, x, u, ux, uxx), uxx))*A(t)*u^n*n^2*ux^3/u^2-(diff(Lambda1(t, x, u, ux, uxx), uxx))*A(t)*u^n*n*ux^3/u^2+2*(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), x))*A(t)*u^n*n*ux^2/u-(diff(Lambda1(t, x, u, ux, uxx), ux))*A(t)*u^n*n*ux^2/u = 0, diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx) = 0, diff(diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx), uxx) = 0]

The command PDEtools:-casesplit handles no only non-integer powers but also known functions and arbitrary compositions of all of those. Now, your system involves 4 unknown functions

indets(det_eqs, unknown); show

{A(t), B(t), F(t), Lambda1(t, x, u, ux, uxx)}

(2)

Your call to DEtools[rifsimp with CL_multipliers := [Lambda1(t, x, u, ux, uxx)] is equivalent to take A, B  and F as arbitrary functions. For arbitrary values of them, the only solution to your system is

NULL

casesplit(det_eqs, Lambda1, arbitrary = {A, B, F})

`casesplit/ans`([diff(Lambda1(t, x, u, ux, uxx), t) = Lambda1(t, x, u, ux, uxx)*F(t), diff(Lambda1(t, x, u, ux, uxx), x) = 0, diff(Lambda1(t, x, u, ux, uxx), u) = 0, diff(Lambda1(t, x, u, ux, uxx), ux) = 0, diff(Lambda1(t, x, u, ux, uxx), uxx) = 0], [])

(3)

More interesting, you can split this problem into cases if you take all of A, B and F as solving variables ranked lower than Lambda1 (see discussion on rankings in the help page for PDEtools:-casesplit )

casesplit(det_eqs, [Lambda1, {A, B, F}])

`casesplit/ans`([diff(Lambda1(t, x, u, ux, uxx), t) = Lambda1(t, x, u, ux, uxx)*F(t), diff(Lambda1(t, x, u, ux, uxx), x) = 0, diff(Lambda1(t, x, u, ux, uxx), u) = 0, diff(Lambda1(t, x, u, ux, uxx), ux) = 0, diff(Lambda1(t, x, u, ux, uxx), uxx) = 0], [A(t) <> 0, B(t) <> 0]), `casesplit/ans`([diff(diff(Lambda1(t, x, u, ux, uxx), x), x) = (diff(Lambda1(t, x, u, ux, uxx), t)-Lambda1(t, x, u, ux, uxx)*F(t))/B(t), diff(Lambda1(t, x, u, ux, uxx), u) = 0, diff(Lambda1(t, x, u, ux, uxx), ux) = 0, diff(Lambda1(t, x, u, ux, uxx), uxx) = 0, A(t) = 0], [B(t) <> 0]), `casesplit/ans`([diff(diff(Lambda1(t, x, u, ux, uxx), uxx), x) = -(diff(diff(Lambda1(t, x, u, ux, uxx), ux), uxx))*uxx-(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx))*ux+diff(Lambda1(t, x, u, ux, uxx), ux), diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx) = 0, diff(Lambda1(t, x, u, ux, uxx), t) = ((diff(Lambda1(t, x, u, ux, uxx), uxx))*A(t)*u^n*n^2*ux^3+(diff(Lambda1(t, x, u, ux, uxx), ux))*A(t)*u^n*n*ux^2*u+3*uxx*(diff(Lambda1(t, x, u, ux, uxx), uxx))*A(t)*u^n*n*ux*u-(diff(Lambda1(t, x, u, ux, uxx), uxx))*A(t)*u^n*n*ux^3-(diff(Lambda1(t, x, u, ux, uxx), x))*A(t)*u^n*u^2+ux*(diff(Lambda1(t, x, u, ux, uxx), ux))*F(t)*u^2+(diff(Lambda1(t, x, u, ux, uxx), u))*F(t)*u^3+uxx*(diff(Lambda1(t, x, u, ux, uxx), uxx))*F(t)*u^2+Lambda1(t, x, u, ux, uxx)*F(t)*u^2)/u^2, B(t) = 0], [])

(4)

The caseplot option gives a pictorial view of the splitting into cases

casesplit(det_eqs, [Lambda1, {A, B, F}], caseplot)

`========= Pivots Legend =========`

 

p1 = B(t)

 

p2 = A(t)

 

 

`casesplit/ans`([diff(Lambda1(t, x, u, ux, uxx), t) = Lambda1(t, x, u, ux, uxx)*F(t), diff(Lambda1(t, x, u, ux, uxx), x) = 0, diff(Lambda1(t, x, u, ux, uxx), u) = 0, diff(Lambda1(t, x, u, ux, uxx), ux) = 0, diff(Lambda1(t, x, u, ux, uxx), uxx) = 0], [A(t) <> 0, B(t) <> 0]), `casesplit/ans`([diff(diff(Lambda1(t, x, u, ux, uxx), x), x) = (diff(Lambda1(t, x, u, ux, uxx), t)-Lambda1(t, x, u, ux, uxx)*F(t))/B(t), diff(Lambda1(t, x, u, ux, uxx), u) = 0, diff(Lambda1(t, x, u, ux, uxx), ux) = 0, diff(Lambda1(t, x, u, ux, uxx), uxx) = 0, A(t) = 0], [B(t) <> 0]), `casesplit/ans`([diff(diff(Lambda1(t, x, u, ux, uxx), uxx), x) = -(diff(diff(Lambda1(t, x, u, ux, uxx), ux), uxx))*uxx-(diff(diff(Lambda1(t, x, u, ux, uxx), u), uxx))*ux+diff(Lambda1(t, x, u, ux, uxx), ux), diff(diff(Lambda1(t, x, u, ux, uxx), uxx), uxx) = 0, diff(Lambda1(t, x, u, ux, uxx), t) = ((diff(Lambda1(t, x, u, ux, uxx), uxx))*A(t)*u^n*n^2*ux^3+(diff(Lambda1(t, x, u, ux, uxx), ux))*A(t)*u^n*n*ux^2*u+3*uxx*(diff(Lambda1(t, x, u, ux, uxx), uxx))*A(t)*u^n*n*ux*u-(diff(Lambda1(t, x, u, ux, uxx), uxx))*A(t)*u^n*n*ux^3-(diff(Lambda1(t, x, u, ux, uxx), x))*A(t)*u^n*u^2+ux*(diff(Lambda1(t, x, u, ux, uxx), ux))*F(t)*u^2+(diff(Lambda1(t, x, u, ux, uxx), u))*F(t)*u^3+uxx*(diff(Lambda1(t, x, u, ux, uxx), uxx))*F(t)*u^2+Lambda1(t, x, u, ux, uxx)*F(t)*u^2)/u^2, B(t) = 0], [])

(5)

From the pivot information you see the problem split into three cases depending on whether A or B are equal to 0, and when both are different from zero only the first case (equivalent to all of A, B and F being arbitrary). By the way, if this is the determining system of a PDE problem you may be interested in giving a look at the help page for PDEtools:-DEtermininingPDE  and all the related symmetry commands.

 

NULL


 

Download question_for_rif_(reviewed).mw

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

@nm 

Your comments are valuable; it would be helpful however if you could please

  • Transform your reply into a post.
  • Be more specific regarding 3) and 4); itemize the three things you think are more important than anything else for each of them, be clear enough for people to understand, unambiguously, what you are talking about. Giving an example for each of your points always help.

Then, people may or not agree with you, as usual, that is natural, and Maplesoft may or may not have other plans, that is also natural, but people are listening, and chances are that your opinions (yours and others that may add material to your post) are taken into account, entirely or to some point.

Regarding the Heun functions, the original topic of this question, I agree with you nm when you say "given the small [amount of] resources ... I would prefer Maplesoft put its important resources on things that can impact many more users".

For example, this year is one with a heavy dedication to the integral transforms (the inttrans package) in connection with further developments on the exact solutions of PDE & Boundary Conditions, where these transforms are a key part of the strategies. The integral transforms numerical evaluation, differentiation rules, and several fixes and improvements (all that included some versions ago in the Physics Updates for Maple 2019 - and there is more coming) have the potential for significantly bumping up the utility of these valuable functions.

The Heun functions, by the way, are implemented - I wrote the Maple implementation many years ago, and I think it is a thorough implementation. True, their existing numerical evaluation routines can be improved at this point, and the Lame and spheroidal wave functions are not implemented. I know all that. Nobody forgot. What is happening is that other things pop up year after year that appear to me more relevant and of more impact than enhancinthe existing (and in my opinion already sophisticated) numerical evaluation routines of Heun functions, or implementing Lame. I realize others may not agree with me, and that is also natural.

And about that comment "... esoteric parts of the physics package", it looks to me highly subjective - despite the way the comment is written as if it were an indisputable truth. My opinion is that nothing currently found in the Physics package is esoteric. We all need to be respectful of others opinions. And that is all that I'll say in this thread about the original question.

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

The command for applying a change of variables (transformation) to an algebraic expression (differential or not) is PDEtools:-dchange

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

The convention explained in dsolve's help page is that the integration constants introduced by dsolve are of the form _Cn with n an integer. If you change that by something else, odetest has no way to know what is the integration constant that dsolve introduced. That information is relevant to test implicit solutions, as the one you show in your question. As explained in an answer to another of your questions, the technique is simple: solve for the integration constant introduced by dsolve (_C1, identified by odetest because of the _Cn convention) then differentiate with respect to the independent variable (in your example that is x) and you will get 0 modulo the ODE.

In summary: no bug here, and if you want the code to work as indicated in the help page, you cannot change its conventions. Alternatively, you change the conventions, and then test this result manually, not using odetest. The technique is simple, explained in the previous paragraph.

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft.


 

From the version of Physics you are using I assume you are using Maple 2018?

 

I'm unable to reproduce the problem in Maple 2019, this is what I get:

 

Physics:-Version()

`The "Physics Updates" version in the MapleCloud is 419 and is the same as the version installed in this computer, created 2019, August 24, 16:37 hours, found in the directory /Users/ecterrab/maple/toolbox/2019/Physics Updates/lib/`

(1)

with(Physics)

Setup(coordinates = {X = [t, x, y, z]}, dimension = 4, metric = {(1, 1) = 1, (2, 2) = -1, (3, 3) = -1, (4, 4) = -1}, signature = `+---`, mathematicalnotation = true)

`Systems of spacetime coordinates are:`*{X = (t, x, y, z)}

 

_______________________________________________________

 

[coordinatesystems = {X}, dimension = 4, mathematicalnotation = true, metric = {(1, 1) = 1, (2, 2) = -1, (3, 3) = -1, (4, 4) = -1}, signature = `+ - - -`]

(2)

Define(H[mu, nu] = Matrix(4, {(1, 1) = 1+h, (1, 2) = h, (2, 2) = -1+h, (3, 3) = -1, (4, 4) = -1}, shape = symmetric))

`Defined objects with tensor properties`

 

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

(3)

H[]

H[mu, nu] = Matrix(%id = 18446744078474560566)

(4)

"LinearAlgebra:-Determinant(rhs(?))"

-1

(5)

H[determinant]

-1

(6)

Note that in Maple 2019 you can also indicate the indices to make clear what determinant are you computing:

H[`~mu`, nu, determinant]

1

(7)

And that is Maple 2019.

Regarding previous versions of Maple, unfortunately I cannot help you with that, but in case this information is of use for you, from reading the code in Maple 2018 I can see it is computing the determinant of H[mu, `~nu`]:

"g_[~mu,~nu] H[nu,rho]"

Physics:-g_[`~mu`, `~nu`]*H[nu, rho]

(8)

Simplify(Physics[g_][`~mu`, `~nu`]*H[nu, rho])

H[rho, `~mu`]

(9)

TensorArray(H[rho, `~mu`])

Matrix(%id = 18446744078374452990)

(10)

"LinearAlgebra:-Determinant(?)"

1

(11)

That is, in Maple 2018 you are getting "det(H) = det(H[nu]^(mu))=det(g[]^(mu,nu)) det(H[nu,rho])."


 

Download It_works_fine_in_2019..mw


Edgardo S. Cheb-Terrab
Physics, Differential Equations andMathematicalFunctions, Maplesoft

First 23 24 25 26 27 28 29 Last Page 25 of 59