Old assumptions: replace !finite == infinite with infinite -> !finite

The motivation here is that there might be things that are neither finite nor
infinite, i.e., non-numbers. For example, I would expect anything with
commutative=False to be neither finite nor infinite.

This only changes the fact in assumptions.py, and does not fix any of the
remaining code in SymPy to match it.
Old assumptions: change nonzero == !zero to nonzero == real & !zero

This matches the definition in the new assumptions. This definition is more
useful, as !zero can just as easily be accessed by not expr.is_zero. This also
matches the other non- assumptions, namely nonnegative and nonpositive, which
mean real & !negative and real & !positive, respectively. This definition may
end up being a "gotcha", but hopefully its usefulness will outweigh this.
Old assumptions: Add the fact complex -> finite

The only reason I didn't add the fact complex == finite is that it seems to
make finite pointless, as it would become an exact alias for complex. However,
I am not quite sure what would be finite and not complex. Perhaps we should
make it this, or even delete finite and just use complex.

Note that this will require changing things like oo.is_real == True, as this
makes all complex numbers finite. I have not made any changes outside of
assumptions.py yet.  It will likely be necessary to add extended_real and/or
extended_complex assumptions as aliases for real | infinite and complex |
infinite.
Add extended_real to the old assumptions

This only adds the fact to assumptions.py. It does not change any of the
corresponding code elsewhere.

I have made the change that positive and negative are the extended versions
(i.e., oo and -oo are positive and negative).  This means that real is finite,
and positive does not imply real.

I did not make nonzero or noninteger imply extended_real, but perhaps I
should, at least for nonzero.
Old assumptions: Add fact for zero to be imaginary

This only changes assumptions.py, not the corresponding changes throughout
SymPy. See #7649. There are two motivations for this change. First, it makes
more sense mathematically ("imaginary" now means "on the imaginary axis"), and
second, because it makes some more useful deductions possible, such as r*I =
imaginary for r real.
add single-level paren support and func attribute

Also, errors are raised if there are not spaces around
& and | or if there *is* a space after '!'. This inflexibility
enforces readability on the input strings.