is_symmetric() fails badly for symbolic matrices

[orlitzky]

There are plenty of discussions floating around about fixing comparison with zero in inexact rings. This is another example of that issue,

sage: x11, x12, x22 = SR.var("x11, x12, x21", domain="real")
sage: X = matrix(SR, [[x11,x12],[0,x22]])
sage: X
[x11 x12]
[  0 x21]
sage: X.is_symmetric()
True

But maybe we can work around the fact that

sage: bool(x12 != 0)
False

by changing the implementation of is_symmetric()? For example...

sage: not (x12 - 0).is_zero()
True

Then at least we would not have all triangular matrices being symmetric.

[maxale]

Btw, X == X.T correctly evaluates to False.

[mantepse]

Somewhat relevant: https://groups.google.com/g/sage-devel/c/hGOw9X2X9xQ/m/UpsjvNfOBQAJ

So, with some caveats / exceptions, x.__bool__ returns True unless it is known to be zero. (The word "only" in the linked post is a mistake and should be "unless".)

[mantepse]

Hm, I don't know nothing, but how is

sage: bool(x11)
True
sage: bool(x)
True
sage: bool(x11 != 0)
False
sage: bool(x != 0)
True

not a bug?

[orlitzky]

The rules for SR are informal, so it is subjective, but I think it is a bug. Fixing the big problem may prove difficult, though, while fixing is_symmetric() could be easy to do (without hurting anything else) by changing the way we test for zero.

[mantepse]

Changing is_symmetric also has consequences for matrices of lazy power series.

[mantepse]

The rules for SR are informal

I think that they shouldn't be informal, and at least the documentation of __bool__ is precise.

[orlitzky]

Yes, we'd have to be careful not to harm any scenario where comparison with zero is inexact. I think/hope that most inexact rings behave better than SR, though. Floating point matrices for example compare with a tolerance and would not use the generic implementation. Overriding the generic implementation (only for SR) is also an option.

In SR everything is weird because bool() is ternary but we force the return value to be binary (#39319). It's also unclear whether, say, x^2/x should act like the polynomial x or the function x |-> x^2/x (which is undefined at zero). Should expressions that evaluate to zero everywhere have is_zero(), or should it only be the zero expression for which is_zero() is true? People have thought about these issues but there are no formal rules that I know of, so it is very hard to maintain consistency.