@rlopez The simplify command attains the desired result directly in my Maple 2019.{0,1,2},  and Maple 2020.1, without the assumption that rho__m is real.

@Kitonum The expand command does it directly in Maple 2018.2 (and also in Maple 2020.1, as I showed in my Answer).

The evalc command assumes the unknown rho__m is real, but that is not a necessary condition.

@9009134 You could do it by writing your definition for it here, in words.

You need to tell us what you want.

@9009134 You've already identifed why the L31+L32+L33 for the new equation are not equal to its LHS. The difference consists of the mixed terms.

In order to "extract" them you should first specify a unique manner in which they may be grouped.

@Zeineb In your old Maple 12, does this run?

restart:
t0:=0; x0:=<1,2>;
f:= (t, v) -> <t*v[1], v[2]> ;
x[0]:= t -> x0;
for n to 5 do
x[n] := unapply( x0 + map(int, f(tau, x[n-1](tau)), tau=t0..t),  t);
print(x[n]= x[n](t));
od:

@ceight1 Where did you get the function (x,y)->y and exp(x) from, in your attempt? How do you think that those relate to this example's differential equation? [Perhaps your instructor or your textbook used a previous example like that. But this example's differential equation involves a different right-hand side formula. It is not the differential equation y'(x)=y(x) here.]

Download HELP_CODE_ac.mw

Don't post this same problem more than once.

If you have followup queries of details for the example (in addition to the syntax issue with writing x*y(x) as xy) then put them in a Comment/Reply here.

Here's that other way (substitution into a template procedure, and nicer error message).

Download functionB_rev2.mw

@Maple_lover1 The interesting bit is making the first generated procedure (the first result from calling functionB) issue nice error messages if subsequently called with either n greater than the precomputed K or m greater than M-1.

I see two ways to accomplish that. The first (which I've done below) is have the n and m parameters be specified using the satisfies parameter-processing modifier. This is easier to code, although as you may see when there is a violation the error message is slightly awkward.

Another way (which I have not done here) is to substitute the piecewise into a template procedure that is coded to emit a more graceful error message. The piecewise itself can contain the protected global name equivalents for n,m,x after another substitution.

Download functionB_rev1.mw

By the way, how do you expect functionB to be used by someone? If it is to be invoked many times on-the-fly in the same session with (occasionally, or often) the exact same arguments then it might benefit performancewise to give option remember to functionB. (Ie, memoization)

@Maple_lover1 The reworking of the mechanisms to allow the old table=based orthopoly package to be used more like a module-based package is somewhat goofy. But then, so are table-based packages themseleves.

You could experiment with it done as follows:

FunctionC:=proc(k,M) local K,n,m,x;
uses O=orthopoly: 
    K:=2^(k-1);

    unapply(piecewise((n-1)/K <= x and x <= n/K,
            2^((k+1)/2)/sqrt(Pi)*O['':-H''](m,2^(k)*x-2*n+1), 0),
            [n,m,x])
  end proc:

Have a look at the output from a call like, say, FunctionC(3) and test it. (You may wish to stress-test against possibilities of the variable name H being previously assigned.) I don't much care for the procedure generated by the call orthopoly:-H(m,...) where m is an unassigned name.

There's no real difference between between w:=(x)->1; and w:=x->1; except for source tidiness and legibility.

I prefer to pass the independent variable names into unapply in a list, for clarity and legibility. I don't care for passing them as an unadorned sequence -- partially because unapply can also take some other option(s). If one's code has so many unapply calls that garbage collection of the extra list is even noticeable -- or if that list of variables is huge -- then there are surely far more other serious programming difficulties to handle.

@jrive I had replaced the link in the Reply/Comment above (to the worksheet with its name ending in "3").

@jrive I added some variants. With the radicals "frozen" they become temporary names, thus allowing algsubs or simplify-with-side-relations to operate.

@jrive Here are a few ways to get that, using algsubs with the radicals frozen.

The first way uses frontend, and the second uses freeze/thaw. The second of those can also utilize simplify-with-side-relations rather than algsubs.

new_filter_solution_ac3.mw

@love-algebra Do you think that an explicit, exact, closed form solution exists, in the general case that a root other than t=0 exists?

How about a "black box" procedure that can take numeric values for parameters and return a numeric value for `t` (if such then exists...)?

What were you planning on doing with an explicit, exact symbolic answer?

@Carl Love I have edited the Answer and changed it from
  `%.`(A,b)
to
  A %. b
which is nicer, thanks.

(The precedence doesn't affect this example -- as it is -- even in Maple 2017.2.)