What is the specification on how value comparisons have to be implemented?

Question

I can't seem to find the actual language specification on how value comparisons have to be done by a complying implementation (e.g. CPython). Consider the simple case

a == b

The reference says that this is done using the “rich comparison” methods, in this case __eq__(). Neither the Data Model nor the reference on Value Comparison Expressions seem to specify in detail, what else a Python implementation is required/allowed to do, especially if the type(a) signals that it does not implement __eq__ by explicitly returning NotImplemented.

This answer plausibly suggests that for any a == b, CPython

1. calls b.__eq__(a)(!) if b is a subclass of a. This makes intuitive sense, as it allows the subclass to overload all comparisons between values of itself and it's parent class (therefor also implying symmetry for both the parent and the subclass).
2. if the above fails, calls a.__eq__(b)
3. if the above fails, calls b.__eq__(a) if that hasn't happened yet;
4. falls back to identity comparison

AFAICS this order makes sense, also given Python's loose sense of symmetry, reflexivity, variance and the like. My question is: Does the language guarantee that for any a == b (or other value comparisons), a complying implementation will execute the comparison in the way described above?

Answer 1

The said behaviors are well documented in the rich comparison methods section of Data Model:

x==y calls x.__eq__(y) (behavior #2)

and:

There are no swapped-argument versions of these methods (to be used when the left argument does not support the operation but the right argument does); rather, __lt__() and __gt__() are each other’s reflection, __le__() and __ge__() are each other’s reflection, and __eq__() and __ne__() are their own reflection. (behavior #3) If the operands are of different types, and right operand’s type is a direct or indirect subclass of the left operand’s type, the reflected method of the right operand has priority, otherwise the left operand’s method has priority. (behavior #1)

and finally:

By default, object implements __eq__() by using is, returning NotImplemented in the case of a false comparison: True if x is y else NotImplemented. (behavior #4)

Although in the documentation there are no numberings to explicitly spell out the order of the behaviors above, it is logically inferred:

• "x==y calls x.__eq__(y)", making it a tentative behavior #1.
• "__eq__() and __ne__() are their own reflection", so if x.__eq__(y) fails, then y.__eq__(x) is called, making this a tenative behavior #2.
• "If the operands are of different types, and right operand’s type is a direct or indirect subclass of the left operand’s type, the reflected method of the right operand has priority", so when the right operand is a subclass of the left, this condition overrides the aforementioned two behaviors and calls y.__eq__(x), making it the actual behavior #1, demoting the other two to #2 and #3.
• "By default, object implements __eq__() by using is", so if all else fails, it would fall back to the default behavior of object's implementation of __eq__() using identity comparison, making it behavior #4.