ecterrab

14605 Reputation

24 Badges

20 years, 98 days

MaplePrimes Activity


These are answers submitted by ecterrab

Hi guru

Copy and paste is not convenient. It is prone to errors and extra work for whoever would like to get involved with your computation. So next time could you please just use the green arrow you see when you prepare your post and attach a worksheet with your problem?

In the meantime, at the end I am posting what I could understood of the pasted lines you posted: the tensor you define is not identically zero. Regarding tensorial simplification, you could give a look at the help page of Physics:-Setup, the section on tensorsimplifier. I paste here the section of that help page for convenience. You set is as in Setup(tensorsimplifier= your_simplifier).  

  • tensorsimplifier
     Any procedure to be automatically applied when tensor components are computed (e.g. for the general relativity tensors)
    The default tensor simplifier, automatically applied when computing the components of the predefined general relativity tensors, and also of any user-defined tensor, is Physics:-TensorSimplifier, a general simplifier with
    emphasisin handling radicals. Depending on the problem, however, other kinds of simplification may be more convenient. When the tensor components involve large algebraic expressions, for speed reasons, one may also prefer to only apply a (fast) normalization - for this purpose use tensorsimplifier= normal (see normal). One can also set tensorsimplifier= none in which case no simplification is applied but for some unavoidable zero recognitions performed in a few intermediate steps (e.g. when you set a spacetime metric, to verify that its determinant is different from zero). To restore the tensor simplifier to its default value use tensorsimplifier= default or Setup(redo, tensorsimplifier).

 

And the following is what I understood, copy and pasted, of what you posted

 

First set the dimension and the coordinates

restart; with(Physics); Setup(dimension = 3, coordinates = (X = [x, y, t]), mathematicalnotation = true)

`* Partial match of  '`*coordinates*`' against keyword '`*coordinatesystems*`' `

 

`The dimension and signature of the tensor space are set to `[3, `- - +`]

 

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

 

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

 

_______________________________________________________

(1)

Now set the values of ut, ux and uy entering the metric

 

ut := Physics:-diff(u(X), t); ux := diff(u(X), x); uy := diff(u(X), y)

Physics:-diff(u(X), t)

 

Physics:-diff(u(X), x)

 

Physics:-diff(u(X), y)

(2)

Use a compact display to see things more conveniently

 

CompactDisplay(u(X))

` u`(X)*`will now be displayed as`*u

(3)

This is the line element copied from your post

ds2 := -ut^2*dx^2+ut^2*dy^2+(-ux^2-uy^2+1)*dt^2+2*ux*ut*dx*dt+2*uy*ut*dy*dt

-(diff(u(X), t))^2*dx^2+(diff(u(X), t))^2*dy^2+(-(diff(u(X), x))^2-(diff(u(X), y))^2+1)*dt^2+2*(diff(u(X), x))*(diff(u(X), t))*dx*dt+2*(diff(u(X), y))*(diff(u(X), t))*dy*dt

(4)

Is the above what you intended to enter? See if there is not a typographical mistake around ... Putting all in a single line to be executed makes difficult to spot handmade written typos.

 

Assuming there are no typos, this is the metric

Setup(metric = ds2)

[metric = {(1, 1) = -(diff(u(X), t))^2, (1, 3) = (diff(u(X), x))*(diff(u(X), t)), (2, 2) = (diff(u(X), t))^2, (2, 3) = (diff(u(X), y))*(diff(u(X), t)), (3, 3) = -(diff(u(X), x))^2-(diff(u(X), y))^2+1}]

(5)

g_[]

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

(6)

Note that in the above you have derivatives, just displayed indexed (compactly) for convenience. To see what is behind you can always input show

 

show

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

(7)

Now, in your post you use a letter d, but you do not indicate its value. Does it represent the dimension? Assuming that is the case, I set it here to 3

 

d := 3

3

(8)

The tensor your define (you can, but you don't need to indicate which indices are contravariant)

 

S[mu, nu] = (Ricci[mu, nu]-Ricci[`~alpha`, alpha]*g_[mu, nu]/(2*d-2))/(d-2)

S[mu, nu] = Physics:-Ricci[mu, nu]-(1/4)*Physics:-Ricci[`~alpha`, alpha]*Physics:-g_[mu, nu]

(9)

Is that the tensor you actually intended to define in 3 dimensions?

 

Moving forward with what you posted, define it now

Define(S[mu, nu] = Physics[Ricci][mu, nu]-(1/4)*Physics[Ricci][`~alpha`, alpha]*Physics[g_][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], S[mu, nu], Physics:-Weyl[mu, nu, alpha, beta], Physics:-d_[mu], Physics:-g_[mu, nu], Physics:-Christoffel[mu, nu, alpha], Physics:-Einstein[mu, nu], Physics:-KroneckerDelta[mu, nu], Physics:-LeviCivita[alpha, mu, nu], Physics:-SpaceTimeVector[mu](X)}

(10)

Next what would be the Cotton tensor for this metric, if everything above is correctly defined

C[mu, nu, rho] = D_[nu](S[rho, mu])-D_[rho](S[nu, mu])

C[mu, nu, rho] = Physics:-D_[nu](S[mu, rho], [X])-Physics:-D_[rho](S[mu, nu], [X])

(11)

Define(C[mu, nu, rho] = Physics[D_][nu](S[mu, rho], [X])-Physics[D_][rho](S[mu, nu], [X]))

`Defined objects with tensor properties`

 

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

(12)

We know at this point that C[nonzero] does not return the empty set, indicating there are various nonzero components, that as you say they are large in size (although that is a red-herring here, the problem is that they are not zero).

 

Get the indices of the components different from zero

map(proc (u) options operator, arrow; [lhs(u)] end proc, rhs(C[nonzero]))

{[1, 1, 2], [1, 1, 3], [1, 2, 1], [1, 2, 3], [1, 3, 1], [1, 3, 2], [2, 1, 2], [2, 1, 3], [2, 2, 1], [2, 2, 3], [2, 3, 1], [2, 3, 2], [3, 1, 2], [3, 1, 3], [3, 2, 1], [3, 2, 3], [3, 3, 1], [3, 3, 2]}

(13)

 

Sort them by length, to inspect the smaller one

map(proc (u) options operator, arrow; u = length(C[op(u)]) end proc, {[1, 1, 2], [1, 1, 3], [1, 2, 1], [1, 2, 3], [1, 3, 1], [1, 3, 2], [2, 1, 2], [2, 1, 3], [2, 2, 1], [2, 2, 3], [2, 3, 1], [2, 3, 2], [3, 1, 2], [3, 1, 3], [3, 2, 1], [3, 2, 3], [3, 3, 1], [3, 3, 2]})

sort([op(%)], proc (a, b) options operator, arrow; rhs(a) <= rhs(b) end proc)

[[1, 1, 2] = 43528, [1, 2, 1] = 43528, [2, 1, 2] = 45955, [2, 2, 1] = 45955, [3, 1, 2] = 66528, [3, 2, 1] = 66528, [2, 1, 3] = 75924, [2, 3, 1] = 75924, [1, 1, 3] = 77652, [1, 3, 1] = 77652, [2, 2, 3] = 80613, [2, 3, 2] = 80613, [1, 2, 3] = 81096, [1, 3, 2] = 81096, [3, 1, 3] = 126082, [3, 3, 1] = 126082, [3, 2, 3] = 130258, [3, 3, 2] = 130258]

(14)

 

So C[1, 1, 2] is the smallest one, of length 43528 of whatever units. Check its length after simplifying with simplify (that nowadays uses simplify/size by default)

length(simplify(C[1, 1, 2]))

13468

(15)

OK, that is readable. Check it out:

 

simplify(C[1, 1, 2])

(1/2)*(12*(diff(u(X), t))^3*((2/3)*(diff(diff(u(X), y), y))^3*(diff(u(X), y))+((diff(u(X), x))*((diff(u(X), y))^2+1/6)*(diff(diff(u(X), x), y))-(2/3)*(diff(diff(u(X), x), x))*(diff(u(X), y)))*(diff(diff(u(X), y), y))^2+((-(diff(u(X), y))^3+(1/2)*(diff(u(X), y)))*(diff(diff(u(X), x), y))+(diff(diff(u(X), x), x))*(diff(u(X), x))*((diff(u(X), y))^2+1/6))*(diff(diff(u(X), x), y))*(diff(diff(u(X), y), y))+((-2*(diff(u(X), x))*(diff(u(X), y))^2-(1/3)*(diff(u(X), x)))*(diff(diff(u(X), x), y))+(diff(diff(u(X), x), x))*(diff(u(X), y))*((diff(u(X), y))^2-1/2))*(diff(diff(u(X), x), y))^2)+(12*((diff(u(X), y))^2-1/2)^2*((diff(u(X), x))^2+(4/3)*(diff(u(X), y))^2-4/3)*(diff(diff(u(X), t), x))^2-24*((1/2)*(diff(u(X), x))*(((diff(u(X), y))^2+1/6)*(diff(u(X), t))^2+(1/3)*((diff(u(X), y))^2-1/2)^2)*(diff(diff(u(X), y), y))-(1/6)*(diff(u(X), y))*(((diff(u(X), y))^2+3/2)*(diff(u(X), t))^2+5*((diff(u(X), y))^2-1/2)*((diff(u(X), x))^2-1/2))*(diff(diff(u(X), x), y))+(diff(diff(u(X), x), x))*(diff(u(X), x))*((diff(u(X), y))^2-1/2)^2)*(diff(u(X), t))*(diff(diff(u(X), t), x))+8*(diff(u(X), t))^2*(((1/4+(3/2)*(diff(u(X), y))^2)*(diff(u(X), t))^2+(diff(u(X), y))^4+(3/4)*(diff(u(X), y))^2-1/8)*(diff(diff(u(X), y), y))^2+((5/2)*((diff(u(X), y))^2-13/10)*(diff(u(X), y))*(diff(u(X), x))*(diff(diff(u(X), x), y))+((1/4+(3/2)*(diff(u(X), y))^2)*(diff(u(X), t))^2+1/8-(1/4)*(diff(u(X), y))^2)*(diff(diff(u(X), x), x))+(diff(diff(u(X), t), t))*(1/8-(1/2)*(diff(u(X), y))^4))*(diff(diff(u(X), y), y))+((-1/2-3*(diff(u(X), y))^2)*(diff(u(X), t))^2-(5/2)*(diff(u(X), y))^4+(7/4+(3/2)*(diff(u(X), x))^2)*(diff(u(X), y))^2+(1/4)*(diff(u(X), x))^2-1/4)*(diff(diff(u(X), x), y))^2-(7/2)*(diff(u(X), y))*(diff(u(X), x))*((diff(u(X), y))^2-1/2)*(diff(diff(u(X), x), x)-(2/7)*(diff(diff(u(X), t), t)))*(diff(diff(u(X), x), y))+(diff(diff(u(X), x), x))*((diff(u(X), y))^2-1/2)^2*(diff(diff(u(X), x), x)-(1/2)*(diff(diff(u(X), t), t)))))*(diff(diff(u(X), t), y))+(-4*(diff(u(X), y))*(diff(u(X), x))*((diff(u(X), y))^2-1/2)^2*(diff(diff(u(X), t), x))-8*(diff(u(X), t))*((1/2)*(diff(u(X), y))*(((diff(u(X), y))^2+3/2)*(diff(u(X), t))^2+3*((diff(u(X), y))^2-1/2)*((diff(u(X), x))^2-(2/3)*(diff(u(X), y))^2-1/2))*(diff(diff(u(X), y), y))-(3/2)*(diff(u(X), x))*(((diff(u(X), y))^2+1/6)*(diff(u(X), t))^2+2*(diff(u(X), y))^4-(7/3)*(diff(u(X), y))^2+2/3)*(diff(diff(u(X), x), y))+(diff(u(X), y))*((diff(u(X), y))^2-1/2)*((diff(diff(u(X), x), x))*(diff(u(X), t))^2+(diff(diff(u(X), t), t))*((1/2)*(diff(u(X), y))^2-1/4))))*(diff(diff(u(X), t), y))^2-12*((diff(u(X), y))^2-1/2)^2*((diff(u(X), x))^2+(4/3)*(diff(u(X), y))^2-4/3)*(diff(diff(u(X), t), y))^3+4*(2*(diff(diff(u(X), y), y))^2*(diff(u(X), x))*(diff(u(X), y))+(-3*((diff(u(X), y))^2+1/6)*((diff(u(X), x))^2+1/2)*(diff(diff(u(X), x), y))+2*(diff(u(X), y))*(diff(u(X), x))*((diff(u(X), y))^2-1/2)*(diff(diff(u(X), x), x)-(diff(diff(u(X), t), t))))*(diff(diff(u(X), y), y))+(2*(diff(diff(u(X), x), y))*(diff(u(X), x))*(diff(u(X), y))+((diff(u(X), y))^2-1/2)*((diff(diff(u(X), x), x))*((diff(u(X), y))^2-1/2)+2*(diff(diff(u(X), t), t))*(diff(u(X), y))^2))*(diff(diff(u(X), x), y)))*(diff(u(X), t))^2*(diff(diff(u(X), t), x))+4*(diff(u(X), y))*(diff(u(X), t))^2*(diff(u(X), x))*((diff(u(X), y))^2-1/2)^2*(diff(diff(diff(diff(u(X), t), x), x), x))-4*(diff(u(X), y))*(diff(u(X), t))^2*(diff(u(X), x))*((diff(u(X), y))^2-1/2)^2*(diff(diff(diff(diff(u(X), t), x), y), y))-4*(diff(u(X), t))^3*(diff(u(X), x))*((diff(u(X), y))^2-1/2)^2*(diff(diff(diff(diff(u(X), x), x), x), y))+4*(diff(u(X), y))*(diff(u(X), t))^3*((diff(u(X), y))^2-1/2)^2*(diff(diff(diff(diff(u(X), t), t), x), x))+4*(diff(u(X), t))*((diff(u(X), y))^2-1/2)*((((diff(u(X), y))^2+1/2)*(diff(u(X), t))^2+3*((diff(u(X), y))^2-1/2)*((diff(u(X), x))^2+(5/3)*(diff(u(X), y))^2-5/3))*(diff(diff(u(X), t), y))+(diff(u(X), x))*(diff(u(X), y))*((diff(u(X), t))^2+(diff(u(X), y))^2-1/2)*(diff(diff(u(X), t), x))-((3*(diff(u(X), t))^2*(diff(u(X), y))+2*(diff(u(X), y))^3+(1/2)*(diff(u(X), y)))*(diff(diff(u(X), y), y))+(3*(diff(u(X), x))*(diff(u(X), y))^2-3*(diff(u(X), x)))*(diff(diff(u(X), x), y))+(diff(u(X), y))*((diff(diff(u(X), x), x))*(diff(u(X), t))^2+(diff(diff(u(X), t), t))*(-(diff(u(X), y))^2+1/2)))*(diff(u(X), t)))*(diff(diff(diff(u(X), t), y), y))-4*((diff(u(X), x))*(diff(u(X), y))*((diff(u(X), t))^2-(diff(u(X), y))^2+1/2)*(diff(diff(u(X), t), y))+((3*(diff(u(X), y))^2-1)*(diff(u(X), t))^2+((diff(u(X), y))^2-1/2)*((diff(u(X), x))^2+2*(diff(u(X), y))^2-2))*(diff(diff(u(X), t), x))-3*(diff(u(X), t))*(((1/3)*(diff(u(X), x))*(diff(u(X), y))^2-(1/6)*(diff(u(X), x)))*(diff(diff(u(X), y), y))+2*(diff(u(X), y))*((diff(u(X), t))^2-(1/3)*(diff(u(X), x))^2+1/6)*(diff(diff(u(X), x), y))+(diff(diff(u(X), x), x))*(diff(u(X), x))*((diff(u(X), y))^2-1/2)))*(diff(u(X), t))*((diff(u(X), y))^2-1/2)*(diff(diff(diff(u(X), t), x), y))+4*(diff(u(X), t))^3*(diff(u(X), x))*((diff(u(X), y))^2-1/2)^2*(diff(diff(diff(diff(u(X), x), y), y), y))+4*(diff(u(X), y))*(diff(u(X), t))^3*((diff(u(X), y))^2-1/2)^2*(diff(diff(diff(diff(u(X), y), y), y), y))-4*(diff(u(X), y))*(diff(u(X), t))^3*((diff(u(X), y))^2-1/2)^2*(diff(diff(diff(diff(u(X), x), x), y), y))+8*((((diff(u(X), y))^2-3/4)*(diff(u(X), t))^2-((diff(u(X), y))^2-1/2)*((diff(u(X), x))^2+(3/2)*(diff(u(X), y))^2-3/2))*(diff(diff(u(X), t), y))-(diff(u(X), y))*(diff(u(X), x))*((diff(u(X), y))^2-1/2)*(diff(diff(u(X), t), x))-(1/2)*(diff(u(X), t))*(2*((diff(u(X), t))^2-(diff(u(X), x))^2-(diff(u(X), y))^2+1/4)*(diff(u(X), y))*(diff(diff(u(X), y), y))+(diff(u(X), x))*((diff(u(X), y))^2+1)*(diff(diff(u(X), x), y))+(diff(u(X), y))*(diff(diff(u(X), t), t))*((diff(u(X), y))^2-1/2)))*(diff(u(X), t))*((diff(u(X), y))^2-1/2)*(diff(diff(diff(u(X), t), x), x))+12*((diff(u(X), x))*((diff(u(X), y))^2-1/2)*(diff(diff(u(X), t), y))-(1/3)*(2*(diff(diff(u(X), y), y))*(diff(u(X), x))*(diff(u(X), y))+(diff(diff(u(X), x), y))*((diff(u(X), y))^2-1/2))*(diff(u(X), t)))*(diff(u(X), t))^2*((diff(u(X), y))^2-1/2)*(diff(diff(diff(u(X), x), x), x))-4*(diff(u(X), t))^2*((diff(u(X), t))^2-(diff(u(X), y))^2+1)*((diff(u(X), y))^2-1/2)^2*(diff(diff(diff(diff(u(X), t), x), x), y))+4*(diff(u(X), t))^2*((diff(u(X), t))^2-(diff(u(X), y))^2+1)*((diff(u(X), y))^2-1/2)^2*(diff(diff(diff(diff(u(X), t), y), y), y))-4*((diff(u(X), x))*((diff(u(X), y))^2-1/2)*(diff(diff(u(X), t), y))+((diff(u(X), y))^3-(1/2)*(diff(u(X), y)))*(diff(diff(u(X), t), x))+2*(diff(u(X), t))*(diff(u(X), y))*((diff(u(X), y))*(diff(diff(u(X), x), y))-(diff(diff(u(X), y), y))*(diff(u(X), x))))*(diff(u(X), t))^2*((diff(u(X), y))^2-1/2)*(diff(diff(diff(u(X), t), t), x))+4*(diff(u(X), t))^2*((diff(u(X), y))^2-1/2)*(((diff(u(X), y))^3-(1/2)*(diff(u(X), y)))*(diff(diff(u(X), t), y))+(diff(u(X), x))*((diff(u(X), y))^2-1/2)*(diff(diff(u(X), t), x))+(((diff(u(X), y))^2+1/2)*(diff(diff(u(X), y), y))-2*(diff(diff(u(X), x), y))*(diff(u(X), x))*(diff(u(X), y))+(diff(diff(u(X), x), x))*((diff(u(X), y))^2-1/2))*(diff(u(X), t)))*(diff(diff(diff(u(X), t), t), y))-4*((diff(u(X), y))*((diff(u(X), t))^2+2*(diff(u(X), y))^2-1/2)*(diff(diff(u(X), t), y))+(1/2)*(diff(u(X), x))*(diff(diff(u(X), t), x))-(1/2)*(diff(u(X), t))*((-2*(diff(u(X), y))^2-3)*(diff(diff(u(X), y), y))-2*(diff(diff(u(X), x), y))*(diff(u(X), x))*(diff(u(X), y))+diff(diff(u(X), x), x)))*(diff(u(X), t))^2*((diff(u(X), y))^2-1/2)*(diff(diff(diff(u(X), y), y), y))-8*(diff(u(X), t))^2*((diff(u(X), y))^2-1/2)*(((diff(u(X), x))*(diff(u(X), y))^2-(diff(u(X), x)))*(diff(diff(u(X), t), y))+(diff(u(X), y))*(-(1/2)*(diff(u(X), x))^2-1/4)*(diff(diff(u(X), t), x))+(1/2)*(3*(diff(diff(u(X), y), y))*(diff(u(X), x))*(diff(u(X), y))+(-5*(diff(u(X), y))^2+3/2)*(diff(diff(u(X), x), y))+(diff(diff(u(X), x), x))*(diff(u(X), x))*(diff(u(X), y)))*(diff(u(X), t)))*(diff(diff(diff(u(X), x), y), y))+4*(diff(u(X), t))^2*((diff(u(X), y))^2-1/2)*((diff(u(X), y))*((diff(u(X), t))^2-(diff(u(X), x))^2+2*(diff(u(X), y))^2-1)*(diff(diff(u(X), t), y))-(diff(diff(u(X), t), x))*(diff(u(X), x))*(diff(u(X), y))^2-2*(((1/2)*(diff(u(X), y))^2-1/2)*(diff(diff(u(X), y), y))-(7/2)*(diff(diff(u(X), x), y))*(diff(u(X), x))*(diff(u(X), y))+(diff(diff(u(X), x), x))*((diff(u(X), y))^2-1/2))*(diff(u(X), t)))*(diff(diff(diff(u(X), x), x), y))-4*(diff(u(X), y))*(diff(u(X), t))^3*((diff(u(X), y))^2-1/2)^2*(diff(diff(diff(diff(u(X), t), t), y), y))+4*(diff(u(X), y))*(diff(u(X), x))*((diff(u(X), y))^2-1/2)^2*(diff(diff(u(X), t), x))^3+4*(diff(u(X), t))*((diff(u(X), y))^2-1/2)*(2*(diff(u(X), y))*((diff(u(X), t))^2-(diff(u(X), x))^2-(diff(u(X), y))^2+1/2)*(diff(diff(u(X), y), y))+(diff(u(X), x))*((diff(u(X), y))^2+1/2)*(diff(diff(u(X), x), y))+(diff(u(X), y))*(diff(diff(u(X), t), t))*((diff(u(X), y))^2-1/2))*(diff(diff(u(X), t), x))^2)/((diff(u(X), t))^3*(2*(diff(u(X), y))^2-1)^3)

(16)

It is one page, and no radicals nor special functions, this is just a differential polynomial, and clearly not zero. If you were expecting zero, I'd say there is something wrong in your formulation, not related to simplification of tensors.

``


 

Download Cotton_tensor_and_simplification.mw

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


 

Thanks for pointing at this one, nm, there was indeed a typo in new code for tackling PDE & BC, it is fixed installing the Maplesoft Physics Updates version 208 (or higher). After installing the fix you get

 

infolevel[pdsolve] := 2

 

pde := diff(u(r, theta), `$`(r, 2))+(diff(u(r, theta), r))/r+(diff(u(r, theta), `$`(theta, 2)))/r^2 = 0; bc := u(r, 0) = 0, u(r, Pi) = 0, u(0, theta) = 0, u(1, theta) = f(theta); sol := pdsolve([pde, bc], u(r, theta), HINT = boundedseries(r = 0))

diff(diff(u(r, theta), r), r)+(diff(u(r, theta), r))/r+(diff(diff(u(r, theta), theta), theta))/r^2 = 0

 

u(r, 0) = 0, u(r, Pi) = 0, u(0, theta) = 0, u(1, theta) = f(theta)

 

* trying method "_Fn" for 2nd order PDEs
   -> trying "linear_in_xt"
   -> trying "BC_equal_0"
* trying method "_Cn_cn" for 2nd order PDEs
* trying method "Wave" for 2nd order PDEs
   -> trying "Cauchy"
   -> trying "SemiInfiniteDomain"
   -> trying "WithSourceTerm"
* trying method "Heat" for 2nd order PDEs
   -> trying "SemiInfiniteDomain"
   -> trying "WithSourceTerm"
* trying method "Series" for 2nd order PDEs
   -> trying "ThreeBCsincos"
   -> trying "FourBC"

   <- trying "FourBC" successful
<- method "Series" for 2nd order PDEs successful

 

u(r, theta) = Sum(2*(Int(sin(n*theta)*f(theta), theta = 0 .. Pi))*r^n*sin(n*theta)/Pi, n = 1 .. infinity)

(1)

``


 

Download Fixed_in_version_208.mw

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

Hi

There is partial information. There are the two Mapleprimes posts, Maple 2018: Updates to Physics Differential Equations and Mathematical Functions and Tensor Product of Quantum State Spaces. There are also several answers I gave in this forum that have the word "Fixed" in the title (you can give a quick look at these clicking my name in this answer - a page with a summary of my participation in this forum will open - and there click on "Answers").

As a summary, the current version of the Maplesoft Physics updates for 2018 (version 193), actually means quite more than 193 changes posterior to the release of Maple 2018, divided into three categories:

  1. Fixes and adjustments all around, in code that is relevant to Physics, Differential Equations and Mathematical Functions.
  2. Significant developments in the computation of exact solutions for PDE & Boundary Conditions problems - some of these posted here, see for instance Solving PDEs with initial and boundary conditions: Sturm-Liouville problem with RootOf eigenvalues.
  3. Significant developments in the quantum part of Physics, mainly several improvements in the handling of Dirac's notation that allowed for the introduction of tensor products of quantum states in a much more general way, including setting disjointed Hilbert spaces using Setup, also a full implementation of coherent states, including their typesetting, a myriad of improvements in the normalization of expressions involving quantum operators, Bras and Kets (using Physics:-Normal) and in the handling of commutation rules, including those for the Pauli matrices.

Anyway the information publically available is incomplete, I didn't have the time to present the improvements in a more complete and organized manner. That typically happens in the "What's new in Physics" help page of each Maple release, whose contents summarizes the changes of the whole year and I frequently post here in Mapleprimes before the release is out.

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

casesplit_and_pdsolve_ok.mw

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

Hi Christopher,

Note first that the Maplesoft R&D Physics webpage has the Physics Updates for the previous releases Maple 2017, Maple 2016 and Maple 2015 - only the latest one for each of them. This webpage was cleaned-up removing updates for some older releases.

Not exactly what you asked but, regarding maple 2018, the first release that has updates distributed through the Maple cloud, if you 'view' the package you see the instructions to install any previous version of the Physics Updates for Maple 2018. Being that we are at version 192, that means you have an archive of 191 previous versions. This repository may remain available as such when Maple 2019 becomes the current release next year.

On the versions for Maple 2018, additionally, not mentioned in that 'view' of the package's update, a few updates ago I introduced the following: Physics:-Version, that tells you the version on the cloud and in your computer so that you can see whether you have the latest version, now also installs any version. For example, if you have the latest update, input Physics:-Version(123) and you will have version 123 installed (and remember that in version 123 Physics:-Version does not have this capability of installing the package).

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

Hi,

First of all, assuming you are using Maple 2018, be sure you have installed the free upgrade to Maple 2018.2 and also have the latest Maplesoft Physics Updates (version 192 or higher) installed in order to reproduce what is shown below.

 

with(Physics)

 

The following is what you entered first, and indicates that A and C act on the same space, then B and C act on the same space, but A and B do not act on the same space - hence A and B commute, but not A and C or B and C. All bases are discrete with dimensions Na, Nb and Na Nb

 

Setup(hilbertspaces = {{A, C}, {B, C}}, quantumbasisdimension = {A = 1 .. Na, B = 1 .. Nb, C = 1 .. Na*Nb}, quantumdiscretebasis = {A, B, C})

[disjointedspaces = {{A, C}, {B, C}}, quantumbasisdimension = {A = 1 .. Na, B = 1 .. Nb, C = 1 .. Na*Nb}, quantumdiscretebasis = {A, B, C}]

 

Regarding your first question: indicating the dimensions of A and B does not determine the dimension of C, so indeed you need to tell the system what is C's dimension, if you are going to use that (it mainly serves the purpose of computing projectors and their use), not otherwise.

 

About your intention of creating a bracket rule such that `&otimes;`(`&otimes;`(Bra(A, i), Bra(B, j)), Ket(C, t)) = X[i, j](t) you cannot define a bracket rule of this sort (two Bras times one Ket, that is not really a Bracket)  but you can define single Kets that belong to C and that have two quantum numbers, ie representing a tensor product, and you can assign dimensions to each of the quantum numbers as you wish. Quoting from the help page for Setup,

 

"It is valid to state different dimensions for different quantum numbers of Kets of a single basis. For that purpose, if the label of the basis is A, you can set the dimension of each quantum number entering quantumbasisdimension = {A[1] = N, A[2] = M}, where N and M are positive integers, algebraic expressions representing them, or ranges of the form a .. b. This dimension of a quantum basis is used to construct projectors when you call the Projector  command."

 

For example, add another quantum space label, say F, and set the dimensions accordingly, noting that your dependence on t is a continuous dependence (in your post I see it as a function, not as an index)

 

Setup(redo, hilbertspaces = {{A, C, F}, {B, C, F}}, quantumbasisdimension = {A = 1 .. Na, B = 1 .. Nb, C[1] = Na, C[2] = Nb}, quantumcontinuousbasis = F)

[disjointedspaces = {{A, C, F}, {B, C, F}}, quantumbasisdimension = {A = 1 .. Na, B = 1 .. Nb, C[1] = Na, C[2] = Nb}, quantumcontinuousbasis = {F}]

So your bases look like this

`&Iopf;__A` := Projector(Ket(A, i)); `&Iopf;__B` := Projector(Ket(B, i)); `&Iopf;__C` := Projector(Ket(C, i, j)); `&Iopf;__F` := Projector(Ket(F, t))

Sum(Physics:-`*`(Physics:-Ket(A, i), Physics:-Bra(A, i)), i = 1 .. Na)

Sum(Physics:-`*`(Physics:-Ket(B, i), Physics:-Bra(B, i)), i = 1 .. Nb)

Sum(Sum(Physics:-`*`(Physics:-Ket(C, i, j), Physics:-Bra(C, i, j)), i = 0 .. Na-1), j = 0 .. Nb-1)

Int(Physics:-`*`(Physics:-Ket(F, t), Physics:-Bra(F, t)), t = -infinity .. infinity)

For instance,

Bra(A, n).`&Iopf;__A`

Physics:-Bra(A, n)

Bra(F, tau).`&Iopf;__F`

Physics:-Bra(F, tau)

From you post I understand that your bracket rule would then be

%Bracket(Bra(C, i, j), Ket(F, t)) = X[i, j](t)

%Bracket(Physics:-Bra(C, i, j), Physics:-Ket(F, t)) = X[i, j](t)

Setup(%Bracket(Physics[Bra](C, i, j), Physics[Ket](F, t)) = X[i, j](t))

[bracketrules = {%Bracket(%Bra(C, i, j), %Ket(F, t)) = X[i, j](t)}]

Now you have

Bra(C, a, b).Ket(F, tau)

X[a, b](tau)

And with that,

Bra(C, a, b).`&Iopf;__F`

Int(X[a, b](t)*Physics:-Bra(F, t), t = -infinity .. infinity)

 

This answers the question on how to do what I understood you were trying to do. Note next that you can set some rules that have to do with C states being tensor products of A and B states, For example, if

 

Ket(C, j, k) = Ket(A, j)*Ket(B, k)

Physics:-Ket(C, j, k) = Physics:-`*`(Physics:-Ket(A, j), Physics:-Ket(B, k))

Then the bracket rules would be

Bra(A, i).%, Bra(B, i).%

Physics:-Bracket(Physics:-Bra(A, i), Physics:-Ket(C, j, k)) = Physics:-KroneckerDelta[i, j]*Physics:-Ket(B, k), Physics:-Bracket(Physics:-Bra(B, i), Physics:-Ket(C, j, k)) = Physics:-KroneckerDelta[i, k]*Physics:-Ket(A, j)

Set these rules

Setup(%)

[bracketrules = {%Bracket(%Bra(A, i), %Ket(C, j, k)) = Physics:-KroneckerDelta[i, j]*Physics:-Ket(B, k), %Bracket(%Bra(B, i), %Ket(C, j, k)) = Physics:-KroneckerDelta[i, k]*Physics:-Ket(A, j), %Bracket(%Bra(C, i, j), %Ket(F, t)) = X[i, j](t)}]

Now you have

Bra(A, m)*Bra(B, n).Ket(C, r, s)

Physics:-KroneckerDelta[n, s]*Physics:-KroneckerDelta[m, r]

And hence

Bra(A, n).`&Iopf;__C`

Sum(Physics:-`*`(Physics:-Ket(B, j), Physics:-Bra(C, n, j)), j = 0 .. Nb-1)

Bra(B, n).`&Iopf;__C`

Sum(Physics:-`*`(Physics:-Ket(A, i), Physics:-Bra(C, i, n)), i = 0 .. Na-1)

If you tell how would A and B Bras contract with F Kets that can also be implemented as a bracket rule, after which you can use them and Simplify will take them into account when simplifying expressions. Without these rules the system doesn't know how to compute these other ones

Bra(A, n).`&Iopf;__F`

Int(Physics:-Bracket(Physics:-Bra(A, n), Physics:-Ket(F, t))*Physics:-Bra(F, t), t = -infinity .. infinity)

Bra(B, n).`&Iopf;__F`

Int(Physics:-Bracket(Physics:-Bra(B, n), Physics:-Ket(F, t))*Physics:-Bra(F, t), t = -infinity .. infinity)

 

I'm not sure I interpreted your question correctly. If the above does not answer your question I'd need more details on the problem you are trying to formulate in order to suggest you something else.

NULL


 

Download algebra_rules_(reviewed).mw

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


 

Hi

This problem, that can be considered as one with discontinuous boundary conditions (see my previous reply pointing at their classical incompatibility) is now solved.

PDE := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0

BC := u(0, y) = 0, u(Pi, y) = sinh(Pi)*cos(y), u(x, 0) = sin(x), u(x, Pi) = -sinh(x)

pdsolve([PDE, BC])

u(x, y) = ((exp(2*Pi)-1)*(Sum((-1)^n*n*(exp(2*Pi)-1)*exp(n*(Pi-y)-Pi)*sin(n*x)*(exp(2*n*y)-1)/(Pi*(n^2+1)*(exp(2*Pi*n)-1)), n = 1 .. infinity))+(exp(2*Pi)-1)*(Sum(2*sin(n*y)*exp(n*(Pi-x))*n*sinh(Pi)*((-1)^n+1)*(exp(2*n*x)-1)/(Pi*(exp(2*Pi*n)-1)*(n^2-1)), n = 2 .. infinity))+sin(x)*(-exp(y)+exp(-y+2*Pi)))/(exp(2*Pi)-1)

(1)

The improvement is available to everybody within the Maplesoft Physics Updates version 190 or higher. (Note that since its version 188 the Physics Updates requires Maple 2018.2, the free upgrade for those having Maple 2018.)

 

Actually, there is a large number of improvements in exact solutions to PDE & BC problems. I mentioned one in a previous post on Sturm-Liouville problems with RootOf eigenvalues. I will try to summarize next week the new types of problems that can now be solved in maple 2018.2 and beyond.


 

Download weak_solution_-_problem_with_discontinuous_boundary_conditions.mw

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

Hi; John is correct: besides the most relevant tensors of General Relativity, the idea in Physics is to provide flexible ways for you to define, using Physics :-Define (it is worth looking at its help page), any tensor. That is, in any dimension, even a tensor in spacetime, in only space, or in the tetrad system of references (for that purpose pass the corresponding indices in the definition sent to Define). That, of course, allows you for defining not just the Cotton tensor but any tensor that makes sense in your formulation or intermediate computations. 

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

Hi

This problem was one in MultiSet, not in DifferentialGeometry. Anyway, it is fixed now, and the fix uploaded for everybody, available within the Maplesoft Physics Updates version 172 or higher. With the Updates installed, you get


 

restart

with(DifferentialGeometry); with(Tensor); with(LieAlgebras); with(GroupActions); with(Library)

DGsetup([x, y], M)

g := evalDG((`&t`(dx, dx)+`&t`(dy, dy))/y^2)

_DG([["tensor", M, [["cov_bas", "cov_bas"], []]], [[[1, 1], 1/y^2], [[2, 2], 1/y^2]]])

(1)

kv := KillingVectors(g)

[_DG([["vector", M, []], [[[1], (1/2)*x^2-(1/2)*y^2], [[2], y*x]]]), _DG([["vector", M, []], [[[1], x], [[2], y]]]), _DG([["vector", M, []], [[[1], 1]]])]

(2)

L := LieAlgebraData(kv, Poincare)

_DG([["LieAlgebra", Poincare, [3]], [[[1, 2, 1], -1], [[1, 3, 2], -1], [[2, 3, 3], -1]]])

(3)

DGsetup(L); MultiplicationTable("LieTable")

Query(Poincare, "Semisimple")

true

(4)

CSA := CartanSubalgebra(Poincare)

[_DG([["vector", Poincare, []], [[[2], 1]]])]

(5)

RSD := RootSpaceDecomposition(CSA)

table( [( [-1] ) = _DG([["vector", Poincare, []], [[[3], 1]]]), ( [1] ) = _DG([["vector", Poincare, []], [[[1], 1]]]) ] )

(6)

NULL


 

Download error_(reviewed).mw

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

Hi,

Your coordinates are [x, y, z, t], and the line element of your metric is 4*dx*dt-dy^2-dz^2+4*u*(dt^2)). Look closer ... the line elements does not contain the coordinates. Therefore all the derivatives of the metric with respect to the coordinates are equal to zero, so all the Christoffel symbols (proportional to those derivatives) too, and with it, all of the Ricci, Riemman and Weyl tensors are equal to 0.

In the UPDATE I read that u is a function of the variables (not specified ... I imagine you meant to say coordinates x,y,z,t?). If that is the case, definitely this is the problem. To answer that question, give it a try, enter change u by u(x,y,z,t) in your input, press enter, and you will see that all the general relativity tensors, starting with Christoffel, now have nonzero components.

And that resolves the issue. Tip: use CompactDisplay for u(X), and you can type u(X), no need to type u(x,y,z,t).

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


 

Hi

There exists no solution for this problem. The boundary conditions are incompatible. Your PDE and BC are

PDE := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0

BC := u(0, y) = 0, u(Pi, y) = sinh(Pi)*cos(y), u(x, 0) = sin(x), u(x, Pi) = -sinh(x)


Always check the compatibility of the BC before proceeding, evaluating them at the different evaluation points you see in them, in this case x = 0, x = Pi, y = 0, y = Pi, which does not exhaust the compatibility test but frequently helps detecting an issue. So evaluate BC, for instance, at y = 0, x = Pi

eval([BC], [y = 0, x = Pi])

[u(0, 0) = 0, u(Pi, 0) = sinh(Pi), u(Pi, 0) = 0, u(Pi, Pi) = -sinh(Pi)]

(1)

These two

[u(0, 0) = 0, u(Pi, 0) = sinh(Pi), u(Pi, 0) = 0, u(Pi, Pi) = -sinh(Pi)][2 .. 3]

[u(Pi, 0) = sinh(Pi), u(Pi, 0) = 0]

(2)

cannot be both true:

evalf([u(Pi, 0) = sinh(Pi), u(Pi, 0) = 0])

[u(Pi, 0) = 11.54873936, u(Pi, 0) = 0.]

(3)

So I'd say the answer someone posted before given by Mathematica (now I see it deleted?) can never be correct - in that there exists no solution for this problem, and the refusal of Maple's pdsolve/numeric to return something is correct, and Maple's pdsolve exact solutions returning NULL is also correct.

 


 

Download incompatible_boundary_conditions.mw

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


 

with(Physics); Setup(mathematicalnotation = true)

In your input, where you wrote

metric = f(dx1^2+dx2^2+dx3^2+dx4^2)

 

you are saying that the metric is an arbitrary function of the sum of the squares of the differentials of the coordinates. That is not a diagonal metric as I understand you intended to say. It is also not a line element quadratic in the differential of the coordinates (because it an arbitrary function f of that), and it is also not a tensorial expression with two free indices. That is what the error message is telling you, but for one typo at the end: it should say 'none', instead of repeating [%d_(x1), %d_(x2), %d_(x3), %d_(x4)].

 

So I'd suggest first for you to update your library with the Maplesoft Physics Updates where this typo in the error message is already corrected, and for your input you will see:

Setup(Coordinatesystem = (X = [x1, x2, x3, x4]), metric = f(dx1^2+dx2^2+dx3^2+dx4^2))

`* Partial match of  '`*Coordinatesystem*`' against keyword '`*coordinatesystems*`' `

 

`Default differentiation variables for d_, D_ and dAlembertian are:`*{X = (x1, x2, x3, x4)}

 

`Systems of spacetime Coordinates are:`*{X = (x1, x2, x3, x4)}

 

Error, (in Physics:-NormalizeMetricInfo) expected definition of a metric as an expression quadratic in [%d_(x1), %d_(x2), %d_(x3), %d_(x4)] or a tensorial algebraic expression with two free indices; received one that is not quadratic in [%d_(x1), %d_(x2), %d_(x3), %d_(x4)] and with free indices: none

 

Now the message makes sense. A comment to the side: the default way of setting coordinates automatically uses x1, x2, x3, x4 when the label is X ;so, you can but you do not need to indicate each coordinate as you did, Setup(coordinates = X, metric = ds^2) is sufficient.

 

On to your question: how do you enter a diagonal metric where the elements in the diagonal are arbitrary?

 

Just write the line element. As we know, it is an expression quadratic in the differentials of the coordinates, which in the context of Setup can be entered as the letter d followed by the coordinate (for example x1) with no spaces in between, as you do with paper and pencil

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

f[1](X)*dx1^2+f[2](X)*dx2^2+f[3](X)*dx3^2+f[4](X)*dx4^2

(1)

Use CompactDisplay to avoid redundant display of functionality (not necessary, but for me it is always desired)

CompactDisplay(f[1](X)*dx1^2+f[2](X)*dx2^2+f[3](X)*dx3^2+f[4](X)*dx4^2)

` f`(X)*`will now be displayed as`*f

(2)

Now set the metric

Setup(metric = ds^2)

[metric = {(1, 1) = f[1](X), (2, 2) = f[2](X), (3, 3) = f[3](X), (4, 4) = f[4](X)}]

(3)

That answers your question.

 

 

What follows are some comments about syntax and functionality, things that I find useul to know or take into account.

 

When setting the metric, check it out, to be sure you got what you intended to get; these are the covariant and contravariant components

g_[]

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

(4)

"g_[~]"

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

(5)

The functionality of the f__j functions is not displayed, but it is there. To see it for the previous expression use show

show

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

(6)

That is the usefulness of CompactDisplay. You can also set the compact display ON and OFF around the worksheet as you see it convenient by just entering ON and OFF; see the help page CompactDisplay .

 

Next, in (1) I entered the line element writing it explicitly. Here is a version of it writing less that works the same way

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

f[1](X)*Physics:-d_(x1)^2+f[2](X)*Physics:-d_(x2)^2+f[3](X)*Physics:-d_(x3)^2+f[4](X)*Physics:-d_(x4)^2

(7)

In the above the d(X[j]) is an full computational representation of the differential (see the help page for d_ )

 

You  can also indicate the metric as a symmetric matrix. In your example, that could be

piecewise(mu = nu, h[mu](X), 0)

piecewise(mu = nu, h[mu](X), 0)

(8)

I am using a different letter, h only to make evident whether the new definition is kicking in

g_[mu, nu] = Matrix(4, proc (mu, nu) options operator, arrow; piecewise(mu = nu, h[mu](X), 0) end proc)

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

(9)

"Setup(?)"

[metric = {(1, 1) = h[1](X), (2, 2) = h[2](X), (3, 3) = h[3](X), (4, 4) = h[4](X)}]

(10)

g_[]

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

(11)

Finally, the coordinates x1, x2, x3, x4 although ok, look a bit cumbersome to me. I prefer to use the literal subscripted

Coordinates(X = [x__1, x__2, x__3, x__4])

`Default differentiation variables for d_, D_ and dAlembertian are:`*{X = (x__1, x__2, x__3, x__4)}

 

`Systems of spacetime Coordinates are:`*{X = (x__1, x__2, x__3, x__4)}

 

{X}

(12)

or even just Cartesian coordinates

Coordinates(X = cartesian)

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

 

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

 

{X}

(13)

and as you see you can define the coordinates using Setup or using Coordinates. Likewise, you can define the metric using Setup or using Define.

 

If you redefine the coordinates in the middle of the computation as I did above, you need to redefine the metric, that it is still a function of the previous coordinates

g_[]

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

(14)

To redefine the metric just re-enter the lines (8), (9), (10).

NULL


 

Download Diagonal_metric.mw

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

Joe already answered regarding the problem in your DifferentialGeometry input. Although a great package, it suffers of this issue where the input syntax is not entirely natural, or with the natural meaning in context, eg. in the context of evalDG, dr dr could be dr &t dr, after you have said that [r, theta] are coordinates in DGsetup - this frequently bites people.

An alternative to these subtleties is to use the Physics package, more modern and free of those issues. This is the same computation with it:
 

with(Physics)

Setup(dimension = 2, coordinates = (X = [r, theta]), metric = r^2*`d&theta;`^2+dr^2, quiet)

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

(1)

Christoffel[nonzero]

Physics:-Christoffel[alpha, mu, nu] = {(1, 2, 2) = -r, (2, 1, 2) = r, (2, 2, 1) = r}

(2)

seq(Christoffel[j, mu, nu, matrix], j = [1, 2])

Physics:-Christoffel[1, mu, nu] = Matrix(%id = 18446744078349940366), Physics:-Christoffel[2, mu, nu] = Matrix(%id = 18446744078349941446)

(3)

 

The main feature in the above being that everything you write is in natural physics notation (basically, as you would write it with paper and pencil).

Download 2D_spacetime_in_polar_coordinates.mw

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

You are correct vv. This is already fixed and the fix uploaded for everybody within the Maplesoft Physics Updates (version 146 or higher).

(On the way I implemented copy & paste of intats, something pending that never worked. And being at that, also copy and paste of ODESolStruc, PDESolStruc and `casesplit/ans`, none of these worked before, they are used in the output of dsolve, pdsolve, casesplit and for exact solutions to PDE & Boundary Conditions when the eigenvalues have RootOf form - see recent post.)

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

Hi, check the help page for PDEtools:-PolynomialSolutions, it is the command you are looking for. There are also some related commands mentioned in that page. Another command with impressive functionality, that I believe could be of use in your case is PDEtools:-InvariantSolutions. That command allows you to specify that you want to use only polynomial infinitesimals - the simpest case would be linear - and also to specify their degree, all in all resulting in a computational process that is not expensive and leading to all kinds of concrete and simple solutions (when they exist), like polynomial ones.

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

First 29 30 31 32 33 34 35 Last Page 31 of 60