Hi Mac Dude

PhysicsType is a package of specialized types distributed within the Physics,Library  and explained in that help page. Recalling, that I am working with the updated Physics library, downloadable from  "Maple Physics: Research & Development",

the PhysicsVectors type you asked is included in the PhysicsType package:

Hi Mac Dude

PhysicsType is a package of specialized types distributed within the Physics,Library  and explained in that help page. Recalling that I am working with the updated Physics library, downloadable from  "Maple Physics: Research & Development".

The PhysicsVectors type you asked is included in the PhysicsType package.
 

The transformation you posted:

Rewrite your transformation with x, y and  on the left-hand sides

Change variables

In the above you already see the answer to your question, so isolating

I just saw your post ... answering two years after is probably irrelevant, but anyway: things have changed since 2011. Using the Physics library up-to-date (you can download it from the the "Maple Physics: Research & Development" updates page), current version:

Set some commutation rules to see how it works

The first commutator has a constant in the rhs: in these cases you can now index the operators A and B or give functionality to them as desired and the result will always be the right-hand side of type constant  :

In the second commutator, the right-hand side is not constant, so this one works as in previous releases:

The third commutator has functionality in the left-hand and right-hand sides, the same one, so in this case you have more flexibility

You can also transform f into a procedure

The Physics update is developed assuming the Maple 17 library, but the last approach, with  in the right-hand side of the commutator followed by defining f as a procedure, will also work in previous Maples.

Hi

I only saw your post now .. anyway:

From the formula you posted I assume you are working in a 3D Euclidean space; set things accordingly and define a tensor A

Your formula is (using the abbreviation ep_ for LeviCivita)

To obtain the right-hand side you show, you can use Simplify

In the above, the repeated index n corresponds to your index i, and the dAlembertian corresonds to your . To understand how this result is formed you can selectively simplify first the product of LeviCivita tensors using the dot operator, as in

Note first the use of the up-to-date Physics library (dowloadable from the Maple Physics: Research & Development updates page):

Now, Psi is a mathematical function (check ?Psi) so, although possible, it's better to not use that name to avoid potential ambiguous meaning. I all what follows below I use psi instead.

Your annihilation operators: as mentioned by Carl, you can delay evaluation of these procedures am, ap, nn until i, j and  are all nonnegative integers. For that purpose, add the line you see below after "local k"

Insert the same line for ap that generats your creation operators, and also for nn, the occupation number at state

IMPORTANT: the internal routines know that if A is a quantum operator (and all annihilation and creation operators generated by Annihilation and Creation are automatically quantum operators), a sum of A objects is also a quantum operator. However, because these am, ap and nn defined above are returning unevaluated when any of  are not numbers, the internal routines have no way to know these am, ap, nn programs are quantum operators, restricting the use of these three procedures when  are not numbers. You resolve this by directly passing this piece of information, as in

And now you can operate with am, ap and nn as quantum operators even when  are not numbers. For instance, you can do sum, or Sum - but then you cannot us add for the summation where  f is a summation limit and is not defined. So for instance use sum for the addition from 1 to f, and use add for the rest

As said, because you indicated that nn is a quantum operator, the system now knows that this sum 'N ' is also a quantum operator:

You can now apply N to a Ket even not saying the value of f, although of course the operation cannot be performed to the end until you tell that value (note also that `.` automatically distributes over the sum)

Evaluate for instance at  f = 2

This result is correct and I understand the answer to your question on how to do this, which is pretty close to what you have done in fact.

For curiosity, let's anyway verify this result. You need to check that

a) N is an operator that indeed returns the total number of particles.

b) This total number of particles of the state represented by the ket K is indeed 5.

Start with b) just because it is a 1 step thing: the total number of particles of a Ket is equal to the sum of its occupation numbers.  So, discarding the label of K (first operand), the occupation numbers are

and you can add them via

So b) checks OK.

For a) you need to show that the summation NK indeed adds all these occupation numbers of K. For that, get the summand

Get the nn operands in this summand

Check now the quantum number over which each of these Inn operators act. For that purpose note Library:-GetFingerprint (a section describing it is found within the help page for the Physics, Library )

The quantum number returned by  is then the third element returned by GetFingerprint above. So get all the products  being added and get the occupation number each of them is returning

In summary: the sum NK is returning a sum of each of the 12 occupation numbers and, indeed, twelve is the number of "occupation numbers" of K, so this sum is adding all the twelve occupation numbers:

and because the sum of these occupation numbers is also the total number of particles of the state represented by the Ket then NK is indeed returning the total number of particles.

Hi,

In what follows you have the symbolic exact solution to the ODE system you posted, matching the ics you posted, and without specializing any of the symbolic parameters a1, a2, a3, b1, b2 or b3.

Your ODE system:

Strategy:

1) rewrite this system as an ODE system for three unknowns C1, C2, C3, plus an expression giving O1 in terms of them

2) compute the exact solution for C1, C2, C3 in terms of three arbitrary constants

3) adjust the three arbitrary constants to match your initial conditions ics for C1, C2 and C3

4) substitute this solution for C1, C2, C3 matching your initial conditions into the expression giving O1 in terms of them.

While performing these steps, do not display expressions that are too large.

Step 1), one of the equations you present as ics is actually a constraint between the functions:

The actual system to be solved then involves 4 DEs and one constraint

Rewrite now this as "one constraint and three DEs involving only C1, C2 and C3" (see casesplit )

In the above you see a system entirely equivalent to yours, but now involving 3 DEs instead of four. Remove then the constraint (that has O1 for lhs) to work just with the ODE system, and assign it to

Step 2) Compute now the exact solution to this system; note that dsolve will solve and simplify the solution - most of the time is spent in simplifying

As mentioned by others, these solutions involve large algebraic expressions

You can transform these into slightly shorter expressions using simplify/size

Before proceeding further, let's verify this solution

Step 3) Now you need to adjust the integration constants to match your ics for C1, C2 and C3

 are:

So: evaluate  at  and substitute in  in order to have a system for the Cn

Check lengths

The symbols in these ics are

Solve now for the Cn and simplify the size; check lengths and left-hand sides

At this point we have solved the problem:  is the general solution in terms of three arbitrary constants Cn and  gives the value of these three arbitrary constants that match your  for C1, C2 and C3. So evaluate  at  to get the answer you are looking for; check lengths

Step 4) To get the answer to O1, substitute these solutions for C1, C2 and C3 in the

In addition, the following three would help in compacting the expressions, but they are rather large and simplifying takes time - I am keeping the lines here in comments in case you want to try them