Take any odd number X greater than 1 (ie. X is 3 or higher).

Subtract 2 from it. So,

   X = 2 + (X-2)

The result, X-2, is also odd. And 2 is even.

So X = 2 + (X-2) which is the sum of an even number and an odd number.

In programming, a common easy way to generate odd numbers is to add 1 to a multiple of 2. (Similarly, a common way to generate even numbers is to take multiples of 2.) For example,

seq( 2*n, n=1..5 );

          2, 4, 6, 8, 10

seq( 2*n + 1, n=1..5 );

          3, 5, 7, 9, 11

We can use that trick to generate the following output, using the print command to show them on separate lines. (Recall, 2*n+1 is the odd number...)

Download odd_stuff.mw

Something I have done in the past is redefine userinfo.

I once redefined it so as to redirect its output to TextArea Embedded Components. But in your case perhaps it might suffice to alter it to always act as if called from the Command-Line Interface (CLI, tty), ie. plaintext output.

I may have overlooked some corner-case(s), in which case it might require a tweak or two.

Download userinfo_redef.mw

You wrote, "Is it possible to recover that _R is in fact A, that _R0 is in fact B and so on?".

But question includes the assertion that "_R is in fact A", which may not be true. If you had also executed,
   P := A;
at the top level then both P and A would be assigned with value _R. So why would _R "in fact" be A, as opposed to being P? The claim, as stated, would not be true.

Having said that, you can cobble together (dodgy) schemes to find out what assigned names might evaluated to _R.

Download ooph.mw

I am not a fan of this kind of thing, which seems quite backwards to me. I think it's far more sensible to utilize lists of equations and then evaluate formulas using such equations. (Ie, don't make assignments that get in your way.) For example,

Download form_forwards.mw

Download collect_examp.mw

You wrote, "how can i complete this answer in the final form with using common factors of Ts,Cf,Rf,Lg & L." but the meaning of that is not clear. How you do want to use common factors of Ts,Cf,Rf,Lg and L, if the numerator and denominator have already been collected with repected to powers of z?

What so you mean, precisely, by "simplify the formula"?

Do you mean that you want to eliminate instances of certain terms (and if so, which, precisely)? Or do you mean that you want a reformulation with fewer mathematical operations (+,*,-, etc). Or something else?

some_simp_examp.mw

Your attempt used x^k, so I will too.

restart;

H := x^k+x^(2*k):

degree(expand(H),x^k);

             2

There,

expand(H);

                          2
                  k   / k\ 
                 x  + \x / 

That kind of interactive layout of DrawGraph is using functionality provided by the DocumentTools:-InsertContent command to embed an interactive Plot Component into a Task Region of the worksheet.

There can only be a single Task Region for each Execution Group or Document Block. In consequence those repeated calls to InsertContent (from the same input statement) successively overwrite the same Task Region, clobbering its prior content.

This functionality restriction is shared by other commands which use InsertContent, eg,
  DocumentTools:-Tabulate
  Explore
  ImageTools:-Embed

Some such commands allow you (optionally) to force the XML content to be returned rather than embedded, in which case with a little extra effort the multiple instances of that can be stitched together and embedded together. But the DrawGraph and GraphTheory:-InteractiveLayout commands don't seem to offer that.

In the attachment below is code that modifies GraphTheory:-InteractiveLayout so that it (and DrawGraph) can optionally return (early) just the XML of the generated individual Plot Component for a single graph. That doesn't happen unless _EnvDGIReturnXML is set to true., and otherwise DrawGraph should behave as usual.

The AltDGI procedure takes a list of graphs and assembles the corresponding Plot Components into a GUI Table, which it embeds.

I used Maple 2021.2, and it's possible that matters because I'm altering some part of a stock procedure body (by position/inert-form-operand).

If this behaves like you want then let me know if you'd like a revision that handles a Matrix of graphs instead of just a list of graphs.

graph_interactive_table_ac.mw

It sounds as if you might be looking for the functionality provided by subsindets (or evalindets). Those allow you to act on all subexpressions of a particular type.

Notice the similarity between commands indets and subsindets. You could see their respective help-pages.

Here are two made-up examples, since you didn't provide one explicitly. I may have guessed wrong as you your specific goals. It'd be better if you provided actual examples.

There are often several ways to target a flavour of subexpression. (I might have used divide instead of all that member action, in the latter example. The choice between them could depend on whether you want to match exactly `a`  as a multiplicand in the exponent, or `a` as a factor.)

The first example involves exp calls, and the second involves calls to `^`.

Download subsindets_example2.mw

Download subsindets_example.mw

The evalb command is suitable for testing that two equations have the same structure (somewhat akin to being literally the same), but it is not intended for an check of mathematical/algebraic equivalence.

Many examples that arise in practice can be checked by this more suitable test,

   is( eqn1-eqn2 = 0 );

which is slightly more robust than,

   is( eqn1 = eqn2 );

Note also that you can put assumptions on that call, eg,

   is( eqn1-eqn2 = 0 ) assumming x>0, a::real, t::real;

or what have you.

There are a few very rare instance where the extra kick from,

   is( simplify(eqn1-eqn2) = 0 );

is necessary.

Is it the case that you only want assertion-checking on some of your own procedures? If so then you might temporarily turn it off during the key Library calls in your try..catch. For example,

Download AL1.mw

Or perhaps it is the case that you want assertion-checking only for enforcing the local or return types of certain procedures (ie, not the ASSERT calls)? In that case perhaps you could temporarily disable just those. For example (and, you don't need to put it all inside the try..catch).

Download AL2.mw

If you have some more complicated scenerio or usage then you really ought to adequately describe it. Your brief statement, "But I need to use kernelopts('assertlevel'=2): in my program" doesn't explain how you need to use it.

As to why that behaviour happened, consider where the assertion-check fails in your example. It happens in line 82 of Maple 2021.2's routine, SolveTools:-Transformers:-Identity:-Apply. And if coeff(dz1,sol) is +-infinity then line 83 gets that raised exception. You write as if the former assertion-failure prevents the ensuing numeric exception is some very special way. But it only prevents it because it fails first.

showstat(((SolveTools::Transformers)::Identity)::Apply,82..83);

Apply := proc(syst::SubSystem)
local SS, news, af, repeat, sys, eqns, ineqs, vars, z, ind, inds, inds1, inds2, z1,
ineqs2, ip, z3, w, i, v, sol, nopush, r2, dz1, newsystem, savesystem, pts, 
  aeqns, beqns, t, onlylin, x, r3, di, e, subsys, recsols;
       ...
  82                   ASSERT(degree(dz1,sol) = 1);
  83                   dz1 := normal(-coeff(dz1,sol,0)/coeff(dz1,sol));
       ...
end proc

There are a few fancier variations on the following idea of temporarily substituting the target term with a dummy (using algsubs, or subs, etc, as appropriate).

Download isolate_alg.mw

The approaches in other Answers (shown so far) involve more ad hoc manipulations involving key subexpressions and their location, ie. more specific to the particular form of the given example. This makes them less general-purpose -- without problem-specific (manual) assistance.

The OP has alluded to a longer, as yet unseen, example. It would be much better to provide that up front, to alleviate hit-and-miss guessing as to technique.

I cannot tell whether you want the exact results better simplified (but still in terms of exact radicals) or as floating-point approximations.

restart;

f := 9*x^3 - 7*x^2*y + 8*x*y^2 - 6*y^3 + 3*x^2 - 3*x*y + 4*y^2 - 3*x + 9*y - 7:
fx:=diff(f,x):
fy:= diff(f,y):

ctpts:= simplify(evala([solve({fx=0,fy=0},{x,y},explicit)])):

length~(ctpts);
                    [3946, 3946, 3916, 3916]

sort(evalf(ctpts));
          [{x = -0.2777746987, y = -0.6265224303}, 

            {x = -0.1196978963, y = -0.5678259685}, {

            x = 0.04295586208 - 0.2689937611 I, 

            y = 0.9924517216 - 0.1221355627 I}, {

            x = 0.04295586208 + 0.2689937611 I, 

            y = 0.9924517216 + 0.1221355627 I}]

There is a Units:-Simple package, which rebinds several commands and allows this kind of comparison to resolve. (Most of Maple doesn't otherwise know much about units.)

Download Problem_IF_ac.mw

By the way, there is no command Restart with a capital "R". The command is restart, all lowercase.

Inside main's catch clause the callstack is no longer what it was when the original exception was thrown.

You can access the procedure name, using lastexception[1]. For example,

Download try_loc.mw

If your procedures/modules are being accessed from a Library archive into which they were saved (and if the source exists so that line-number information can be used) then you may be able to access that source via lasterrorlocus and showsource. (See the Description of the Help page for topic error.)

For example, I have a file "foo.mpl" with the following plaintext Maple code in it:

A := module()  
  local B:=module()
     export foo:=proc(n)
         1/n;
     end proc;
  end module;
  export main:=proc()
    try
       B:-foo(0);
    catch:
      if lasterrorlocus<>'lasterrorlocus' then
         print(lasterrorlocus);
         showsource();
      end if; 
      print(sprintf("error happened in %a: %s",
            lastexception[1],
            StringTools:-FormatMessage(lastexception[2..-1])));
    end try;
  end proc;
end module:

I can then load that into a .mla Library archive file, and access the relevent souce upon catching an error. For example:

Download try_locb.mw

I'll note that the lastexception[1] shows as A:-main in that last example, while more usefully it shows foo in the first example. But the point of the second example is mostly about printing the source snippet with error location indicated.

If you want the result from calling komb to include indexed names then you could form then as such.

Your approach of concatenating produces names that pretty-print with subscripts but are not indexed names.

There are two kinds of name that pretty-print with subscripts:
1) indexed names like a[2,2] for which the subscripts pretty-print in upright Roman characters.
2) special names with double-underscore like say `a__2,2` for which the subscript pretty-prints in italic characters.
These two kinds of name might appear similar, except for the italic aspect and that is easy to overlook. But they are quite distinct from each other (ie. will not cancel upon subtraction).

That approach of concatenation will produce global names. If you want the result from komb to not have escaped local (indexed) names then you can pass in the base-symbol as an additional argument (instead of declaring that base-symbol as local). Below, I do this by having var be an additional parameter of the procedure komb, so that the base-symbol (eg. a) can be passed in. The effect is that the results from komb have the same kind of global name a as are in the Matrix A.

Download indexed_ac.mw