You cannot use isolve for this. But you don't need it because

j = floor(m*t) + 1

Most error messages are clear enough.
If the arguments are not displayed, you can do something like this:

GETBITS:=proc()
try
  Bits:-GetBits(args);
  catch:
  error "Bits:-GetBits", lasterror, 'ARGS'=args;
end try
end proc:

GETBITS(64+4,2);
                               1
GETBITS(12.3, 4);
Error, (in GETBITS) Bits:-GetBits, argument 1, the number, must be a nonnegative integer, ARGS = (12.3, 4)

The direct computation would be inefficient.

Maple uses the prime factorization and Euler's product formula (see the wiki article).
You can see the implementation:

showstat(NumberTheory:-Totient);

An orbit is not associated to an element of the group (x in your case). It is associated to an i ∈ {1,2,3}.

Maybe you want the order of x [which equals the order of the (cyclic) group generated by x].

You should post the Maple code and the expected answer.

"non deterministic"  in the sense that the order of the objects in memory cannot (normally) be anticipated by the user.

Example

restart;
b:
sort([a,b], address);
                             [b, a]
restart;
sort([a,b], address);
                             [a, b]

It is not a good idea to mix symbolics and floats.

Use:

int(int(sin(x^2*y), x = 1 .. Pi), y = 1 .. Pi);  # symbolic

evalf(%);   # approximate the result

Or,

evalf( Int(Int(sin(x^2*y), x = 1 .. Pi), y = 1 .. Pi) );  # numeric integration

# The linearization  of F(u)  near u0 in the "direction" h, (h=small)
# (If u=u(x), actually it's about directional derivative in a function space)
Lin:=proc(F, u, u0, h)
local eps;
eval(F, u=u0+eps*h);
series(%, eps,2);
eval(convert(%,polynom),eps=1)
end:

# Your case:
sin(phi2)*sin(psi1(t))*lk*m1*(diff(psi1(t), t, t))+sin(phi2)*(diff(psi1(t), t))^2*cos(psi1(t))*lk*m1:
Lin(%, psi1(t), psi1__0(t), u(t)):   simplify(%);

# This agrees with Rouben's answer.

Unfortunately assuming works well only for simple conditions/properties.

But usually it is easy to obtain sufficient convergence conditions (as you did) and the sum can be computed using
sum(exp(a*k*Ta)*z^(-k), k=0..infinity, formal);

Edit. The convergence condition is actually  abs(exp(a*Ta)/z) < 1
but note that even assuming a<0, Ta<0, z>10  does not work.

Your  algebraic fractions al already simplified (but there are of course other possibilities, e.g. partial fractions).
For a factorization, the field K is needed.
For K=Q, the polynomials are already factorized.
If you want K=C (complete factorization) the simplest way is to find the roots with solve. E.g.

p:=(k+2)*(k^2+5)*(k^3-5*k^2+13*k-8)/(6*k*(k^2-3*k+8)):
p1,p2:=(numer,denom)(p):
R1,R2:=[solve(p1,k,explicit)],[solve(p2,k,explicit)]:
mul(k-r,r=R1)/mul(k-r,r=R2);

Actually, the solution of your ODE is

A(t) = a * exp( I * ( a^2*t + b ) ),  where  a, b are real constants.

This can be obtained with Maple writing A(t) in polar form:

restart;
ode := diff(A(t),t) - I * conjugate(A(t))*A(t)^2:
simplify(eval(ode, A(t)=R(t)*exp(I*phi(t)) )  /exp(I*phi(t)) ) assuming real:
evalc([Re,Im](%)):
dsolve(%);

restart;
a := Matrix(3, 3, [[x, y, z], [y, z, x], [z, x, y]]):
ex:= Matrix(3, 3, [[x, y, z], [y, z, x], [z, x, y]]) + B:
#eval(ex, a=A); #does not work
evalindets(ex, 'Matrix', u -> `if`(EqualEntries(u,a),A,u));
                             B + A
evalindets(ex, 'Matrix', u -> `if`(LinearAlgebra[Equal](u,a),A,u));
                             B + A