I suppose that there are several ways to get the plot, depending on which coordinate systems you'd rather use.

Download 3dplotfun.mw

The ImageTools:-Preview command uses a 3D plot and puts the image data on a flat plane and shows it oriented head-on, so that it looks like a flat 2D image.

The ImageTools:-Embed command embeds an image (as a GUI construct) into a so-called Task region, which as you've noticed always gets shown after the usual output portion of an Execution Group or Document Block (paragraph).

But since the ImageTools:-Preview command was devised, 2D plots got the ability to use an image with the background option. The resulting file is quite large when saved, but you might be OK with it scaled even smaller than 500 pixels wide.

Download img_bg.mw

Using only uneval-quotes (ie, single right-ticks) here is not a robust way to prevent evaluation if you need to pass the expression (or a structure containing it) around in additional command/procedure calls.

The subsequent evaluations that occur for arguments of procedure calls will strip off uneval quotes, and produce the effect you're trying to avoid.

Instead, you could use an inert representation of the expression.

Download undesired_textplot_format_ac.mw

Is this the kind of effect you're after?

[note: Here I'm starting with the problematic indexed name being present.]

(It could be tweaked/adjusted... I don't know the extent of the kinds of indexes you'd need handled, etc. There are even much simpler/shorter ways, if you only want to handle names indexed by posint, etc.)

Download Evaluation_of_elliptic_integrals_ac.mw

If you just need to handle this one single indexed name, then here is an easier substitution, ie. directly constructed:

Of course, if you only needed a single substitution for varphi[0] then you might as well use,

    varphi[0] = varphi__0

which is of course easier still(!) and which you already know to work OK. I wrote you the earlier code so that the approach might be used for more complicated subscripted expressions or situations (for which a mere double-underscore could not suffice), programmatically. I don't know your full scenario(s).

Is this not fundamentally similar to your Question of Sept 2nd?

Download why_dsolve_cant_solve_ode_oct_4_2025_maple_ac.mw

I prefer the eval(..,..) way, and the thing you've actually requested is not a great approach IMO.

nb. One way to cause yourself grief is to re-order L, in which case your request can still be done, but in a different way(!) and with consequences that might be awkward for you. IMO this is a hint that it's not a good idea.

Download Using_the_constants_ac.mw

When you issue,

   Physics:-Setup(assumingusesAssume = true)

the routine `convert/diff` is replaced. And your example's simplify call tries to do,

   convert( (D@@2)(y)(Pi), diff )

which then invokes `convert/diff`.

The replaced `convert/diff` procedure calls,

    Physics:-usepdiff

and (eventually) that causes a call like,

    Physics:-`usegdiff/subD`( (D@@2)(y)(Pi) )

which at one point treats Pi as if it were a variable (non-constant name)

It looks like the snippet,
    Df::'function(name)'
might be better as,
    Df::'function(And(name,Not(constant)))'
in the following Library code,

showstat(Physics::`usegdiff/subD`,1)

`usegdiff/subD` := proc(Df)
local D0, D00, D000, f, z, z2;
   1   if Df::':-`*`' and op(1,Df) = -1 then
           ...
       elif not Df::'function(name)' or Df::'function' and nops({op(Df)})
         < nops(Df) then
           ...
       else
           ...
       end if
end proc

The following example also goes wrong,

restart:
with(Physics):

convert((D@@2)(y)(Pi), diff);
Error, (in unknown) invalid input: diff received Pi, which is not valid for its 2nd argument

Perhaps I can make a hot-edit...

[edit] Well, the following appears to work, but ONLY if the first line conditional of the routine is exactly as it is in my Maple 2024.2. So -- like most such hot-fixes -- it won't be good if the routine has been otherwise changed in that respect.

I would guess that Edgardo or Austin might well fix it in the right/safer way, as part of the Physics Updates, if they see this post or if the pronlem is reported.

Download dodgy_hot.mw

The hang (in Maple 2024 at least), seems to depend on having both 

   with(Physics):

and that,

   PDEtools:-undeclare(...):

In fact it seems related just to the 2D prettyprinting of the constructed partial derivatives within the Vx Matrix result under default extended typesetting (and that loaded environment).

(You can check that claim by suppressing the relevant output by making the problematic line end with a full colon as statement terminator. You can also lprint it.)

So, one workaround is to not make that undeclare call. 

I didn't check whether the latest Physics update add-on the Maple 2024 fixes it.

Here is a shorter example that illustrates the hang (which can be avoided with several kinds of workaround...),

Download derivativve_ex01.mw

nb. You could also get by here with just,

    collect(F2,[theta1],normal)

The normal call smartens up those negative signs in the "coefficient".

Download janh_01.mw

You could scale your image to some desired size (in pixels).

Img_Scale.mw

ps. If you create your Matrix M with the datatype=float[8] option then you could Embed/Scale that, without having to convert to `Image`.

Your result from solve is an expression sequence (ie. a sequence of two expressions).

You can't just pass that sequence straight to the simplify command, as the arguments after the first would get interpreted as incorrectly specifying options. That's why you got that error message.

Instead, you could put those two results from solve into a list, and then simplify that.

Download Q_Simplify_ac.mw

Your worksheet contains the input,

   ScrollableMathTableOutput = false

but that would do nothing as Maple input. It's not an assignment and, more importantly, there is no such programmatic option. It can't do anything relevant here.

There can be a meaningful such line, if you add it using an external text editor (preferably while the Maple GUI is not running), in the GUI's stored configuration/preferences file. That is not a file of Maple commands. It's a file of stored GUI options/preferences.

I don't know whether that would resolve your problem. But note that your worksheet did not, in and of itself, disable matrix scrolling. So you may well not have actually successfully tried that yet.
 

ps. Your worksheet attachment was last saved using Maple 2025.0. It may not fix this particular issue, but you might otherwise benefit from the Maple 2025.1 point-release update.

The relevant thing that changed in Maple's behavior is that lowercase int began to try floating-point quadrature (aka numeric integration) in the case that it detects floats in the integrand. (Previously, it did that if only the numeric range contained floats.) This happens to have exposed a weakness in a particular numeric integration method.

So now your example (with the float in the integrand) is attempting numeric rather than symbolic integration, and it goes wrong using the _d01amc method.

Note however that you can disable that computational route, for the int command here, by supplying the numeric=false option. Then you'd get successful symbolic integration here, even for this example with a float in the integrand.

You could also get successful numeric integration here by forcing some other method (or raising Digits).

I believe that covers the relevant details. You can see the commonalities below, run with Maple 2022.2 versus Maple 2024.2. It is only the first variant below which changed, which behaves like the OP's example.

Download int_deta_2022.2.mw

Download int_deta_2024.2.mw

For example,

type(y(x), And(typefunc(symbol,symbol),
               satisfies(u->nops(u)=1)));

                true

If you actually intended name instead of (either instance of) symbol then you could change accordingly.

The animate export of the solution modules returned by pdsolve,numeric is  considerately more efficient than generating frames as separate plots and thus repeatedly pushing the computation further out.

The results of separate animations can also be ripped out of each structure and then recombined so that they show together.

The following seems reasonably quick, taking about 12 seconds to do the computational work on my machine, ie. generating the 4*2*2*35=560 curves.

I've used Maple 2018, as the OP did.

Download paper2_new_efficiency_plots_2025_acc.mw