@PatrickT I suspect some misunderstanding.

Firstly, in your earlier versions you made assignments such as sol:=dsol along with the comment that this produced a copy of dsol. But that is not so. That assignment does not make a copy of dsol, or of the three procs within dsol. (More on copying, below...)

Even if you assign the value of (read: the procedure assigned to) dsol to various other names, you still have to reset the initial conditions (over again) of the earlier names *each time* that you wish to go back and recalculate with them.

I don't see any cheap way around having to reset the initial conditions each time you wish to recalculate. You don't have to reinvoke dsolve, I think, but you do have to reinstate the various initial conditions. For example,

restart:
dsol :=
dsolve(
[ diff(u(t),t)=u(t)-v(t), diff(v(t),t)=u(t)-w(t), diff(w(t),t)=v(t)-w(t)
, u(0)=2, v(0)=1, w(0)=2 ]
, [u(t),v(t),w(t)]
, 'type' = numeric
, 'output' = listprocedure
):
solA:=dsol:
solA(initial=[2,1,2]):
solA(-135.0);
[t(-135.0) = -135.0, u(t)(-135.0) = HFloat(3.9077543506678216),
v(t)(-135.0) = HFloat(4.992270555376236),
w(t)(-135.0) = HFloat(4.0845162047084)]
solB:=dsol:
solB(initial=[6,7,8]):
solB(-135.0);
[t(-135.0) = -135.0, u(t)(-135.0) = HFloat(8.08460488495403),
v(t)(-135.0) = HFloat(7.17680411000912),
w(t)(-135.0) = HFloat(6.092199225055099)]
solA(initial=[2,1,2]):
solA(-135.0);
[t(-135.0) = -135.0, u(t)(-135.0) = HFloat(3.9077543506678216),
v(t)(-135.0) = HFloat(4.992270555376236),
w(t)(-135.0) = HFloat(4.0845162047084)]

Are you seeing behaviour where this kind of approach is not good enough, and still has "contamination"?

In light of the above, there's not much point to having different names solA, solB, etc, with this particular scheme above. But... see at end for an alternative which does merit the various names.

I don't think that you can get around this calling the `copy` command on each of the three procs within dsol either. I mean, by doing solAu:=copy(eval(u(t),dsol)), etc, or with various judiciously placed calls like forget(solB), etc. And that's not only because of the way Maple uniquifies procs (ie. "simpls them"). You can subsop(1=..,eval(u(t),dsol)) and get various instances with actual different addresses, and still have same behaviour.

If you want to have various named procedure, for convenience of reexecution, then you can write them as simple procedures which wrap around preliminary calls to reset the initial conditions. Eg.

solA:=proc(tt) dsol(initial=[2,1,2]); dsol(tt); end proc:
solB:=proc(tt) dsol(initial=[6,7,8]); dsol(tt); end proc:
solA(-135.0);
[t(-135.0) = -135.0, u(t)(-135.0) = HFloat(3.9077543506678216),
v(t)(-135.0) = HFloat(4.992270555376236),
w(t)(-135.0) = HFloat(4.0845162047084)]
solB(-135.0);
[t(-135.0) = -135.0, u(t)(-135.0) = HFloat(8.08460488495403),
v(t)(-135.0) = HFloat(7.17680411000912),
w(t)(-135.0) = HFloat(6.092199225055099)]
solA(-135.0);
[t(-135.0) = -135.0, u(t)(-135.0) = HFloat(3.9077543506678216),
v(t)(-135.0) = HFloat(4.992270555376236),
w(t)(-135.0) = HFloat(4.0845162047084)]

Hopefully this may be of some use to you.