Почему этот код не выполнится должным образом?

template <class T> 
T& min (T& a, T& b) 
{
  return (a<b)?a:b;
}

template <class T>
T& min (T& a, T& b)
{
return (a<b)?a:b;
}
 
 
b = b+1;
    std::cout << min(a, b) << "\n";

template <class T>
T min (T a, T b)
{
return (a<b)?a:b;
}
 
std::cout << min(a, b + 1) << "\n";

template <class T>
const T& min(const T& a, const T& b)
{
    return (a < b) ? a : b;
}

// error: cannot bind non-const lvalue reference of type ‘int&’ to an rvalue of type ‘int’
int& ref = 1;

const int v = 10;
const int& r = min(v, v - 1);

#include <iostream>
#include <type_traits>
 
#define dIS_RVALUE(t) \
  ::std::is_rvalue_reference<t>::value
 
#define dENABLE(...) \
    ::std::enable_if_t<__VA_ARGS__, void>
 
#define dFOR_RVALUE \
    class = dENABLE( dIS_RVALUE(T1&&) || dIS_RVALUE(T2&&) )
 
#define dFOR_LVALUE \
    class = dENABLE( !dIS_RVALUE(T1&&) && !dIS_RVALUE(T2&&) )
    
 
template<class T1, class T2, dFOR_RVALUE>
constexpr auto min (T1&& a, T2&& b) noexcept
    { return (a < b) ? a : b; }
 
template<class T1, class T2, dFOR_LVALUE>
constexpr decltype(auto) min (T1&& a, T2&& b) noexcept
    { return (a < b) ? a : b; }
 
int main()
{
    int a = 10, b = 10;
    
    // функция возвращвает по ссылке (int&)
    std::cout << "1) " << min(a, b) << '\n';
 
    // функция возвращвает по значению (int)
    std::cout << "2) " << min(a, b - 1) << '\n';
    
    using x = decltype(min(a, b));
    using z = decltype(min(a, b - 1));    
    static_assert(::std::is_same_v<x, int&>);
    static_assert(::std::is_same_v<z, int>);    
}

using namespace std;

template <class T> 
T& min (T& a, T& b) 
{
    std::cout << "Invisible text";
    return (a<b)?a:b;
}

// Компилируется, но есть большое НО
#include <iostream>
 
using namespace std;
 
template <class T> 
T& min (T& a, T& b) 
{
    std::cout << "Find min ...\n";
    return (a<b)?a:b;
}
 
int main()
{
    int a = 10;
    int b = 3;
    cout << min(a, b + 1);
 
    return 0;
}

// Не компилируется
#include <iostream>
 
template <class T> 
T& min (T& a, T& b) 
{
    std::cout << "Find min ...\n";
    return (a<b)?a:b;
}
 
int main()
{
    int a = 10;
    int b = 3;
    std::cout << min(a, b + 1);
 
    return 0;
}

(b + 1) = a;

// Компилируется и работает, но для min(a, b)
#include <iostream>
 
template <class T> 
T& min (T& a, T& b) 
{
    std::cout << "Find min ...\n";
    return (a<b)?a:b;
}
 
int main()
{
    int a = 10;
    int b = 3;
    std::cout << min(a, b);
 
    return 0;
}

template< class T >
const T& std::min( const T& a, const T& b );

using namespace std;

#include <iostream>
 
using namespace std;
 
template <class T> 
T& min (T& a, T& b) 
{
    std::cout << "Find min ...\n";
    return (a<b)?a:b;
}
 
int main()
{
    int a = 10;
    int b = 3;
    cout<< min(a, b);
 
    return 0;
}

min(T &a, T &b)