According to the standard §25.2.8, std::unique has behavior defined in terms of *i == *(i - 1) or pred(*i, *(i - 1)) != false however the current implementation compares each successive element to the first in the "equal" range. This is only equivalent if the transitive property holds. This is certainly wrong if a functor is passed, and it may be wrong for the other case as well. The non-functor version is defined to evaluate *i == *(i - 1) but does not require EqualityComparable elements. C++0x does impose this requirement: "The comparison function shall be an equivalence relation."
Fixing this would make std::unique quite a bit less efficient. I personally believe the intention was always to make it an equivalence relation and as you say C++0x tightens up the condition. If this had come up 5 or 6 years ago, I might have suggested fixing it, but changing it now would produce an incompatibility between our C++03 and C++0x implementations unnecessarily. Does any other compiler get this right? If they did that would make a more convincing case, but I'm fairly sure they don't.
This is a defect in the original standard: http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#202 The policy of libstdc++ is to fix defects, and I see no benefit in changing the C++03 behaviour to be incompatible with C++0x. I'm closing this as WONTFIX rather than INVALID