Add a callback function so that -k can take a variable number of
arguments.  Fixes #5228
do not exec file if none of the kw is/are present

Also, in case None is the value for kw, make it a tuple
Merge pull request #1 from smichr/optparse

do not even exec file if the kw is not present
Merge pull request #8087 from pbrady/optparse

Allow -k to take a variable number of arguments
additional bounded -> finite changes
add docstring to as_dummy()
do not use bare </> tests of things which might not be Numbers
modify assumptions

It is currently possible to create a meaningless set of assumptions:

    neither
        Dummy(zero=True, finite=False) nor
        Dummy(zero=True, infinite=True)
    raise an error.

    If we assume finite == !infinite in assumptions, we
    create an alias: finite=False is the same as infinite=True
    and vice versa. We don't want to do that. What we want is
    behavior like integer and noninteger:

    Dummy(integer=0) is not the same thing as Dummy(noninteger=1).
    A noninteger is commutative, complex, hermitian, noninteger,
    nonzero, and real while integer=0 is only commutative -- nothing
    else is known about it (other than that it is not 0).

    /!\ In general, it is much easier to comprehend what one means
    by using only true attributes to desccribe it. If something is
    not zero but still complex, say nonzero=True instead of zero=False.

    So assumptions.py has been modified to make the following true:

    ```
    finite   : 0 < abs(x) < oo
    finite  : 0 <= abs(x) < oo
    infinite : abs(x) == oo
    ```

    The same is also true for zero and nonzero. If nonzero is True you
    are talking about a complex number that is not zero. But if zero is
    False you are only talking about a commutative object that is not
    zero.

    In addition, we now use is_infinite = True not is_finite = False
    in the few places where this is defined. The former is an affirmation
    of what the object *is* not an indication of what it is not.

In addition, nonzero is also made to be complex and rationals and integers
are now marked as finite. The new assumption nzfinite was added to
describe a number with 0 < abs(x) < oo.
remove redundant attributes of numbers
remove redundant clause testing for NaN after finite test
modify Mul._eval_is_* routines
modify use of assumptions with symbols
update tests for changed attributes on integer and nan
modify Add._eval_is_* routines
modify wester test
add tests and modify existing tests
let _unevaluated_Add collect numbers, too
do not call self.is_* from _eval_is_* routines

I am not sure about the ramifications but my hunch is that
if, when trying to resolve fact foo, an _eval_is routines
calls self.is_bah -- and bah is not actually a prerequisite
of foo -- that this might interrupt the resolution of fact
foo. At least, using the _eval method will result in a faster
resolution of the fact without running through prerequisites
of the fact. But again...I'm not even sure that's a good idea.
I'm not sure how much of the burden of knowing what to call
should be the responsibility of the _eval_is routines and how
much should be handled by the assumption machinery. (I know the
machinery will handle prerequisites, but it is not clear how
to effectively write the _eval_is routines so they are not
working too hard.
do not add tests that are not prereq

    It is important not to add prerequisites to a result that are
    not consistent with the assumption rules. This can lead to facts
    being missed, something that will be intermittent in nature depending
    on the order in which the assumptions are traversed to resolve the fact.

    for example:

    >>> from sympy.core.assumptions import _assume_rules as R
    >>> print filldedent(R.prereq['imaginary'])

    set(['real', 'prime', 'irrational', 'antihermitian', 'nonpositive',
    'composite', 'zero', 'integer', 'odd', 'even', 'commutative',
    'positive', 'noninteger', 'negative', 'nonnegative', 'complex',
    'rational'])

    Having an answer to nonzero is not a prerequisite of knowing the
    `imaginary` fact. The same is true for antihermitian.

    >>> print filldedent(R.prereq['antihermitian'])

    set(['imaginary'])
only allow super call if self is real