The following replaces all names of the form `x` followed by a positive integer.

It handles your set of names assigned to t, and it doesn't matter how many such names there are.

It also allows you to make such replacements within expressions more generally.

Download subsind_ex.mw

If you know that there are just that particular 100 such names then you could do it more tersely like, say,

   subs('x||i=y||i'$i=1..100,t);
or,
   subs('x||i=y||i'$i=1..100,expr);

Or, using it more than once,

   S:='x||i=y||i'$i=1..100:
   subs(S,t);
   subs(S,expr);

Don't make the assignment to C if you want it to remain as an unassigned name.

It looks as if you wanted to use only an equation involving C, not an assignment.

Download isol.mw

You wrote of expressing them in terms of each other.

I'd be interested to know whether your wider investigations might have any use for expressing them all ("compactly") in terms of additional temporary variables.

For example,

Download rearrangingterms_q2.mw

I made those additional temporary substitutions as assignments. But they could also be formulated as a sequence of equations (for substitution into each other, up the chain).

You could optionally (telescopically) collapse a portion of that sequence of subsitutions, from the top down.  Eg, you could retain only the knowledge in a5 & a6, or what have you.

Also, such a scheme can also support a wider set of operations (expression forms) than just mere polynomials. For polynomials there are various techniques (basis, triangularization, etc) to produce such a substituion chain. But there are also mechanisms for doing it for a wider (non-polynomial) class.

The five you cited can be found pretty quickly, and exactly, as follows.

restart;

nsd := 16*a*b*c*(9 + a^2 + b^2 + c^2)*(b*c + a*(b + c) + 3*(a + b + c))
       - (3 + a + b + c)^2*(a*b + 3*c)*(3*b + a*c)*(3*a + b*c):

nsdac := eval(nsd,{c=a}):
rawac := solve({nsdac,a>0,b>0},[a,b]):
solac := map(s->{s[],c=eval(a,s)},rawac);

    solac := [{a = 1, b = 1, c = 1}, {a = 3, b = 3, c = 3}, 
              {a = 3, b = 9, c = 3}]

eval~(nsd, solac);

                 [0, 0, 0]

The remaining pair can be had immediately by noticing/proving the symmetry, or by re-running with each of the corresponding substitutions c=b and b=a.

Proving that there are no other solutions seems difficult or time-consuming. Let's see...

You mistakenly placed the call to polygonplot inside the call to draw.

Download jamet_ex.mw

Are you trying to get an effect something like one of these?

Download somecoll.mw

If you actually wanted to "collect" that term within a modification of the original expression assigned to aa, then you could follow that up with either of,

  subs(reveq,collect(algsubs(eq,expand(aa)),PP,simplify));

or,

  subs(reveq,collect(algsubs(eq,temp1),PP,simplify))
   + simplify(aa-temp1);

This can be done in your Maple 18 simply by,

   convert([sol],rational)[]

You have an expression sequence assigned to sol, not a list or a set. By wrapping it in square backets you get [sol] as a list. This allows you to pass them all together, without any being misinterpreted as options to the command.

By prepending [] to the call you can turn the result from a list back into a mere expression sequence (if you so want...).

problem1_ac.mw

This issue is covered quite clearly on the Help page for topic if, in the section Nested Selection Statements. See also the Help page for topic printlevel.

I'll mention that the inner conditional code does indeed get executed. The effects you're seeing only relate to the display of the inner results.

These effects also cover such nesting involving do-loops.

A good place to start looking for details, when you have an issue with a particular command, would be the Help page for that command.

Download LambW_simpl1.mw

You misspelled Distance as distance.

Download distance_ex.mw

Is this the kind of effect you're after?

Download plot_1_ac.mw

There are several variants on this methodology. I just gave one. (You don't necessarily need to construct revr. Instead you could refer to the reversed entries in the rhs of the tickmarks equation by indexing with a formula. And so on...)

I used Reverse after loading ListTools. Again, there are several other ways. Too many to mention. But the basic idea is to force the tickmarks.

ps. I gave one of the variants that is "simpler" because it relies on the special kind of r values you have. In fact for this special kind of r-values it could be done even more simply.

It's also possible to do it for more general r values (irregularly spaced, say), with a more exotic mapping. Let us know if you need that,

The idea behind that particular calling sequence is that you can efficiently re-use the created rtable (Array, Vector, etc). The relevant calls to Sample will populate the passed rtable, in-place.

This is more efficient than having Sample create new rtable containers each time, especially if you are going to do this many times.

Download Sample_and_rtables.mw

You were failing to provide any knowledge of f to the attempts at computing c5,c6,c7.

I resolved that issue by calling dsolve on a coupled system -- once, for each set of parameter values. (Yes, you could dsolve for f alone, decoupled, and then reuse that result in the later dsolve calls for theta. But efficiency seems not a major concern in what you've attempted here. I'm just trying to keep it simpler for you to do -- it's just a judgement call, on what might be best for you.)

In at least one place you also had f instead of f(x). That's the kind of mistake you can make when you allow declare to make things visually unclear.

You had duplicates of most of the parameter information. I've cleaned all that up and made it more organized, which might help you keep track of which is what. Having twice as many solutions as necessary floating around, with numbering mismatches, seems a recipe for confusion.

Note that M only appears in eq1, and is multiplied by sin(alpha).
Hence M has no effect when sin(alpha) is taken as 0, which is the case for all your given parameter sets.

So I rearranged the parameter sets according to the value for cos(omega). And I added a legend. We can see that for your parameter sets it is the value of cos(omega) that is the key difference.

Download IP-TEMP_ac.mw

You might wish to also try varying the sin(alpha) parameter, and then see the related effects of varying M.

The keen observer might notice that there is a lot in common amongst all those dsolve and odeplot calls. There is so much that could be generalized. But I've deliberately chosen not to wrap it all up in a single resuable procedure that could produce all the results.

There are a lot of members on this forum who attempt very similar problems. Several struggle with numeric dsolve & odeplot, and perhaps even with the DE concepts. I think that some members can learn more by doing each step themselves rather than use an abstracted do-it-all solution procedure.

The following was done using Maple 2023.0.

Where you see R subscripted by x it was entered as the keystrokes R__x with two underscores, and similarly for y and z subscripts.

Download sincos_ts.mw

The code in red above could be tucked away out of sight in a worksheet's Startup Code, accessible via the main menubar's Edit menu.

ps. I could mention that the first three lines of red code, which assigns to (s,c) and the print-extensions, could be replaced by alias, as Edgardo mentioned. My longstanding preference is not to use alias, which is why I didn't mention it earlier. The rest of the red code, the Typesetting calls, accomplish the rest of the aspects you mentioned or showed.

That lengthy result you obtained appears to have a "hidden" division-by-zero in it. I suspect that you might not be able to just simplify that away, given that form.

But the option method=trager to the int command seems to help here.

Download int_tr_ex.mw

I don't know all the details of the control flow by which available methods are attempted by default for indefinite integration. I'll submit this example as a bug report.