@Earl I don't doubt my computed value of DthetaZero---I can get it other ways, and it's the same as what everyone else got---but I do doubt the validity of my solution technique. The value of T that I computed was just based on round-off error. By increasing the accuracy of the computations, I can make it as large as I want. See my Answer below.

@mskalsi Take apart my command. Study what each part does. This'll be much easier to understand than frontend, and will help you understand what frontend does.

@Adam Ledger If you want to see evalf code, then you just need to specify the function name. For example, to see the code for Psi, do showstat(`evalf/Psi`). The only one that I'm aware of being kernel code is `evalf/hypergeom/kernel`. On the other hand, it seems that the evaluation of most of the special functions ultimately make a call to this one. For numeric integration see `evalf/int`.

@Adam Ledger The entire on-board documentation of is consists of six short sentences on page ?assume. It's a very old part of Maple (at least 20 years), and I don't recall there ever being an announcement that it had been updated (not that every update is announced). The validity of is is a frequent topic of debate here.

It should return FAIL in this situation (assuming that the identity is true for all complex values of the parameters under the assumptions). That's what it's supposed to return if it can't prove or disprove the algebraic truth of the statement. It might be interesting to trace the execution and figure out how it ends up returning false; and it might be overwhelming. Certainly I've seen many situations where it incorrectly returns false.

As far as I recall, a true return from is is trustworthy.

@Earl The Question that you asked is theoretically interesting for this ODE, and there is something very strange and unstable about it that's worth studying (I'll give an Answer below, eventually). However, I'm writing this Reply to cast doubt on the relevance of the ODE to the real-world situation that you describe. The ODE can be rewritten as

diff(theta(t),t$2) = sin(theta(t))*(cos(theta(t))-9.81)

Now what is this 9.81? Is it the acceleration due to gravity? So the units are m/s^2. How is it valid to subtract that from the cosine of something? There must be an implied coefficient of 1 m/s^2 in front of the cosine. So what in the real-world situation has an acceleration of 1 m/s^2?

Now look at the left side. Its units must be radians/s^2. So there's an implied coefficient of 1 radians/m in front of the sine. What does that 1 radians/m represent?

@Earl Kitonum's values for DthetaZero are well within the bounding values that you gave. Perhaps you are forgetting to divide by Pi?

@Preben Alsholm Vote up. For those who have some trouble understanding frontend (myself included), the following does kinda the same thing, but showing the steps:

thaw(map[3](coeff, subsindets[flat](eq, specfunc(diff), freeze), g(z), [4,-2]));

@Adam Ledger You said it correctly in your text, but your displayed formula is incorrect: The denominator should be s^(k-1).

@Joe Riel I think that he means simply that he wants to read the code.

Scale2 and Scale10 multiply the numbers by the appropriate power of 2 or 10, but they don't affect how the number is displayed. In the cases that you show, the number is displayed in scientifc notation because it is large. If you had used some smaller exponents, scientific notation wouldn't have been used.

@rstellian Please see my update to the Answer above. After reading your Grid-related Question, I anticipated that my original Answer probably wouldn't work for you and I upated the Answer. And, considering the size, you'll definitely want to use the .m format.

@Matt C Anderson I'm glad that you figured it out on your own: In earlier Maple, you can't include an initializer in a local declaration. It helps a lot if you include your Maple version in the Question header. I already edited it in this case.

@Earl I have some experimental and preliminary results. By treating the problem as a BVP whose upper boundary is that critical value of t (I called the upper boundary T), using theta(T) = Pi as the boundary condition, I get that T = 10.38172 is the value at which D(theta)(T) = 0. Then using this value for T, I get that DthetaZero = 1.034385*Pi, which confirms your findng.

However, if I then try to solve the problem as an IVP using this value as the initial condition for D(theta)(0), nothing special happens at t = T! The problem seems to be unstable near that value of DthetaZero. Minute changes in this value (like 1e-5) make big changes in the plots.

Please explain to me how the following plot suggests the existence of such a value of t for your proposed value of D(theta)(0)? One would expect the two curves to intersect on the horizontal axis at that t. But there's no point where they are even close to crossing on the horizontal axis. Furthermore, the plot suggests that theta(t) is a periodic function whose value will never be Pi.

sol:=
     dsolve(
          {
               4*sin(theta(t))*cos(theta(t))-9.8100*sin(theta(t)) = diff(theta(t),t$2),
               theta(0) = 2*Pi/3, D(theta)(0) = 1.03425*Pi
          },
          numeric
):

plots:-odeplot(sol, [[t,theta(t)-Pi], [t,diff(theta(t),t)]], t= 0..5);

Most of these commands for inquiring about an object have a corresponding command for altering or reconstructing objects. Usually, these don't literally alter the object, but instead create a new object.

Inquiry                                                            Construction
-----------------------------------------------------   ------------------------------------------------------
about                                                                                  assume
attributes                                                                          setattribute
indets                                                                                 subs, subsindets
ToInert                                                                              FromInert
dismantle                                                                          none
disassemble                                                                     assemble
addressof                                                                         pointto
eval                                                                                    :=, assign
op                                                                                       subsop