Automatically implement operator+ using CRTP
Missing header
I had to #include &lt;utility&gt; to get a definition for std::move().
Don't delete your destructors
You didn't show us your tests, but I struggled to get my obvious code to compile.  Part of the reason was the deleted constructors; I changed the default constructor to protected and made the copy/move constructors to protected and = default, and then I was able to inherit without having to explicitly write copy/move construct/assign in my subclass:
struct Test : public Sumable&lt;Test&gt;
{
    int i;
    Test(int i) : i(i) {}
    Test&amp; operator+=(const Test&amp; t) { i += t.i; return *this; }
};

There's no need to move() when returning
I know the question is tagged C++11, but even there, any benefit is questionable (and particularly unlikely to exist when the function is inlined).  When you move the code to a more recent standard, it's actively harmful.
Pass by value instead of copying from a reference
If you can insist on the usual x + y == y + x (which seems to be assumed already, given the third and fourth methods, which compute rhs += *this), then you can pass rhs by value (since we need to copy one of the arguments), which will be move-constructed as and when appropriate:
template&lt;class T&gt;
inline T Sumable&lt;T&gt;::operator+(T rhs) const
{
    return rhs += *static_cast&lt;const T*&gt;(this);
}

That's now one method instead of four.
N.B. I had to introduce the static_cast there, as your code wouldn't compile with GCC 8.0 without it.
Consider free functions
Inheritance isn't necessarily the best solution to everything in C++.  You may be better writing free functions instead (in the same namespace as your classes, or in a specific includable namespace, along the lines of std::rel_ops).
Here's a start, including a basic test:
#include &lt;type_traits&gt;

namespace arithmetic_ops
{
    template&lt;typename T, typename U&gt;
    auto operator+(T t, U&amp;&amp; u)
        -&gt; typename std::remove_reference&lt;decltype(t+=u)&gt;::type
    {
        return t += u;
    }

    template&lt;typename T, typename U&gt;
    auto operator+(T&amp;&amp; t, U u)
        -&gt; typename std::enable_if&lt;!std::is_assignable&lt;T,U&gt;::value,
                                   decltype(operator+(u,t))&gt;::type
    {
        return u + t;
    }
}


namespace test {
    struct Test
    {
        int i;
        Test(int i) : i(i) {}
        Test&amp; operator+=(const Test&amp; t) { i += t.i; return *this; }
    };
}

int main()
{
    using namespace arithmetic_ops;

    test::Test a(4);
    test::Test b(-4);
    return (0 + a + b + 0).i;
}

I've used forwarding references above for the non-copied argument - that allows us to have only one method for the class-first case (the second version being an override for cases such as 0 + a where the first argument must be converted).
The enable_if avoids ambiguity when t + u and u + t are both possible.
The ::type and ::value members get shortened from C++14, with _t and _v suffixes to the names (e.g. std::remove_reference_t&lt;decltype(t+=u)&gt; and std::enable_if_t&lt;!std::is_assignable_v&lt;T,U&gt;, decltype(operator+(u,t))&gt;.
a and/or b can be made const in this test without breaking it.