@Carl Love Thanks very much. I shall think it over later.

And what about other two commands? Contrary to my expectations, they do not do the same thing (at least here). 

@Oliveira I find an instance such that _Z1 ≠ _Z1: 

restart;
op([-1, -1], Invfunc[cos](0)):
ToInert(%);

restart;
op([-1, -1], Invfunc[cos](0)):
ToInert(%);

restart;
op([-1, -1], Invfunc[cos](0)):
ToInert(%);

The return value is always _Inert_LOCALNAME("_Z1~", ```different number```), which is surely distinct from the ToInert(_Z1).

@nm Thanks. As regards the series solutions, if an "exact" general solution is available, we can utilize the asympt function later, but if the symbolic solver is stuck… 
An instance that both Maple and Mathematica cannot solve: 

dsolve({t^2*diff(diff(z(t),t),t)+log(t)^2*z(t)=0},z(t),type='series',t=infinity):
AsymptoticDSolveValue[t^2*Derivative[2][z][t]+Log[t]^2*z[t]==0,z[t],t->Infinity];

@nm It's a undocumented internal function, so use of Holonomic`DifferentialAsymptoticSeries is somewhat discouraged. 

In addition, unfortunately, 

dsolve({t^6*diff(diff(z(t),t),t)+2*t^5*diff(z(t),t)-4*z(t)=0},z(t),'series');

returns nothing (in other words, Maple is unable to find symbolic solution), but Mma's AsymptoticDSolveValue is still capable of solving it. (I don't why.)

@nm Actually, one can obtain (almost) the same results in Mma: 

Series solutions from MatLab's ode::series (just for comparison): 

@Carl Love & @mmcdara Thanks. 

In my opinion, Mathematica's Apply is technically not identical with Maple's apply. Compare:

(* Mma *)
Construct[f, a, b, c];
(* Maple *)
apply(f, a, b, c):

 and 

(* Mma *)
Apply[f, {a, b, c}];
(* Maple *)
`?()`(f, [a, b, c]):

@Carl Love Well, maybe the better term is "ordered pair" rather than "rule" (let alone "function"). (A bijection is dispensable.)
Here is the result from Mathematica: 

@Christian Wolinski, @mmcdara, and @Carl Love 
Thanks. But if we add a new rule f＝g (which gives an additional cycle), the results will go wrong.

@lcz 

eval(reduce(uneval(SubstituteAll), [s, seq(uneval(L1[k], L2[k]), k = 1 .. length['shortname'](L1))]));
 = 
  "{ {0, 1}, {1, 2}, {1, 10}, {2, 3}, {3, 4}, {4, 5},

    {4, 9}, {5, 6}, {6, 7}, {7, 8},{8, 9}, {10, 11}, {11, 12},

    {11, 16}, {12, 13}, {13, 14}, {14, 15}, {15, 16}}"

@Carl Love Actually, as I mentioned before, sometimes such a list does perform a permutation, but in my opinion, we do not need to regard it as a permutation. 
Here we convert one cycles into (another) rules: 

cycles := [[g, d, c], [e, a], [f, d, c], [b]]:
use ListTools in rules := (combinat['randperm']@MakeUnique@curry(`?()`,`=`)~@FlattenOnce)([seq(Transpose([k,Rotate(k,1)]),k  in  cycles),[[a,b](*,[f,g]*)]]) end use: # a = b obfuscates the rules here.

Yet I have no idea how to reconvert rules back into cycles. 
Comparison: 
 

Download trivial.mw

@Carl Love Sorry, I don't know if such algorithms exist. This instance is adapted from the last example of MMA's Apply (which is more or less similar to Maple's `?()`). Unfortunately, the original function that occured in the help page only has limited functionalities. (So it is incorrect in general.)

@Carl Love Since a＝b cannot become or form a cycle (∵ b＝a is missing or lacking), the output should exclude [a, b].

@Carl Love Surely need not necessarily be a permutation; They are just a list of "ordered pairs". (However, sometimes such a list does perform a permutation.)

Remark. Something like this: the rules (instead of equalities) g＝d, c＝g, d＝c construct a cycle g→d→c→g, so the result includes [g, d, c] (and for the same reason, the result includes [f, d, c] as well).

@dharr & @acer Thanks. It appears that nothing returns when I just give simple bounds on variables: 
 

Download anExplicitEnumeration.mw