ecterrab

14540 Reputation

24 Badges

20 years, 22 days

MaplePrimes Activity


These are answers submitted by ecterrab

Hi nm

Mariusz Iwaniuk is correct, and the help page of pdsolve tells the same: this command returns one solution, as general as possible. As usual, the design is debatable; I designed this a long time ago having in mind that, for PDEs, the concept of a particular solution is, at the same time, useful, and there are just infinitely many ones, making little sense of the idea of "returning all particular solutions" available.

Frequently, more relevant than "many particular solutions" it is to know what kind of particular solution you are getting. E..g, whether it is a so-called complete solution, relevant in the Hamilton-Jacobi formulation of classical mechanics, or separation of variables, relevant in electrodynamics and quantum mechanics, or symmetry solutions with what kind of symmetry, the information being relevant depending on the context.

Anyway, Mathematica is not stronger than Maple to return particular solutions either. In the two PDE examples you brought, the solutions are traveling wave solutions, as you can see using infolevel[pdsolve] := 2. So for the two examples you posted, try PDEtools:-TWSolutions(pde) and you will see the two and the several many solutions you posted. 

More relevant: you can also try your two pde with the optional argument function = sech, or function = JacobiSN, or function = .... You will be surprised how many particular solutions of this kind exist - none of them returned by Mathematica, which has none of these options. You can as well try the option 'extended' - you will get not just more solutions but also more general. Example (22) of the help page is a beautiful one. All these things are explained in the help page ?PDEtools:-TWSolutions.

By the way, because for PDE particular solutions it is relevant to know what kind of solution you are getting, another  advantage in Maple is the infolevel mechanism used by pdsolve to convey that information.

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

 

Hi Rouben

In the documentation, first paragraph, it says "[Its purpose] is to permit a simple, compact display of functions and derivatives on the screen".

In the third paragraph it says "This scheme also displays all differentiation variables as indices, and permits declaring a prime variable so that, for functions of one variable, derivatives with respect to that declared prime variable are displayed with a prime."

So the behaviour you are showing is intended, according to the design and its documentation. The Examples section of that help page also illustrate with examples what is said in these two sentences: derivatives are displayed indexed, and the functionality of declared functions is omitted.

Now, I imagine you read this help page. What is not clear in these two sentences or in the examples that motivated your post?

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

 

Hi nm, Tom,

The 'method = ...' is new and only for PDE & BC problems. Implementing it for PDE with no BCs is possible, but a whole different project. So taking 'method = ...' for PDE only is not valid. Thus the error message you see: you are passing a wrong extra argument. As for your suggestion of ignoring the extra argument, I think that would be misleading: people (would be my case) would then think that 'method = ...' works, that they just passed a not good method. Regarding documentation, it is not documented in Maple 2018.2 because as said 'method = ...' is new. Attached is a first version of what would be an updated help page mentioning it.

pdsolveBoundaryConditions.mw

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

Hi nm,

D[1]*u(1, theta, t) = 0 is just the product of D[1] times u(1, theta, t), equated to 0. That is not, at all, a third notation to enter a derivative. 

From the point of view of an initial/boundary condition, factors that don't depend on the variables of the problem (would be D[1] in that product) are automatically discarded so entering D[1]*u(1, theta, t) = 0 is the same as entering u(1, theta, t) = 0. That is all about your actual question.

I realize you took this equation for the post I made (example number 8); indeed, I made a typo there, partially hidden by the mathematical notation, and pdsolve solved this problem with u(1, theta, t) = 0. I will look later this week to the same problem but with D[1](u)(1, theta, t) = 0 as a boundary condition, using the derivative, not the function itself.

NOTE: Dec/23, I corrected the typo in the original post, the two valid different problems, with and without the typo, are now solved.

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

Hi nm,

I have installed version 263 in my copy of Maple 2018.2, so apparently the problem is not in your computer or in the Update but somewhere else ... Anyway I tried now the following:

  1. Input PackageTools:-Uninstall("Physics Updates") - say yes to everything towards uninstalling the package
  2. Close Maple
  3. Open Maple, click the MapleCloud icon on the Maple toolbar, then Packages, find Physics Updates and install it.

And in that way I re-installed the package normally, it worked fine again. I hope this helps you. By the way upcomming version 264 (later today) has further developments in PDE & BC.

Best

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

 

Hi

Check the PDEtools commands ToJet, FromJet, diff_table. The first two allow you to input your equations in jet notation and have the software rewriting it for you in the notation used by dsolve and pdsolve, then re-expressing back the answer in jet notation if you want. The diff_table command is different, and in some sense more convenient: it allows you to input things using jet notation and have them automatically coming out in the standard function notation used by dsolve and pdsolve to solve differential equations.

If you also use PDEtools:-declare you will see on the screen everything in jet notation, even when what you are looking at is expressed using the standard function notation.  

By the way, all the Lie symmetry commands of the PDEtools and DifferentialAlgebra packages work internally using jet notation.

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

 J F Ogilvie 

You have a very peculiar way of expressing your points of view ... I will disregard that for this one time and try to help you with the contents.

The Maplesoft Physics Updates work fine with TTY cmaple, and also with the Standard Interface distributed with Maple, maintained by Maplesoft, and also with the not-maintained-anymore-since-years, so-called "Classic," ancient interface, the one you say you want to use, that was developed in the 1990s, provided that Maple itself runs properly in that interface.

IMPORTANT: the Maplesoft Physics Updates require you to have installed the latest Maple version (2018.2.1). If that is not the case Maple will warn you and point to the webpage from where you can download a version of the Updates for your version of Maple.

Now, that there are other things in that ancient "Classic" interface not working the way you expect, as you are saying, would seem expected for me, for the reasons mentioned in the previous paragraph. That is also not related to physics or my person: as you pointed out in your post, Maple 2018.2 is already having trouble to run in that not-maintained ancient interface. Interfaces developed more than 20 years ago typically don't work 100% or at all in nowadays operative systems, a situation standard in software. You could still argue that "Classic" is included in the distribution of Maple (not for Macintosh since many years). Yes, but you know it is not maintained anymore and that is not the interface Maplesoft indicates to use with the Maple system, since years.

Then if for you, using the ancient "Classic" interface, is relevant for any reason, working with the last Maple that runs fine for your purposes in that interface would be the way to go, I suppose. Otherwise, I suggest you to start using the Standard interface, distributed with the Maple system, intended for its use, and well maintained by Maplesoft.

Maybe of help for you in that transition: open the preferences of the Standard interface, the one distributed with Maple and maintained by the company, and choose to use worksheet instead of document mode. If you prefer, also choose to use 1D math input (so-called Maple Notation). These two things already make the Standard interface distributed with Maple nowadays work primarily as that ancient "Classic" one, as said not recommended and not maintained anymore for many years. If the remaining differences are still important for you then, unfortunately, I have nothing else to suggest you.

Hi John

This difference in behaviour between `.` and Physics:-`.`, for A^n (n an integer) when A is the computational object Array of dimension 1 or 2 is not present anymore after installing the Maplesoft Physics Updates version 240 or higher. Arrays (for which type(A, Array) returns true) are now kept unchanged, not rewritten as the object Matrix.

In that sense, this is now adjusted for good, or fixed, depending on whether you see this as an undesired incompatibility (my take on this nowadays) or a bug.

As for the origin of this problem: the same way you  - somehow - found "natural" (say?) that for a 2x2 table of numbers the object A^(-1) would satisfy A . A^(-1) = Identity (number 1 in the diagonal, the rest equal to 0), I also found that natural 15+ years ago when coding this.

But if A is represented using the computational object called Array, then A . A^(-1) is not equal to the Identity but to a square table of numbers all of them equal to 1. The first time I saw this I thought it was a bug. As Pascal4QM says, for the computational object Array, `.` is performing elementwise multiplication. As a physicist, I thought this behaviour was undesired, prone to mistakes. Whether you represent the square table of numbers using the computational object called Array or the one called Matrix (and both are displayed the same way on the screen - as a square table of numbers), in mathematics, the dot product of square tables of objects is called matrix multiplication, not elementwise multiplication. So, in Physics:-`.` day one I also coded a convert(A, Matrix) when A was the object called Array before proceeding with the "multiplication" of square tables of numbers.

And nobody ever complained about this or found it unnatural for 15+ years, but today (this post by you).

Looking at this design issue today, it also seems to me relevant to keep the differences in behaviour - sometimes unavoidable - to a very^2 strict minimum. So the adjustment mentioned at the beginning. 

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


 

Hi nm,

 

The problem Maple had with this example was not in whether the boundary conditions are of Neumann or Dirichlet kind nor in whether they are nonhomogeneous.

 

The problem was in the presence, in the PDE, of an unknown function as Q(x, t), depending on both x and t. You realize that can make computing the solution particularly difficult, specially if you have to match that solution to boundary conditions also of the most general form, depending on arbitrary functions, here A(t) and B(t).

 

On the other hand, I agree with you, the code should not try to do impossible things, e.g.: separation of variables in the presence of an unknown function of both variables likeQ(x, t). Having adjusted the code now (this adjustment is already within the distributed Maplesoft Physics updates version 223 or higher), the computational flow moves forward, the problem is within the scope of the methods implemented.

 

So this is the problem you posted:

 

pde := diff(u(x, t), t) = k*(diff(u(x, t), x, x))+Q(x, t)
ic := u(x, 0) = f(x)
bc := eval(diff(u(x, t), x), {x = 0}) = A(t), eval(diff(u(x, t), x), {x = 1}) = B(t)

 

And this is its solution:

 

pdsolve({bc, ic, pde})

u(x, t) = Int((1/2)*(Int((x^2-2*x)*(diff(A(tau), tau))-x^2*(diff(B(tau), tau))-2*k*A(tau)+2*k*B(tau)+2*Q(x, tau), x = 0 .. 1))+Sum(cos(n*Pi*x)*exp(-k*Pi^2*n^2*(t-tau))*(Int(-2*((-(1/2)*x^2+x)*(diff(A(tau), tau))+(1/2)*x^2*(diff(B(tau), tau))+k*A(tau)-k*B(tau)-Q(x, tau))*cos(n*Pi*x), x = 0 .. 1)), n = 1 .. infinity), tau = 0 .. t)+Sum(cos(n*Pi*x)*exp(-k*Pi^2*n^2*t)*(Int(cos(n*Pi*tau)*((tau^2-2*tau)*A(0)-tau^2*B(0)+2*f(tau)), tau = 0 .. 1)), n = 1 .. infinity)+(1/2)*(Int((tau^2-2*tau)*A(0)-tau^2*B(0)+2*f(tau), tau = 0 .. 1))+(1/2)*(-x^2+2*x)*A(t)+(1/2)*x^2*B(t)

(1)

 

To follow the computational flow, enter infolevel[pdsolve] := 2 before the call to pdsolve above.

 

Download solution_-_not_hanging.mw


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


 

Hi nm,

 

Good catch. This problem is present in 2018.2 without the Physics Updates. A fix is already uploaded for everybody within the Maplesoft Physics Updates version 201 (or higher).

 

Physics:-Version()[2]

`2018, November 26, 8:56 hours, version in the MapleCloud: 221, version installed in this computer: 221`

(1)

 

pde := diff(w(x, t), t)+3*t*(diff(w(x, t), x)) = w(x, t)
ic := w(x, 0) = f(x)

 

sol := pdsolve([pde, ic])

w(x, t) = f(-(3/2)*t^2+x)*exp(t)

(2)

pdetest(sol, [pde, ic])

[0, 0]

(3)

Note by the way this problem can also be solved using Fourier transforms

pdsolve([pde, ic], method = Fourier)

w(x, t) = exp(t)*invfourier(fourier(f(x), x, s)*exp(-((3/2)*I)*t^2*s), s, x)

(4)

convert(w(x, t) = exp(t)*invfourier(fourier(f(x), x, s)*exp(-((3/2)*I)*t^2*s), s, x), Int)

w(x, t) = (1/2)*exp(t)*(Int((Int(f(x)*exp(-I*x*s), x = -infinity .. infinity))*exp(-((3/2)*I)*t^2*s+I*s*x), s = -infinity .. infinity))/Pi

(5)

 

Download Fixed_in_Physics_Updates_version_201.mw

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


 

Not necessary, but useful to avoid typos and better readability, enter your PDE using PDEtools:-declare  and PDEtools:-diff_table ,

PDEtools:-declare(v(u))

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

      (1)

V := PDEtools:-diff_table(v(u))

 

Input now the ODE directly using jet notation

u*V[]*V[u, u]+u*V[u]^2-2*V[]*V[u] = 0

u*v(u)*(diff(diff(v(u), u), u))+u*(diff(v(u), u))^2-2*v(u)*(diff(v(u), u)) = 0

(2)

Now on your question: How do you check the dimension of the underlying symmetry group, or whether it is finite or infinite? You do that by:

1. 

compute the determining system for the Lie symmetries of the problem;

2. 

check the dimension of the solution of that determining system.

 

For the first step, you can use DEtools[gensys]  or PDEtools:-DeterminingPDE

PDEtools:-DeterminingPDE(u*v(u)*(diff(diff(v(u), u), u))+u*(diff(v(u), u))^2-2*v(u)*(diff(v(u), u)) = 0)

{diff(diff(diff(_eta[v](u, v), u), v), v) = (-(diff(diff(_eta[v](u, v), u), v))*v+diff(_eta[v](u, v), u))/v^2, diff(diff(diff(_eta[v](u, v), v), v), v) = (3*(diff(_eta[v](u, v), v))*v-3*_eta[v](u, v))/v^3, diff(diff(_eta[v](u, v), u), u) = 2*(diff(_eta[v](u, v), u))/u, diff(diff(_xi[u](u, v), u), u) = (2*(diff(diff(_eta[v](u, v), u), v))*u^2*v+2*u^2*(diff(_eta[v](u, v), u))-2*v*(u*(diff(_xi[u](u, v), u))-_xi[u](u, v)))/(u^2*v), diff(diff(_xi[u](u, v), u), v) = (1/2)*((diff(diff(_eta[v](u, v), v), v))*u*v^2+(diff(_eta[v](u, v), v))*u*v-4*(diff(_xi[u](u, v), v))*v^2-_eta[v](u, v)*u)/(u*v^2), diff(diff(_xi[u](u, v), v), v) = (diff(_xi[u](u, v), v))/v}

(3)

For the second step, use DEtools[initialdata]

T := DEtools[initialdata]({diff(diff(diff(_eta[v](u, v), u), v), v) = (-(diff(diff(_eta[v](u, v), u), v))*v+diff(_eta[v](u, v), u))/v^2, diff(diff(diff(_eta[v](u, v), v), v), v) = (3*(diff(_eta[v](u, v), v))*v-3*_eta[v](u, v))/v^3, diff(diff(_eta[v](u, v), u), u) = 2*(diff(_eta[v](u, v), u))/u, diff(diff(_xi[u](u, v), u), u) = (2*(diff(diff(_eta[v](u, v), u), v))*u^2*v+2*u^2*(diff(_eta[v](u, v), u))-2*v*(u*(diff(_xi[u](u, v), u))-_xi[u](u, v)))/(u^2*v), diff(diff(_xi[u](u, v), u), v) = (1/2)*((diff(diff(_eta[v](u, v), v), v))*u*v^2+(diff(_eta[v](u, v), v))*u*v-4*(diff(_xi[u](u, v), v))*v^2-_eta[v](u, v)*u)/(u*v^2), diff(diff(_xi[u](u, v), v), v) = (diff(_xi[u](u, v), v))/v})

 

No underlying infinite dimensional symmetry group

T[Infinite]

      []

 

The underlying finite symmetry group is  8-dimensional

T[Finite]

[_eta[v](u[0], v[0]) = _C1, (D[1](_eta[v]))(u[0], v[0]) = _C2, (D[2](_eta[v]))(u[0], v[0]) = _C3, (D[1, 2](_eta[v]))(u[0], v[0]) = _C4, (D[2, 2](_eta[v]))(u[0], v[0]) = _C5, _xi[u](u[0], v[0]) = _C6, (D[1](_xi[u]))(u[0], v[0]) = _C7, (D[2](_xi[u]))(u[0], v[0]) = _C8]

(5)

nops(%)

      8

           


 

Download Find_dimension_of_underlying_symmetry_group.mw

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

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

First 28 29 30 31 32 33 34 Last Page 30 of 59