See ?collect, it states:

A function may be specified using the optional argument func. It is applied to the coefficients of the collected result. Often simplify or factor will be used.

See ?collect, it states:

A function may be specified using the optional argument func. It is applied to the coefficients of the collected result. Often simplify or factor will be used.

With the settings of your document, you can collect on the derivatives of p and then q by:

collect(ExpandedEqn5, [diff(p(x, t), x), diff(q(y, t), y)], factor);

At first sight, the output does not look very different to your "Manual Equation 7", but the latter does not have e.g. any u0, as it occurs in ExpandedEqn5. You should check it.

With the settings of your document, you can collect on the derivatives of p and then q by:

collect(ExpandedEqn5, [diff(p(x, t), x), diff(q(y, t), y)], factor);

At first sight, the output does not look very different to your "Manual Equation 7", but the latter does not have e.g. any u0, as it occurs in ExpandedEqn5. You should check it.

See e.g. this paper by Helmer Aslaksen. E.g. so far as I have checked, Maple seems passing the posed tests.

See e.g. this paper by Helmer Aslaksen. E.g. so far as I have checked, Maple seems passing the posed tests.

Simplifications like in the OP's request appear quite frequently. So, some additions as you describe would be most useful.

Simplifications like in the OP's request appear quite frequently. So, some additions as you describe would be most useful.

Interesting. Sadly, this routine Groebner:-SubstituteRootOfs is also undocumented.

Interesting. Sadly, this routine Groebner:-SubstituteRootOfs is also undocumented.

Really, I am not sure to understand much of what you are saying. Probably because my English is not good enough.

I disagree with that principal as you've stated it applying to Maple (as it now stands).

I have not found here or elsewhere an explanation of what may be that you disagree with.

About op, I think that you are saying, in other words, exactly the same as me. When you begin using type checking, to distinguish factors in a product, like a numeric constant, a function call, a matrix or whatever, you are moving from a purely syntactic specification like the operand in the position two, to a more semantic specification. Among many practical advantages, this is session independendent on the order of factors.

Those two internal routines are sadly undocumented. I find that they may be very useful. Perhaps, `simplify/getkernels` is somewhat related to the command kernels in Axiom. From its documentation:

The operator kernels returns a list of the kernels in an object of
type Expression.

Conceptually, an object of type Expression can be thought of a quotient of multivariate polynomials, where the ``variables'' are kernels. The arguments of the kernels are again expressions and so the structure recurses.

That Maple and its documentation often blurs conceptual distinctions is quite true, and this is the source of a lot of confusion for users.

Finally, I read:

what's the point of rigid adherence to a lofty ideal?

"Pragmatism. Is that all you have have to offer?" - Guildenstern

and I cannot realize whether you accuse me of idealism or pragmatism. May be because I have never heard of this man Guildenstern.

Really, I am not sure to understand much of what you are saying. Probably because my English is not good enough.

I disagree with that principal as you've stated it applying to Maple (as it now stands).

I have not found here or elsewhere an explanation of what may be that you disagree with.

About op, I think that you are saying, in other words, exactly the same as me. When you begin using type checking, to distinguish factors in a product, like a numeric constant, a function call, a matrix or whatever, you are moving from a purely syntactic specification like the operand in the position two, to a more semantic specification. Among many practical advantages, this is session independendent on the order of factors.

Those two internal routines are sadly undocumented. I find that they may be very useful. Perhaps, `simplify/getkernels` is somewhat related to the command kernels in Axiom. From its documentation:

The operator kernels returns a list of the kernels in an object of
type Expression.

Conceptually, an object of type Expression can be thought of a quotient of multivariate polynomials, where the ``variables'' are kernels. The arguments of the kernels are again expressions and so the structure recurses.

That Maple and its documentation often blurs conceptual distinctions is quite true, and this is the source of a lot of confusion for users.

Finally, I read:

what's the point of rigid adherence to a lofty ideal?

"Pragmatism. Is that all you have have to offer?" - Guildenstern

and I cannot realize whether you accuse me of idealism or pragmatism. May be because I have never heard of this man Guildenstern.

Yes, my guess is that it is calculating the sum for finite upper limit N:

sum(1/(n^4+n^2+n),n=1..N);


  /   -----
  |    \       /            2   13              \
  |     )      |-4/31 _alpha  - -- + 6/31 _alpha| Psi(N + 1 - _alpha)
  |    /       \                31              /
  |   -----
  \_alpha = %1

        \                /   -----
        |                |    \
        | + Psi(N + 1) - |     )
        |                |    /
        |                |   -----
        /                \_alpha = %1

                                                          \
        /            2   13              \                |
        |-4/31 _alpha  - -- + 6/31 _alpha| Psi(1 - _alpha)| + gamma
        \                31              /                |
                                                          |
                                                          /

                 3
  %1 := RootOf(_Z  + _Z + 1)

and then takes the limit N->infinity.

The problem seems then that it is not properly checked that the coefficient of the leading term in ln(N), which has the form 1+ Sum(...), is zero, as the sum is -1:

series(%,N=infinity,1);
eval(indets(%,And(specfunc(anything,Sum),satisfies(u->has(u,ln))))
[],ln=1);
(simplify@allvalues)(%);


  /   -----                                            \
  |    \       /            2   13              \      |
  |     )      |-4/31 _alpha  - -- + 6/31 _alpha| ln(N)| + gamma
  |    /       \                31              /      |
  |   -----                                            |
  \_alpha = %1                                         /

                   /   -----
                   |    \
         + ln(N) - |     )
                   |    /
                   |   -----
                   \_alpha = %1

                                                          \
        /            2   13              \                |
        |-4/31 _alpha  - -- + 6/31 _alpha| Psi(1 - _alpha)| + O(1/N)
        \                31              /                |
                                                          |
                                                          /

                 3
  %1 := RootOf(_Z  + _Z + 1)

               -----
                \       /            2   13              \
                 )      |-4/31 _alpha  - -- + 6/31 _alpha|
                /       \                31              /
               -----
            _alpha = %1

                                       3
                        %1 := RootOf(_Z  + _Z + 1)


                                  -1

For instance:

with(Units:-Standard):
use Unit=:-Unit, m=:-m, kg=:-kg,s=:-s,`+`=:-`+` in 
isolate(4*Unit(m)=3*Unit(m)+p/(1000*Unit(kg/m^3)*9.86*
Unit(m*s^(-2))), p);
convert(combine(rhs(%), 'units'), 'units', bar);
end use;

                             9860.000000
                         p = ----------- [m]
                               [ 2  2]
                               [m  s ]
                               [-----]
                               [ kg  ]


                         0.09860000000 [bar]

For instance:

with(Units:-Standard):
use Unit=:-Unit, m=:-m, kg=:-kg,s=:-s,`+`=:-`+` in 
isolate(4*Unit(m)=3*Unit(m)+p/(1000*Unit(kg/m^3)*9.86*
Unit(m*s^(-2))), p);
convert(combine(rhs(%), 'units'), 'units', bar);
end use;

                             9860.000000
                         p = ----------- [m]
                               [ 2  2]
                               [m  s ]
                               [-----]
                               [ kg  ]


                         0.09860000000 [bar]