diff --git a/include/boost/safe_numbers/detail/signed_integer_basis.hpp b/include/boost/safe_numbers/detail/signed_integer_basis.hpp
index e985d08..e24cb63 100644
--- a/include/boost/safe_numbers/detail/signed_integer_basis.hpp
+++ b/include/boost/safe_numbers/detail/signed_integer_basis.hpp
@@ -66,6 +66,9 @@ class signed_integer_basis
 
     template <fundamental_signed_integral OtherBasis>
     constexpr auto operator+=(signed_integer_basis<OtherBasis> rhs) -> signed_integer_basis&;
+
+    template <fundamental_signed_integral OtherBasis>
+    constexpr auto operator-=(signed_integer_basis<OtherBasis> rhs) -> signed_integer_basis&;
 };
 
 // Helper for diagnostic messages
@@ -772,6 +775,353 @@ constexpr auto signed_integer_basis<BasisType>::operator+=(const signed_integer_
     return *this;
 }
 
+// ------------------------------
+// Subtraction
+// ------------------------------
+
+namespace impl {
+
+template <fundamental_signed_integral BasisType>
+constexpr auto signed_overflow_sub_msg() noexcept -> const char*
+{
+    if constexpr (std::is_same_v<BasisType, std::int8_t>)
+    {
+        return "Overflow detected in i8 subtraction";
+    }
+    else if constexpr (std::is_same_v<BasisType, std::int16_t>)
+    {
+        return "Overflow detected in i16 subtraction";
+    }
+    else if constexpr (std::is_same_v<BasisType, std::int32_t>)
+    {
+        return "Overflow detected in i32 subtraction";
+    }
+    else if constexpr (std::is_same_v<BasisType, std::int64_t>)
+    {
+        return "Overflow detected in i64 subtraction";
+    }
+    else
+    {
+        return "Overflow detected in i128 subtraction";
+    }
+}
+
+template <fundamental_signed_integral BasisType>
+constexpr auto signed_underflow_sub_msg() noexcept -> const char*
+{
+    if constexpr (std::is_same_v<BasisType, std::int8_t>)
+    {
+        return "Underflow detected in i8 subtraction";
+    }
+    else if constexpr (std::is_same_v<BasisType, std::int16_t>)
+    {
+        return "Underflow detected in i16 subtraction";
+    }
+    else if constexpr (std::is_same_v<BasisType, std::int32_t>)
+    {
+        return "Underflow detected in i32 subtraction";
+    }
+    else if constexpr (std::is_same_v<BasisType, std::int64_t>)
+    {
+        return "Underflow detected in i64 subtraction";
+    }
+    else
+    {
+        return "Underflow detected in i128 subtraction";
+    }
+}
+
+#if BOOST_SAFE_NUMBERS_HAS_BUILTIN(__builtin_sub_overflow)
+
+template <std::signed_integral T>
+auto signed_intrin_sub(const T lhs, const T rhs, T& result) -> signed_overflow_status
+{
+    if (__builtin_sub_overflow(lhs, rhs, &result))
+    {
+        return classify_signed_overflow(lhs);
+    }
+
+    return signed_overflow_status::no_error;
+}
+
+#elif defined(BOOST_SAFENUMBERS_HAS_WINDOWS_X64_INTRIN) || defined(BOOST_SAFENUMBERS_HAS_WINDOWS_X86_INTRIN)
+
+template <std::signed_integral T>
+auto signed_intrin_sub(const T lhs, const T rhs, T& result) -> signed_overflow_status
+{
+    using unsigned_t = std::make_unsigned_t<T>;
+
+    unsigned_t temp {};
+
+    if constexpr (std::is_same_v<T, std::int8_t>)
+    {
+        _subborrow_u8(0, static_cast<std::uint8_t>(lhs), static_cast<std::uint8_t>(rhs), &temp);
+    }
+    else if constexpr (std::is_same_v<T, std::int16_t>)
+    {
+        _subborrow_u16(0, static_cast<std::uint16_t>(lhs), static_cast<std::uint16_t>(rhs), &temp);
+    }
+    else if constexpr (std::is_same_v<T, std::int32_t>)
+    {
+        _subborrow_u32(0, static_cast<std::uint32_t>(lhs), static_cast<std::uint32_t>(rhs), &temp);
+    }
+    #if defined(BOOST_SAFENUMBERS_HAS_WINDOWS_X86_INTRIN)
+    else if constexpr (std::is_same_v<T, std::int64_t>)
+    {
+        // x86 does not provide the _subborrow_u64 intrinsic
+        temp = static_cast<std::uint64_t>(lhs) - static_cast<std::uint64_t>(rhs);
+    }
+    #else
+    else if constexpr (std::is_same_v<T, std::int64_t>)
+    {
+        _subborrow_u64(0, static_cast<std::uint64_t>(lhs), static_cast<std::uint64_t>(rhs), &temp);
+    }
+    #endif
+
+    result = static_cast<T>(temp);
+
+    // Signed subtraction overflow: operands have different signs and result sign differs from lhs
+    const auto ulhs {static_cast<unsigned_t>(lhs)};
+    const auto urhs {static_cast<unsigned_t>(rhs)};
+    const auto has_overflow {static_cast<bool>(((ulhs ^ urhs) & (ulhs ^ temp)) >> std::numeric_limits<T>::digits)};
+
+    if (has_overflow)
+    {
+        return classify_signed_overflow(lhs);
+    }
+
+    return signed_overflow_status::no_error;
+}
+
+#endif
+
+template <fundamental_signed_integral T>
+constexpr auto signed_no_intrin_sub(const T lhs, const T rhs, T& result) noexcept -> signed_overflow_status
+{
+    using unsigned_t = make_unsigned_helper_t<T>;
+    unsigned_t temp {};
+
+    if constexpr (std::is_same_v<T, std::int8_t> || std::is_same_v<T, std::int16_t>)
+    {
+        temp = static_cast<unsigned_t>(static_cast<std::uint32_t>(lhs) - static_cast<std::uint32_t>(rhs));
+    }
+    else
+    {
+        temp = static_cast<unsigned_t>(lhs) - static_cast<unsigned_t>(rhs);
+    }
+
+    result = static_cast<T>(temp);
+
+    // Signed subtraction overflow: operands have different signs and result sign differs from lhs
+    const auto ulhs {static_cast<unsigned_t>(lhs)};
+    const auto urhs {static_cast<unsigned_t>(rhs)};
+    const auto has_overflow {static_cast<bool>(((ulhs ^ urhs) & (ulhs ^ temp)) >> std::numeric_limits<T>::digits)};
+
+    if (has_overflow)
+    {
+        return classify_signed_overflow(lhs);
+    }
+
+    return signed_overflow_status::no_error;
+}
+
+template <overflow_policy Policy, fundamental_signed_integral BasisType>
+struct signed_sub_helper
+{
+    [[nodiscard]] static constexpr auto apply(const signed_integer_basis<BasisType> lhs,
+                                              const signed_integer_basis<BasisType> rhs)
+        noexcept(Policy != overflow_policy::throw_exception)
+        -> signed_integer_basis<BasisType>
+    {
+        using result_type = signed_integer_basis<BasisType>;
+
+        const auto lhs_basis {static_cast<BasisType>(lhs)};
+        const auto rhs_basis {static_cast<BasisType>(rhs)};
+        BasisType result {};
+
+        auto handle_error = [&result](signed_overflow_status status)
+        {
+            if (std::is_constant_evaluated())
+            {
+                if (status == signed_overflow_status::overflow)
+                {
+                    if constexpr (std::is_same_v<BasisType, std::int8_t>)
+                    {
+                        throw std::overflow_error("Overflow detected in i8 subtraction");
+                    }
+                    else if constexpr (std::is_same_v<BasisType, std::int16_t>)
+                    {
+                        throw std::overflow_error("Overflow detected in i16 subtraction");
+                    }
+                    else if constexpr (std::is_same_v<BasisType, std::int32_t>)
+                    {
+                        throw std::overflow_error("Overflow detected in i32 subtraction");
+                    }
+                    else if constexpr (std::is_same_v<BasisType, std::int64_t>)
+                    {
+                        throw std::overflow_error("Overflow detected in i64 subtraction");
+                    }
+                    else
+                    {
+                        throw std::overflow_error("Overflow detected in i128 subtraction");
+                    }
+                }
+                else
+                {
+                    if constexpr (std::is_same_v<BasisType, std::int8_t>)
+                    {
+                        throw std::underflow_error("Underflow detected in i8 subtraction");
+                    }
+                    else if constexpr (std::is_same_v<BasisType, std::int16_t>)
+                    {
+                        throw std::underflow_error("Underflow detected in i16 subtraction");
+                    }
+                    else if constexpr (std::is_same_v<BasisType, std::int32_t>)
+                    {
+                        throw std::underflow_error("Underflow detected in i32 subtraction");
+                    }
+                    else if constexpr (std::is_same_v<BasisType, std::int64_t>)
+                    {
+                        throw std::underflow_error("Underflow detected in i64 subtraction");
+                    }
+                    else
+                    {
+                        throw std::underflow_error("Underflow detected in i128 subtraction");
+                    }
+                }
+            }
+            else
+            {
+                if constexpr (Policy == overflow_policy::throw_exception)
+                {
+                    static_cast<void>(result);
+
+                    if (status == signed_overflow_status::overflow)
+                    {
+                        BOOST_SAFE_NUMBERS_THROW_EXCEPTION(std::overflow_error, signed_overflow_sub_msg<BasisType>());
+                    }
+                    else
+                    {
+                        BOOST_SAFE_NUMBERS_THROW_EXCEPTION(std::underflow_error, signed_underflow_sub_msg<BasisType>());
+                    }
+                }
+                else
+                {
+                    static_cast<void>(result);
+                    BOOST_SAFE_NUMBERS_UNREACHABLE;
+                }
+            }
+        };
+
+        #if BOOST_SAFE_NUMBERS_HAS_BUILTIN(__builtin_sub_overflow) || defined(BOOST_SAFENUMBERS_HAS_WINDOWS_X64_INTRIN) || defined(BOOST_SAFENUMBERS_HAS_WINDOWS_X86_INTRIN)
+
+        if constexpr (!std::is_same_v<BasisType, int128::int128_t>)
+        {
+            if (!std::is_constant_evaluated())
+            {
+                const auto status {impl::signed_intrin_sub(lhs_basis, rhs_basis, result)};
+                if (status != signed_overflow_status::no_error)
+                {
+                    handle_error(status);
+                }
+
+                return result_type{result};
+            }
+        }
+
+        #endif // BOOST_SAFE_NUMBERS_HAS_BUILTIN(__builtin_sub_overflow) || defined(BOOST_SAFENUMBERS_HAS_WINDOWS_X64_INTRIN) || defined(BOOST_SAFENUMBERS_HAS_WINDOWS_X86_INTRIN)
+
+        const auto status {impl::signed_no_intrin_sub(lhs_basis, rhs_basis, result)};
+        if (status != signed_overflow_status::no_error)
+        {
+            handle_error(status);
+        }
+
+        return result_type{result};
+    }
+};
+
+template <overflow_policy Policy, fundamental_signed_integral BasisType>
+[[nodiscard]] constexpr auto sub_impl(const signed_integer_basis<BasisType> lhs,
+                                      const signed_integer_basis<BasisType> rhs)
+{
+    return signed_sub_helper<Policy, BasisType>::apply(lhs, rhs);
+}
+
+} // namespace impl
+
+template <fundamental_signed_integral BasisType>
+[[nodiscard]] constexpr auto operator-(const signed_integer_basis<BasisType> lhs,
+                                       const signed_integer_basis<BasisType> rhs) -> signed_integer_basis<BasisType>
+{
+    if (std::is_constant_evaluated())
+    {
+        BasisType res {};
+        const auto status {impl::signed_no_intrin_sub(static_cast<BasisType>(lhs), static_cast<BasisType>(rhs), res)};
+        if (status == impl::signed_overflow_status::overflow)
+        {
+            if constexpr (std::is_same_v<BasisType, std::int8_t>)
+            {
+                throw std::overflow_error("Overflow detected in i8 subtraction");
+            }
+            else if constexpr (std::is_same_v<BasisType, std::int16_t>)
+            {
+                throw std::overflow_error("Overflow detected in i16 subtraction");
+            }
+            else if constexpr (std::is_same_v<BasisType, std::int32_t>)
+            {
+                throw std::overflow_error("Overflow detected in i32 subtraction");
+            }
+            else if constexpr (std::is_same_v<BasisType, std::int64_t>)
+            {
+                throw std::overflow_error("Overflow detected in i64 subtraction");
+            }
+            else
+            {
+                throw std::overflow_error("Overflow detected in i128 subtraction");
+            }
+        }
+        else if (status == impl::signed_overflow_status::underflow)
+        {
+            if constexpr (std::is_same_v<BasisType, std::int8_t>)
+            {
+                throw std::underflow_error("Underflow detected in i8 subtraction");
+            }
+            else if constexpr (std::is_same_v<BasisType, std::int16_t>)
+            {
+                throw std::underflow_error("Underflow detected in i16 subtraction");
+            }
+            else if constexpr (std::is_same_v<BasisType, std::int32_t>)
+            {
+                throw std::underflow_error("Underflow detected in i32 subtraction");
+            }
+            else if constexpr (std::is_same_v<BasisType, std::int64_t>)
+            {
+                throw std::underflow_error("Underflow detected in i64 subtraction");
+            }
+            else
+            {
+                throw std::underflow_error("Underflow detected in i128 subtraction");
+            }
+        }
+
+        return signed_integer_basis<BasisType>{res};
+    }
+
+    return impl::signed_sub_helper<overflow_policy::throw_exception, BasisType>::apply(lhs, rhs);
+}
+
+BOOST_SAFE_NUMBERS_DEFINE_MIXED_SIGNED_INTEGER_OP("subtraction", operator-)
+
+template <fundamental_signed_integral BasisType>
+template <fundamental_signed_integral OtherBasisType>
+constexpr auto signed_integer_basis<BasisType>::operator-=(const signed_integer_basis<OtherBasisType> rhs)
+    -> signed_integer_basis&
+{
+    *this = *this - rhs;
+    return *this;
+}
+
 } // namespace boost::safe_numbers::detail
 
 #undef BOOST_SAFE_NUMBERS_DEFINE_MIXED_SIGNED_INTEGER_OP
diff --git a/test/Jamfile b/test/Jamfile
index 0a25788..e9b9f33 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -57,6 +57,7 @@ run test_signed_conversions.cpp ;
 run test_signed_comparisons.cpp ;
 run test_signed_unary_operators.cpp ;
 run test_signed_addition.cpp ;
+run test_signed_subtraction.cpp ;
 
 run test_unsigned_addition.cpp ;
 compile-fail compile_fail_unsigned_addition.cpp ;
diff --git a/test/test_signed_subtraction.cpp b/test/test_signed_subtraction.cpp
new file mode 100644
index 0000000..6ec1207
--- /dev/null
+++ b/test/test_signed_subtraction.cpp
@@ -0,0 +1,354 @@
+// Copyright 2026 Matt Borland
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/lightweight_test.hpp>
+
+#if defined(__clang__)
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#  pragma clang diagnostic ignored "-Wundef"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wsign-conversion"
+#  pragma clang diagnostic ignored "-Wfloat-equal"
+#  pragma clang diagnostic ignored "-Wsign-compare"
+#  pragma clang diagnostic ignored "-Woverflow"
+
+#  if (__clang_major__ >= 10 && !defined(__APPLE__)) || __clang_major__ >= 13
+#    pragma clang diagnostic ignored "-Wdeprecated-copy"
+#  endif
+
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wundef"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wsign-conversion"
+#  pragma GCC diagnostic ignored "-Wsign-compare"
+#  pragma GCC diagnostic ignored "-Wfloat-equal"
+#  pragma GCC diagnostic ignored "-Woverflow"
+
+#elif defined(_MSC_VER)
+#  pragma warning(push)
+#  pragma warning(disable : 4389)
+#  pragma warning(disable : 4127)
+#  pragma warning(disable : 4305)
+#  pragma warning(disable : 4309)
+#endif
+
+#define BOOST_SAFE_NUMBERS_DETAIL_INT128_ALLOW_SIGN_COMPARE
+#define BOOST_SAFE_NUMBERS_DETAIL_INT128_ALLOW_SIGN_CONVERSION
+
+#include <boost/random/uniform_int_distribution.hpp>
+
+#ifdef __clang__
+#  pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic pop
+#elif defined(_MSC_VER)
+#  pragma warning(pop)
+#endif
+
+// Ignore [[nodiscard]] on the tests that we know are going to throw
+#ifdef __clang__
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wunused-result"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wunused-result"
+#elif defined(_MSC_VER)
+#  pragma warning (push)
+#  pragma warning (disable: 4834)
+#endif
+
+#ifdef BOOST_SAFE_NUMBERS_BUILD_MODULE
+
+import boost.safe_numbers;
+
+#else
+
+#include <boost/safe_numbers.hpp>
+#include <random>
+#include <limits>
+#include <type_traits>
+
+#endif
+
+using namespace boost::safe_numbers;
+
+inline std::mt19937_64 rng{42};
+inline constexpr std::size_t N {1024};
+
+// -----------------------------------------------
+// Valid subtraction: values in the safe half-range
+// -----------------------------------------------
+
+template <typename T>
+void test_valid_subtraction()
+{
+    using basis_type = detail::underlying_type_t<T>;
+
+    // Use quarter-range to ensure no overflow when subtracting two values
+    boost::random::uniform_int_distribution<basis_type> dist {static_cast<basis_type>(std::numeric_limits<basis_type>::min() / 2),
+                                                              static_cast<basis_type>(std::numeric_limits<basis_type>::max() / 2)};
+
+    for (std::size_t i {0}; i < N; ++i)
+    {
+        const auto lhs_value {dist(rng)};
+        const auto rhs_value {dist(rng)};
+
+        // For int8_t/int16_t, promotion to int means no overflow in the builtin subtraction
+        T ref_value {};
+        if constexpr (std::is_same_v<basis_type, std::int8_t> || std::is_same_v<basis_type, std::int16_t>)
+        {
+            ref_value = T{static_cast<basis_type>(static_cast<std::int32_t>(lhs_value) - static_cast<std::int32_t>(rhs_value))};
+        }
+        else
+        {
+            ref_value = T{static_cast<basis_type>(lhs_value - rhs_value)};
+        }
+
+        const T lhs {lhs_value};
+        const T rhs {rhs_value};
+        const auto res {lhs - rhs};
+
+        BOOST_TEST(ref_value == res);
+    }
+}
+
+// -----------------------------------------------
+// Positive overflow: positive - negative near min
+// e.g. near_max - (-2) overflows
+// -----------------------------------------------
+
+template <typename T>
+void test_positive_overflow()
+{
+    using basis_type = detail::underlying_type_t<T>;
+    boost::random::uniform_int_distribution<basis_type> dist {std::numeric_limits<basis_type>::min(),
+                                                              basis_type{-2}};
+
+    for (std::size_t i {0}; i < N; ++i)
+    {
+        constexpr auto lhs_value {static_cast<basis_type>(std::numeric_limits<basis_type>::max() - 1)};
+        const auto rhs_value {dist(rng)};
+
+        const T lhs {lhs_value};
+        const T rhs {rhs_value};
+
+        BOOST_TEST_THROWS(lhs - rhs, std::overflow_error);
+    }
+}
+
+// -----------------------------------------------
+// Negative overflow (underflow): negative - positive
+// e.g. near_min - 2 underflows
+// -----------------------------------------------
+
+template <typename T>
+void test_negative_overflow()
+{
+    using basis_type = detail::underlying_type_t<T>;
+    boost::random::uniform_int_distribution<basis_type> dist {basis_type{2},
+                                                              std::numeric_limits<basis_type>::max()};
+
+    for (std::size_t i {0}; i < N; ++i)
+    {
+        constexpr auto lhs_value {static_cast<basis_type>(std::numeric_limits<basis_type>::min() + 1)};
+        const auto rhs_value {dist(rng)};
+
+        const T lhs {lhs_value};
+        const T rhs {rhs_value};
+
+        BOOST_TEST_THROWS(lhs - rhs, std::underflow_error);
+    }
+}
+
+// -----------------------------------------------
+// Same-sign subtraction: should never overflow
+// Positive - positive and negative - negative can never exceed the range
+// -----------------------------------------------
+
+template <typename T>
+void test_same_sign_subtraction()
+{
+    using basis_type = detail::underlying_type_t<T>;
+    boost::random::uniform_int_distribution<basis_type> pos_dist {basis_type{0},
+                                                                   std::numeric_limits<basis_type>::max()};
+    boost::random::uniform_int_distribution<basis_type> neg_dist {std::numeric_limits<basis_type>::min(),
+                                                                   basis_type{-1}};
+
+    for (std::size_t i {0}; i < N; ++i)
+    {
+        // positive - positive
+        {
+            const auto lhs_value {pos_dist(rng)};
+            const auto rhs_value {pos_dist(rng)};
+
+            const T lhs {lhs_value};
+            const T rhs {rhs_value};
+
+            const auto res {lhs - rhs};
+
+            T expected {};
+            if constexpr (std::is_same_v<basis_type, std::int8_t> || std::is_same_v<basis_type, std::int16_t>)
+            {
+                expected = T{static_cast<basis_type>(static_cast<std::int32_t>(lhs_value) - static_cast<std::int32_t>(rhs_value))};
+            }
+            else
+            {
+                expected = T{static_cast<basis_type>(lhs_value - rhs_value)};
+            }
+
+            BOOST_TEST(res == expected);
+        }
+
+        // negative - negative
+        {
+            const auto lhs_value {neg_dist(rng)};
+            const auto rhs_value {neg_dist(rng)};
+
+            const T lhs {lhs_value};
+            const T rhs {rhs_value};
+
+            const auto res {lhs - rhs};
+
+            T expected {};
+            if constexpr (std::is_same_v<basis_type, std::int8_t> || std::is_same_v<basis_type, std::int16_t>)
+            {
+                expected = T{static_cast<basis_type>(static_cast<std::int32_t>(lhs_value) - static_cast<std::int32_t>(rhs_value))};
+            }
+            else
+            {
+                expected = T{static_cast<basis_type>(lhs_value - rhs_value)};
+            }
+
+            BOOST_TEST(res == expected);
+        }
+    }
+}
+
+// -----------------------------------------------
+// Compound assignment: operator-=
+// -----------------------------------------------
+
+template <typename T>
+void test_minus_equals()
+{
+    using basis_type = detail::underlying_type_t<T>;
+
+    // Use quarter-range to ensure no overflow
+    boost::random::uniform_int_distribution<basis_type> dist {static_cast<basis_type>(std::numeric_limits<basis_type>::min() / 2),
+                                                              static_cast<basis_type>(std::numeric_limits<basis_type>::max() / 2)};
+
+    for (std::size_t i {0}; i < N; ++i)
+    {
+        const auto lhs_value {dist(rng)};
+        const auto rhs_value {dist(rng)};
+
+        const T lhs {lhs_value};
+        const T rhs {rhs_value};
+
+        // operator- result for reference
+        const auto expected {lhs - rhs};
+
+        // operator-= should give the same result
+        T result {lhs_value};
+        result -= rhs;
+        BOOST_TEST(result == expected);
+    }
+
+    // -= with overflow should throw (positive - negative)
+    T near_max {static_cast<basis_type>(std::numeric_limits<basis_type>::max() - 1)};
+    BOOST_TEST_THROWS(near_max -= T{basis_type{-2}}, std::overflow_error);
+
+    // -= with underflow should throw (negative - positive)
+    T near_min {static_cast<basis_type>(std::numeric_limits<basis_type>::min() + 1)};
+    BOOST_TEST_THROWS(near_min -= T{basis_type{2}}, std::underflow_error);
+
+    // -= with zero is identity
+    T val {basis_type{42}};
+    val -= T{basis_type{0}};
+    BOOST_TEST(val == T{basis_type{42}});
+}
+
+// -----------------------------------------------
+// Specific boundary cases
+// -----------------------------------------------
+
+template <typename T>
+void test_boundary_cases()
+{
+    using basis_type = detail::underlying_type_t<T>;
+
+    // 0 - 0 = 0
+    BOOST_TEST(T{basis_type{0}} - T{basis_type{0}} == T{basis_type{0}});
+
+    // 1 - 1 = 0
+    BOOST_TEST(T{basis_type{1}} - T{basis_type{1}} == T{basis_type{0}});
+
+    // 0 - 1 = -1
+    BOOST_TEST(T{basis_type{0}} - T{basis_type{1}} == T{basis_type{-1}});
+
+    // max - 0 = max
+    BOOST_TEST(T{std::numeric_limits<basis_type>::max()} - T{basis_type{0}} == T{std::numeric_limits<basis_type>::max()});
+
+    // min - 0 = min
+    BOOST_TEST(T{std::numeric_limits<basis_type>::min()} - T{basis_type{0}} == T{std::numeric_limits<basis_type>::min()});
+
+    // max - max = 0
+    BOOST_TEST(T{std::numeric_limits<basis_type>::max()} - T{std::numeric_limits<basis_type>::max()} == T{basis_type{0}});
+
+    // min - min = 0
+    BOOST_TEST(T{std::numeric_limits<basis_type>::min()} - T{std::numeric_limits<basis_type>::min()} == T{basis_type{0}});
+
+    // max - (-1) overflows
+    BOOST_TEST_THROWS(T{std::numeric_limits<basis_type>::max()} - T{basis_type{-1}}, std::overflow_error);
+
+    // min - 1 underflows
+    BOOST_TEST_THROWS(T{std::numeric_limits<basis_type>::min()} - T{basis_type{1}}, std::underflow_error);
+
+    // 0 - min overflows (since -min > max for two's complement)
+    BOOST_TEST_THROWS(T{basis_type{0}} - T{std::numeric_limits<basis_type>::min()}, std::overflow_error);
+}
+
+int main()
+{
+    test_valid_subtraction<i8>();
+    test_valid_subtraction<i16>();
+    test_valid_subtraction<i32>();
+    test_valid_subtraction<i64>();
+    test_valid_subtraction<i128>();
+
+    test_positive_overflow<i8>();
+    test_positive_overflow<i16>();
+    test_positive_overflow<i32>();
+    test_positive_overflow<i64>();
+    test_positive_overflow<i128>();
+
+    test_negative_overflow<i8>();
+    test_negative_overflow<i16>();
+    test_negative_overflow<i32>();
+    test_negative_overflow<i64>();
+    test_negative_overflow<i128>();
+
+    test_same_sign_subtraction<i8>();
+    test_same_sign_subtraction<i16>();
+    test_same_sign_subtraction<i32>();
+    test_same_sign_subtraction<i64>();
+    test_same_sign_subtraction<i128>();
+
+    test_minus_equals<i8>();
+    test_minus_equals<i16>();
+    test_minus_equals<i32>();
+    test_minus_equals<i64>();
+    test_minus_equals<i128>();
+
+    test_boundary_cases<i8>();
+    test_boundary_cases<i16>();
+    test_boundary_cases<i32>();
+    test_boundary_cases<i64>();
+    test_boundary_cases<i128>();
+
+    return boost::report_errors();
+}