Now (for compiler) std::strict_weak_ordering<...> is same as
std::relation<...>, and std::equivalence_relation is same as std::relation
This produces amgibuity:

#include <concepts>
#include <functional>

bool foo(std::strict_weak_order<int, int> auto x) { return true; }
bool foo(std::relation<int, int> auto x) { return false; }

int main() {
    foo(std::less{});
}

I propose create a two different implementation concepts
strict_weak_order_sematic_requirement<R, T, U>
and
equivalence_relation_semantic_requirement<R, T, U>

#include <concepts>
#include <functional>
// Must be different for equivalence_relation
template<typename...>
concept always_true = true;
template<typename T, typename A, typename B>
concept strict_weak_order_semantic_requirement =
always_true<T, A, B>;
template<typename T, typename A, typename B>
concept strict_weak_order = std::relation<T, A, B>
&& strict_weak_order_semantic_requirement<T, A, B>;

bool foo(strict_weak_order<int, int> auto x) { return true; }
bool foo(std::relation<int, int> auto x) { return false; }

int main() {
    foo(std::less{});
}

They must be different, such that strcit_weak_order !=
equivalence_relation, this solves ambiguity in overload resolution(
https://godbolt.org/z/n7ovccf9n) and explicitly in code declares our
intensions.
May be in future implementation of this semantic concepts will be possible.