@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

@Carl Love 

"<==" is obvious.

"==>" Follows from a lemma due to Birkhoff:

For each doubly stochastic matrix there is a permutation of the columns such that all the diagonal elements are nonzero.
(see Horn R. A., Johnson C. R. - Matrix Analysis. Cambridge 2013).

[Note that for our matrix M, (1/2)*M is doubly stochastic].

@acer 

I like Carl's main ingredient which is worth formulating explicitely:

Lemma.
A binary square matrix M has two ones in each line and each column iff
there exist a permutation matrix P and a dearangenent matrix Q such that M = (I + Q).P
(the representation is not unique).

@Carl Love 

and vote up, of course!

P.S.  Probably    runtime + time(algorithm)  >>  time(brute force)   in this case   :-)
 

@Preben Alsholm 

In other cases an error appears:

evalf(Int(1/t^2, t=I .. I*infinity));
Error, (in evalf/int) non-numeric integration limit encountered

so, probably the parameters are not correctly checked.
But anyway evalf should transform correctly the complex limits into reals.