You need to also need to remove the zeros from here.

How do you test zero? This is the issue @roed314 complained about: for some base rings (such as power series or p-adics) we do not want to simplify trailing zeros such as O(t^5). Removing zeros is now handled by polynomials in multi_polynomial_element.py rather than PolyDict. Though I am looking for a better way to consistently handle all base rings (which at the moment is not taken care of at all).

Note that this is a change in the behavior compared to before. Extra zeros in the polynomial pollute it and make the code slower. Simply do what you do in other places and call the method that you replaced the remove_zeros argument.

In fact, I really don't see the utility of pulling that out as a separate method. It leads to easy-to-overlook issues like this and requires more direct manual intervention (with now a seemingly separate method) from the coder. I think you need to have some justification for separating this..

In summary, the here is not how to test for zeros (which is a separate issue), but they fact you are not calling remove_zeros() whereas before it was doing the equivalent with remove_zero=True for the constructor.

What do you call polynomial in this context: a Polydict or a MPolynomial_element?

A PolyDict never removes zero coefficients simply because it does not know how to test zero. This test depends on the base ring and PolyDict does not store the base ring. However, MPolynomial_element does know about the base ring and can implement a remove_zero.

That would be a bit of an improvement, although I am not sure the extra work and maintenance is worth it from your current proposal.

Could we step back from this local picture and look at what each class is supposed to do? My initial comment might have been looking too locally at the change. I am hoping this will clarify things, possibly leading to your current proposal.

Right now, we have three classes:

1. ETuple: represents a single monomial. This is good, unique, and clearly necessary.
2. PolyDict: represents a linear combination of terms by a dict mapping monomials to their coefficients. Implemented in Cython.
3. MPolynomial_element: partially wraps a PolyDict but also carries more information about the base ring. Implemented in Python.

Now it is clear what stuff should be handled by the ETuple, but it is not clear what separates 2 and 3. Why shouldn't a PolyDict know about the coefficient ring? Do we have some reason why it is kept as a separate backend class? Part (most?) of this, I imagine, is to be able to split it off as its own separate entity and not have it fully integrated into Sage. So why doesn't MPolynomial_element inherit from PolyDict? If it was a Cython class, then we run into multiple inheritance issues. If MPolynomial_element inherited from PolyDict, then it could implement, e.g.,

def _add_(self, other):
    ret = PolyDict.__add__(self, other)
    ret.remove_zeros()
    return ret

which should be comparative in terms of speed (not tested). Although I guess from this separation of the backend with eye towards Cythonization, it would make sense to keep the current version, right?

I agree with your analysis of the situation. Some additional points

• making PolyDict agnostic to coefficients nature makes it possible to have plain Python type for coefficients (eg int or float) or mixed types (eg exact and floating point values)
• one extra delicate point with inheritance, is that PolyDict.__add__ would have to be careful about its return type (which do have a cost)

I cleaned the current version to make it clear that we want to use remove_zeros more carefully. If you are happy with the current merge request I will open an issue on what has to be done next to handle properly polynomials over rings with trailing zeros.

I think I am modulo the last few things I commented below about with your more recent changes. It is nice to see a little more clarification in the docs about this.

I opened a general discussion about inexact zeros at #35319. I will mention the latter in the documentations of PolyDict and MPolynomial_element.