Works without errors in Maple 2017.3.

You should try to present the mathematical problem.
Otherwise, for suggestions or alternate solutions a "reverse engineering" of the Maple code will be necessary.

@Rouben Rostamian  

For an "lndirect documentation" see showstat(log).

@Carl Love 

I was also curious to understand on what basis Maple returns true for is(exp(2),irrational);
This information should (probably) be found in `property/exp` but it's not there.
It would be very disappointing if the answer is obtained using approximations because Digits cannot be set to infinity and the answer is simply a guess in this case.

is(x,irrational) seems indeed to be a pure guess because of:

is(sum(10^(-k^3),k=1..infinity), irrational);
        false

@Rouben Rostamian  

If f is the name of a procedure then  f[u](x)  actually calls  f(x), but in the body of f the index/indices
u can be retrived (and used) via  op(procname).
To check whether f is invoked with an index one may use  type(procname,indexed).

(I am not sure whether this is documented, but I found about it long time ago in a Maple book which I do not remember). 

@Carl Love 

But ?type,property clearly says:

Note: Types are properties, but not all properties are types.

Do you know a type which is not property? (I don't mean "proper").

@Jason Lee 

Download linsyst.mw

@Jason Lee 

What exactly is not clear? I have used your notations.
But I just noticed that you are using Maple T.A. and I am not sure whether this works here.

@Carl Love 

Why dou you think that is is using list(rational) as a type? Of course, any type is a property.

is(list(rational), property);
   true

type(list(rational), property);
    true

Probably your notion of "proper property" is useful.

@_Maxim_ 

Of course is uses simplifications. It should  return FAIL much more frequently (when in doubt)  but it does not probably for "commercial" reasons; it prefers `false`. The assume facility deserves a much more careful implementation.

Surprisingly:
is(exp(1)+Pi,irrational);
    FAIL
So, it seems that is adopts a special strategy for properties which are not types.

Also:

is(Pi,irrational);
                              true
is(Pi^2,irrational);
                              FAIL
is(exp(1),irrational);
                              true
is(exp(1)^2,irrational);
                              FAIL
is(exp(2),irrational);
                              true

is(exp(sqrt(2)),irrational); #does not know Lindemann theorem (from 1882!)
                              FAIL

@st104290 

As you see in the example, sort itself does not alter the terms. Probably you have used some other command.
You may append assuming t>0  to that command.

@Markiyan Hirnyk 

As always you want to have the final word even when you are wrong.
But two pages earlier Fichtenholz states:  "generalized sum" (in the sense of Poisson).
He also says that actually Abel was not interested in the summation of divergent series.

Note.
In 1828 Abel wrote `Divergent series are the invention of the devil, and
it is shameful to base on them any demonstration whatsoever.'

[Abel died in 1829]

@Markiyan Hirnyk 

It is also called "power series method" or Poisson (e.g. in the Mathematical Analysis book by G.M. Fichtenholz).

@Markiyan Hirnyk 

Genericity is not strictly defined in Maple. There are plenty of such examples.
I don't think that the situation is going to change soon. The assume facility is too weak.
The correct answer for a real k should be:  piecewise(k<-1, 0, k=-1, 1, infinity)

sum(binomial(i+k,k),i=0..infinity) assuming k>-2,k<-1; #ok
                               0
sum(binomial(i+k,k),i=0..infinity) assuming k>-2,k<=-1; #wrong
                               0
sum(binomial(i-1,-1),i=0..infinity);simplify(%);
                  infinity                   
                   -----                     
                    \                        
                     )                       
                    /     binomial(i - 1, -1)
                   -----                     
                   i = 0                     
                  infinity                   
                   -----                     
                    \                        
                     )                       
                    /     binomial(i - 1, -1)
                   -----                     
                   i = 0                     
1+sum(binomial(i-1,-1),i=1..infinity);  # ok
                               1
sum(binomial(i+k,k),i=0..infinity) assuming k>=-1; # wrong
                            infinity
sum(binomial(i+k,k),i=0..infinity) assuming k>-1; # ok
                            infinity

@Preben Alsholm 

Probably the OP has converted somehow the numbers into "atomic" variables (via patettes or some 2d input "facilities").
Such as:

`#mn("13")` + 13;
     13+13