Updated assumptions: Now complex and !finite infers infinite.

[ShubhamKJha]

References to other Issues or PRs

Fixes #16579

Brief description of what is fixed or changed

A complex value can either be finite or infinite. Therefore, complex and not finite should mean the value is infinite. Currently, SymPy doesn't account for this.
With this PR,

>>> from sympy import Dummy
>>> Dummy(complex=True, finite=False).is_infinite
True

Other comments

Release Notes

• core
  • added new clause complex -> finite | infinite in _assume_rules in assumptions.py.

[sympy-bot]

✅

Hi, I am the SymPy bot (v147). I'm here to help you write a release notes entry. Please read the guide on how to write release notes.

Your release notes are in good order.

Here is what the release notes will look like:

• core
  • added new clause complex -> finite | infinite in _assume_rules in assumptions.py. (#16592 by @ShubhamKJha)

This will be added to https://github.com/sympy/sympy/wiki/Release-Notes-for-1.5.

Note: This comment will be updated with the latest check if you edit the pull request. You need to reload the page to see it.

Click here to see the pull request description that was parsed.

<!-- Your title above should be a short description of what
was changed. Do not include the issue number in the title. -->

#### References to other Issues or PRs
<!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact
format, e.g. "Fixes #1234". See
https://github.com/blog/1506-closing-issues-via-pull-requests . Please also
write a comment on that issue linking back to this pull request once it is
open. -->
Fixes #16579 

#### Brief description of what is fixed or changed
A complex value can either be `finite` or `infinite`. Therefore, `complex and not finite` should mean the value is `infinite`. Currently, SymPy doesn't account for this. 
With this PR,
```py
>>> from sympy import Dummy
>>> Dummy(complex=True, finite=False).is_infinite
True
```

#### Other comments


#### Release Notes

<!-- Write the release notes for this release below. See
https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information
on how to write release notes. The bot will check your release notes
automatically to see if they are formatted correctly. -->

<!-- BEGIN RELEASE NOTES -->
* core
  * added new clause `complex  ->   finite | infinite` in `_assume_rules` in assumptions.py.
<!-- END RELEASE NOTES -->

Update

The release notes on the wiki have been updated.

[codecov]

Codecov Report

Merging #16592 into master will increase coverage by 0.027%.
The diff coverage is n/a.

@@              Coverage Diff              @@
##            master    #16592       +/-   ##
=============================================
+ Coverage   73.805%   73.833%   +0.027%     
=============================================
  Files          619       619               
  Lines       159230    159230               
  Branches     37370     37370               
=============================================
+ Hits        117521    117565       +44     
+ Misses       36273     36236       -37     
+ Partials      5436      5429        -7

[jksuom]

Please add a test.

[oscargus]

I'm not that well versed with the assumption system, will this also mean that the same thing hold for e.g. real?

(Wouldn't it be enough to add an assumption as finite == !infinite? Which I realize that there already is one. So this is really the connection that any number that is finite is not infinite and vice versa? Maybe the release note should be updated to clarify this?)

[ShubhamKJha]

HI @oscargus we can't take finite == !infinite, there can numbers which are both not finite and not infinite (e.g. nan). The case that finite infers not infinite holds for complex numbers (real numbers are complex so they are covered).
How should I update release notes?

[oscargus]

OK! Yeah, now I noted that it is only in one direction, so infinite -> !finite, not the other way around.

I'm just thinking that maybe one should focus on the practical effect in the release note. Now, if you specify any property of the number (complex, imaginary, real, rational, integer) and either finite or infinite, it will inherit the other finite/infinite property. This is clearly not how it should be formulated though... But more the practical consequence than the code change.

This also means that specifying e.g. real means that it cannot take on NaN by definition and that is really the only difference between that and not specifying anything.

It leads to the question: what does this really say about x?

Symbol('x', finite=False, infinite=False)

xis NaN?

[ShubhamKJha]

It leads to the question: what does this really say about x?

Symbol('x', finite=False, infinite=False)

xis NaN?

Now I see, nan.is_finite and nan.is_infinite both return None. Though clearly there can be consequences of having finite == !infinite, I can't find an example which breaks this. Another argument is in this commit's message.

[asmeurer]

I guess I originally wanted to add complex -> finite in #8293, but it was too hard. This is a good step forward.

We should decide once and for all however exactly which predicates should contain infinity.

[asmeurer]

Maybe add a comment here that complex may not imply infinite in the future.

[ShubhamKJha]

Okay, I would add comment.

[ShubhamKJha]

@jksuom is it good to be merged?

[jksuom]

With this complex and not finite would infer infinite. Since reals are complex, the implication follows in real as well.

I would remove this explanation from the release notes. Maybe it, or part of it, could go in the comments above. Otherwise I think this is good to be merged.

[ShubhamKJha]

Hi @jksuom considering the work in #16603 the scenario with reals may change so I am not adding this to comments. I revised the release notes please merge it.

[jksuom]

Thanks.