Warn with substitution of derived classes using equality

[rwst]

There is a long-standing problem with substitution in that some substitutions do not work when given as equality but do work when given as dictionary.

sage: (x*pi).subs(x*pi==e)
x*pi
sage: (x*pi).subs({x*pi:e})
e

sage: s = x.series(x,2); s
1*x + Order(x^2)
sage: (x*pi).subs(x*pi==s)
pi*x

It looks like that in some cases the conversion to dict switches lhs and rhs of the equation and this is because of such behaviour:

sage: x*pi==e
e == pi*x
sage: x == s
1*x + Order(x^2) == x

Component: symbolics

Issue created by migration from https://trac.sagemath.org/ticket/24255

[rwst]

Description changed:

--- 
+++ 
@@ -7,4 +7,10 @@
 e
 ```
 
-It looks like that in some cases the conversion to dict switches lhs and rhs of the equation.
+It looks like that in some cases the conversion to dict switches lhs and rhs of the equation and this is because of such behaviour:
+
+```
+sage: x*pi==e
+e == pi*x
+```
+This should really be fixed.

[rwst]

Description changed:

--- 
+++ 
@@ -13,4 +13,18 @@
 sage: x*pi==e
 e == pi*x
 ```
-This should really be fixed.
+The problem is that constants are not made into expressions immediately:
+
+```
+sage: SR(e)
+e
+sage: type(_)
+<type 'sage.symbolic.constants_c.E'>
+sage: e+1-1
+e
+sage: type(_)
+<type 'sage.symbolic.expression.Expression'>
+sage: x*pi==e+1-1
+pi*x == e
+```
+

[rwst]

Description changed:

--- 
+++ 
@@ -27,4 +27,4 @@
 sage: x*pi==e+1-1
 pi*x == e
 ```
-
+It seems that `e` is the only constant affected by this.

[rwst]

Description changed:

--- 
+++ 
@@ -5,6 +5,9 @@
 x*pi
 sage: (x*pi).subs({x*pi:e})
 e
+
+sage: s = x.series(x,2); s
+1*x + Order(x^2)
 ```
 
 It looks like that in some cases the conversion to dict switches lhs and rhs of the equation and this is because of such behaviour:
@@ -12,8 +15,10 @@
 ```
 sage: x*pi==e
 e == pi*x
+sage: x == s
+1*x + Order(x^2) == x
 ```
-The problem is that constants are not made into expressions immediately:
+The problem is that constants/series are subclasses of `Expression` and are not coerced/converted immediately into `Expression`:
 
 ```
 sage: SR(e)
@@ -24,7 +29,4 @@
 e
 sage: type(_)
 <type 'sage.symbolic.expression.Expression'>
-sage: x*pi==e+1-1
-pi*x == e
 ```
-It seems that `e` is the only constant affected by this.

[rwst]

Description changed:

--- 
+++ 
@@ -8,6 +8,8 @@
 
 sage: s = x.series(x,2); s
 1*x + Order(x^2)
+sage: (x*pi).subs(x*pi==s)
+pi*x
 ```
 
 It looks like that in some cases the conversion to dict switches lhs and rhs of the equation and this is because of such behaviour:

[rwst]

Description changed:

--- 
+++ 
@@ -20,12 +20,10 @@
 sage: x == s
 1*x + Order(x^2) == x
 ```
-The problem is that constants/series are subclasses of `Expression` and are not coerced/converted immediately into `Expression`:
+The problem seems that constants/series are subclasses of `Expression` and are not coerced immediately into `Expression`.
 
 ```
-sage: SR(e)
-e
-sage: type(_)
+sage: type(e)
 <type 'sage.symbolic.constants_c.E'>
 sage: e+1-1
 e

[rwst]

comment:7

class A(SageObject):
    def __init__(self):
        from sage.symbolic.ring import SR
        self._parent = SR
    def __eq__(a, b):
        print(a, b)
        return True
    def __repr__(self):
        return "A"

class B(A):
    def __eq__(a, b):
        print(a, b)
        return True
    def __repr__(self):
        return "B"

sage: from sage.symbolic.tests import A,B
sage: A() == B()
(B, A)
True

versus

class A():
    def __init__(self):
        from sage.symbolic.ring import SR
        self._parent = SR
    def __eq__(a, b):
        print(a, b)
        return True
    def __repr__(self):
        return "A"

class B(A):
    def __eq__(a, b):
        print(a, b)
        return True
    def __repr__(self):
        return "B"

sage: from sage.symbolic.tests import A,B
sage: A() == B()
(A, B)
True

The first has A inherit from SageObject the second not.

[rwst]

comment:8

Since we cannot use the @richcmp decorator on a cdef class we cannot work around it but must investigate the reason for the argument switching, which is possibly in Cython.