diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi
index 04feafba..5db811b6 100644
--- a/pandas-stubs/core/series.pyi
+++ b/pandas-stubs/core/series.pyi
@@ -2055,7 +2055,6 @@ class Series(IndexOpsMixin[S1], NDFrame):
     ) -> Series[bool]: ...
     @overload
     def __ror__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ...
-    def __rsub__(self, other: num | _ListLike | Series[S1]) -> Series: ...
     # ignore needed for mypy as we want different results based on the arguments
     @overload  # type: ignore[override]
     def __rxor__(  # pyright: ignore[reportOverlappingOverload]
@@ -2064,6 +2063,74 @@ class Series(IndexOpsMixin[S1], NDFrame):
     @overload
     def __rxor__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ...
     @overload
+    def __sub__(
+        self, other: Timestamp | datetime | TimestampSeries
+    ) -> TimedeltaSeries: ...
+    @overload
+    def __sub__(self: Series[Never], other: complex | _ListLike | Series) -> Series: ...
+    @overload
+    def __sub__(self, other: Series[Never]) -> Series: ...  # type: ignore[overload-overlap]
+    @overload
+    def __sub__(self: Series[bool], other: bool | Sequence[bool]) -> Never: ...
+    @overload
+    def __sub__(
+        self: Series[bool], other: _T_COMPLEX | Sequence[_T_COMPLEX]
+    ) -> Series[_T_COMPLEX]: ...
+    @overload
+    def __sub__(
+        self: Series[bool], other: np_ndarray_anyint | Series[int]
+    ) -> Series[int]: ...
+    @overload
+    def __sub__(
+        self: Series[bool], other: np_ndarray_float | Series[float]
+    ) -> Series[float]: ...
+    @overload
+    def __sub__(
+        self: Series[int],
+        other: (
+            bool | Sequence[bool] | np_ndarray_bool | np_ndarray_anyint | Series[bool]
+        ),
+    ) -> Series[int]: ...
+    @overload
+    def __sub__(
+        self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX]
+    ) -> Series[_T_COMPLEX]: ...
+    @overload
+    def __sub__(self: Series[int], other: np_ndarray_float) -> Series[float]: ...
+    @overload
+    def __sub__(
+        self: Series[float],
+        other: (
+            int
+            | Sequence[int]
+            | np_ndarray_bool
+            | np_ndarray_anyint
+            | np_ndarray_float
+            | Series[_T_INT]
+        ),
+    ) -> Series[float]: ...
+    @overload
+    def __sub__(
+        self: Series[float],
+        other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX],
+    ) -> Series[_T_COMPLEX]: ...
+    @overload
+    def __sub__(
+        self: Series[complex],
+        other: (
+            _T_COMPLEX
+            | Sequence[_T_COMPLEX]
+            | np_ndarray_bool
+            | np_ndarray_anyint
+            | np_ndarray_float
+            | Series[_T_COMPLEX]
+        ),
+    ) -> Series[complex]: ...
+    @overload
+    def __sub__(
+        self: Series[_T_COMPLEX], other: np_ndarray_complex | Series[complex]
+    ) -> Series[complex]: ...
+    @overload
     def __sub__(
         self: Series[Timestamp],
         other: Timedelta | TimedeltaSeries | TimedeltaIndex | np.timedelta64,
@@ -2074,11 +2141,293 @@ class Series(IndexOpsMixin[S1], NDFrame):
         other: Timedelta | TimedeltaSeries | TimedeltaIndex | np.timedelta64,
     ) -> TimedeltaSeries: ...
     @overload
-    def __sub__(
-        self, other: Timestamp | datetime | TimestampSeries
-    ) -> TimedeltaSeries: ...
+    def sub(
+        self: Series[Never],
+        other: complex | _ListLike | Series,
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series: ...
+    @overload
+    def sub(
+        self: Series[bool],
+        other: bool | Sequence[bool],
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Never: ...
+    @overload
+    def sub(
+        self: Series[bool],
+        other: _T_COMPLEX | Sequence[_T_COMPLEX],
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[_T_COMPLEX]: ...
+    @overload
+    def sub(
+        self: Series[bool],
+        other: np_ndarray_anyint | Series[int],
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[int]: ...
+    @overload
+    def sub(
+        self: Series[bool],
+        other: np_ndarray_float | Series[float],
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[float]: ...
+    @overload
+    def sub(
+        self: Series[int],
+        other: (
+            bool | Sequence[bool] | np_ndarray_bool | np_ndarray_anyint | Series[bool]
+        ),
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[int]: ...
+    @overload
+    def sub(
+        self: Series[int],
+        other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX],
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[_T_COMPLEX]: ...
+    @overload
+    def sub(
+        self: Series[_T_INT],
+        other: np_ndarray_float,
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[float]: ...
+    @overload
+    def sub(
+        self: Series[float],
+        other: (
+            int
+            | Sequence[int]
+            | np_ndarray_bool
+            | np_ndarray_anyint
+            | np_ndarray_float
+            | Series[_T_INT]
+        ),
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[float]: ...
+    @overload
+    def sub(
+        self: Series[float],
+        other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX],
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[_T_COMPLEX]: ...
+    @overload
+    def sub(
+        self: Series[complex],
+        other: (
+            _T_COMPLEX
+            | Sequence[_T_COMPLEX]
+            | np_ndarray_bool
+            | np_ndarray_anyint
+            | np_ndarray_float
+            | Series[_T_COMPLEX]
+        ),
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[complex]: ...
+    @overload
+    def sub(
+        self: Series[_T_COMPLEX],
+        other: np_ndarray_complex | Series[complex],
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[complex]: ...
+    @overload
+    def __rsub__(
+        self: Series[Never], other: complex | _ListLike | Series
+    ) -> Series: ...
+    @overload
+    def __rsub__(self, other: Series[Never]) -> Series: ...
+    @overload
+    def __rsub__(self: Series[bool], other: bool | Sequence[bool]) -> Never: ...
+    @overload
+    def __rsub__(
+        self: Series[bool], other: _T_COMPLEX | Sequence[_T_COMPLEX]
+    ) -> Series[_T_COMPLEX]: ...
+    @overload
+    def __rsub__(
+        self: Series[bool], other: np_ndarray_anyint | Series[int]
+    ) -> Series[int]: ...
+    @overload
+    def __rsub__(
+        self: Series[bool], other: np_ndarray_float | Series[float]
+    ) -> Series[float]: ...
+    @overload
+    def __rsub__(
+        self: Series[int],
+        other: bool | Sequence[bool] | np_ndarray_bool | np_ndarray_anyint,
+    ) -> Series[int]: ...
+    @overload
+    def __rsub__(
+        self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX]
+    ) -> Series[_T_COMPLEX]: ...
+    @overload
+    def __rsub__(self: Series[_T_INT], other: np_ndarray_float) -> Series[float]: ...
+    @overload
+    def __rsub__(
+        self: Series[float],
+        other: (
+            int
+            | Sequence[int]
+            | np_ndarray_bool
+            | np_ndarray_anyint
+            | np_ndarray_float
+            | Series[_T_INT]
+        ),
+    ) -> Series[float]: ...
+    @overload
+    def __rsub__(
+        self: Series[float],
+        other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX],
+    ) -> Series[_T_COMPLEX]: ...
+    @overload
+    def __rsub__(
+        self: Series[complex],
+        other: (
+            _T_COMPLEX
+            | Sequence[_T_COMPLEX]
+            | np_ndarray_bool
+            | np_ndarray_anyint
+            | np_ndarray_float
+            | Series[_T_COMPLEX]
+        ),
+    ) -> Series[complex]: ...
+    @overload
+    def __rsub__(
+        self: Series[_T_COMPLEX], other: np_ndarray_complex | Series[complex]
+    ) -> Series[complex]: ...
+    @overload
+    def rsub(
+        self: Series[Never],
+        other: complex | _ListLike | Series,
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series: ...
+    @overload
+    def rsub(
+        self: Series[bool],
+        other: bool | Sequence[bool],
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Never: ...
+    @overload
+    def rsub(
+        self: Series[bool],
+        other: _T_COMPLEX | Sequence[_T_COMPLEX],
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[_T_COMPLEX]: ...
+    @overload
+    def rsub(
+        self: Series[bool],
+        other: np_ndarray_anyint | Series[int],
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[int]: ...
+    @overload
+    def rsub(
+        self: Series[bool],
+        other: np_ndarray_float | Series[float],
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[float]: ...
+    @overload
+    def rsub(
+        self: Series[int],
+        other: (
+            bool | Sequence[bool] | np_ndarray_bool | np_ndarray_anyint | Series[bool]
+        ),
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[int]: ...
+    @overload
+    def rsub(
+        self: Series[int],
+        other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX],
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[_T_COMPLEX]: ...
     @overload
-    def __sub__(self, other: num | _ListLike | Series) -> Series: ...
+    def rsub(
+        self: Series[_T_INT],
+        other: np_ndarray_float,
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[float]: ...
+    @overload
+    def rsub(
+        self: Series[float],
+        other: (
+            int
+            | Sequence[int]
+            | np_ndarray_bool
+            | np_ndarray_anyint
+            | np_ndarray_float
+            | Series[_T_INT]
+        ),
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[float]: ...
+    @overload
+    def rsub(
+        self: Series[float],
+        other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX],
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[_T_COMPLEX]: ...
+    @overload
+    def rsub(
+        self: Series[complex],
+        other: (
+            _T_COMPLEX
+            | Sequence[_T_COMPLEX]
+            | np_ndarray_bool
+            | np_ndarray_anyint
+            | np_ndarray_float
+            | Series[_T_COMPLEX]
+        ),
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[complex]: ...
+    @overload
+    def rsub(
+        self: Series[_T_COMPLEX],
+        other: np_ndarray_complex | Series[complex],
+        level: Level | None = None,
+        fill_value: float | None = None,
+        axis: int = 0,
+    ) -> Series[complex]: ...
     @overload
     def __truediv__(
         self: Series[Never], other: complex | _ListLike | Series
@@ -2804,13 +3153,6 @@ class Series(IndexOpsMixin[S1], NDFrame):
         fill_value: float | None = None,
         axis: AxisIndex = ...,
     ) -> Series[S1]: ...
-    def rsub(
-        self,
-        other: Series[S1] | Scalar,
-        level: Level | None = ...,
-        fill_value: float | None = None,
-        axis: AxisIndex = ...,
-    ) -> Series[S1]: ...
     def sem(
         self,
         axis: AxisIndex | None = 0,
@@ -2834,20 +3176,6 @@ class Series(IndexOpsMixin[S1], NDFrame):
         numeric_only: _bool = False,
         **kwargs: Any,
     ) -> float: ...
-    def sub(
-        self,
-        other: num | _ListLike | Series[S1],
-        level: Level | None = ...,
-        fill_value: float | None = None,
-        axis: AxisIndex | None = 0,
-    ) -> Series[S1]: ...
-    def subtract(
-        self,
-        other: num | _ListLike | Series[S1],
-        level: Level | None = ...,
-        fill_value: float | None = None,
-        axis: AxisIndex | None = 0,
-    ) -> Series[S1]: ...
     @overload
     def sum(
         self: Series[Never],
@@ -2955,7 +3283,7 @@ class TimestampSeries(Series[Timestamp]):
         self, other: Timestamp | datetime | TimestampSeries
     ) -> TimedeltaSeries: ...
     @overload
-    def __sub__(  # pyright: ignore[reportIncompatibleMethodOverride]
+    def __sub__(
         self,
         other: (
             timedelta | TimedeltaSeries | TimedeltaIndex | np.timedelta64 | BaseOffset
diff --git a/tests/series/arithmetic/bool/test_sub.py b/tests/series/arithmetic/bool/test_sub.py
new file mode 100644
index 00000000..a0813ed1
--- /dev/null
+++ b/tests/series/arithmetic/bool/test_sub.py
@@ -0,0 +1,151 @@
+import numpy as np
+from numpy import typing as npt  # noqa: F401
+import pandas as pd
+from typing_extensions import (
+    Never,
+    assert_type,
+)
+
+from tests import (
+    TYPE_CHECKING_INVALID_USAGE,
+    check,
+)
+
+left = pd.Series([True, True, False])  # left operand
+
+
+def test_sub_py_scalar() -> None:
+    """Test pd.Series[bool] - Python native scalars"""
+    b, i, f, c = True, 1, 1.0, 1j
+
+    if TYPE_CHECKING_INVALID_USAGE:
+        assert_type(left - b, Never)
+    check(assert_type(left - i, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left - f, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    if TYPE_CHECKING_INVALID_USAGE:
+        assert_type(b - left, Never)
+    check(assert_type(i - left, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(f - left, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(c - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    if TYPE_CHECKING_INVALID_USAGE:
+        assert_type(left.sub(b), Never)
+    check(assert_type(left.sub(i), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.sub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(c), "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    if TYPE_CHECKING_INVALID_USAGE:
+        assert_type(left.rsub(b), Never)
+    check(assert_type(left.rsub(i), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.rsub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(
+        assert_type(left.rsub(c), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+
+
+def test_sub_py_sequence() -> None:
+    """Test pd.Series[bool] - Python native sequence"""
+    b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j]
+
+    if TYPE_CHECKING_INVALID_USAGE:
+        assert_type(left - b, Never)
+    check(assert_type(left - i, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left - f, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    if TYPE_CHECKING_INVALID_USAGE:
+        assert_type(b - left, Never)
+    check(assert_type(i - left, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(f - left, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(c - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    if TYPE_CHECKING_INVALID_USAGE:
+        assert_type(left.sub(b), Never)
+    check(assert_type(left.sub(i), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.sub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(c), "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    if TYPE_CHECKING_INVALID_USAGE:
+        assert_type(left.rsub(b), Never)
+    check(assert_type(left.rsub(i), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.rsub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(
+        assert_type(left.rsub(c), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+
+
+def test_sub_numpy_array() -> None:
+    """Test pd.Series[bool] - numpy array"""
+    b = np.array([True, False, True], np.bool_)
+    i = np.array([2, 3, 5], np.int64)
+    f = np.array([1.0, 2.0, 3.0], np.float64)
+    c = np.array([1.1j, 2.2j, 4.1j], np.complex128)
+
+    if TYPE_CHECKING_INVALID_USAGE:
+        assert_type(left - b, Never)
+    check(assert_type(left - i, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left - f, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    # `numpy` typing gives the corresponding `ndarray`s in the static type
+    # checking, where our `__rsub__` cannot override. At runtime, they return
+    # `Series`s with the correct element type.
+    if TYPE_CHECKING_INVALID_USAGE:
+        assert_type(b - left, Never)
+    check(assert_type(i - left, "npt.NDArray[np.int64]"), pd.Series, np.integer)
+    check(assert_type(f - left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
+    check(
+        assert_type(c - left, "npt.NDArray[np.complex128]"),
+        pd.Series,
+        np.complexfloating,
+    )
+
+    if TYPE_CHECKING_INVALID_USAGE:
+        left.sub(b)  # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue]
+    check(assert_type(left.sub(i), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.sub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(c), "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    if TYPE_CHECKING_INVALID_USAGE:
+        left.rsub(b)  # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue]
+    check(assert_type(left.rsub(i), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.rsub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(
+        assert_type(left.rsub(c), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+
+
+def test_sub_pd_series() -> None:
+    """Test pd.Series[bool] - pandas series"""
+    b = pd.Series([True, False, True])
+    i = pd.Series([2, 3, 5])
+    f = pd.Series([1.0, 2.0, 3.0])
+    c = pd.Series([1.1j, 2.2j, 4.1j])
+
+    if TYPE_CHECKING_INVALID_USAGE:
+        _ = left - b  # pyright: ignore[reportOperatorIssue]
+    check(assert_type(left - i, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left - f, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    if TYPE_CHECKING_INVALID_USAGE:
+        _ = b - left  # pyright: ignore[reportOperatorIssue]
+    check(assert_type(i - left, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(f - left, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(c - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    if TYPE_CHECKING_INVALID_USAGE:
+        left.sub(b)  # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue]
+    check(assert_type(left.sub(i), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.sub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(c), "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    if TYPE_CHECKING_INVALID_USAGE:
+        left.rsub(b)  # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue]
+    check(assert_type(left.rsub(i), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.rsub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(
+        assert_type(left.rsub(c), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
diff --git a/tests/series/arithmetic/complex/test_sub.py b/tests/series/arithmetic/complex/test_sub.py
new file mode 100644
index 00000000..5a7cc0de
--- /dev/null
+++ b/tests/series/arithmetic/complex/test_sub.py
@@ -0,0 +1,157 @@
+from typing import NoReturn
+
+import numpy as np
+from numpy import typing as npt  # noqa: F401
+import pandas as pd
+from typing_extensions import assert_type
+
+from tests import check
+
+left = pd.Series([1j, 2j, 3j])  # left operand
+
+
+def test_sub_py_scalar() -> None:
+    """Test pd.Series[complex] - Python native scalars"""
+    b, i, f, c = True, 1, 1.0, 1j
+
+    check(assert_type(left - b, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left - i, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left - f, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(b - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(i - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(f - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(c - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.sub(b), "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left.sub(i), "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left.sub(f), "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left.sub(c), "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(
+        assert_type(left.rsub(b), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+    check(
+        assert_type(left.rsub(i), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+    check(
+        assert_type(left.rsub(f), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+    check(
+        assert_type(left.rsub(c), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+
+
+def test_sub_py_sequence() -> None:
+    """Test pd.Series[complex] - Python native sequence"""
+    b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j]
+
+    check(assert_type(left - b, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left - i, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left - f, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(b - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(i - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(f - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(c - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.sub(b), "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left.sub(i), "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left.sub(f), "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left.sub(c), "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(
+        assert_type(left.rsub(b), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+    check(
+        assert_type(left.rsub(i), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+    check(
+        assert_type(left.rsub(f), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+    check(
+        assert_type(left.rsub(c), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+
+
+def test_sub_numpy_array() -> None:
+    """Test pd.Series[complex] - numpy array"""
+    b = np.array([True, False, True], np.bool_)
+    i = np.array([2, 3, 5], np.int64)
+    f = np.array([1.0, 2.0, 3.0], np.float64)
+    c = np.array([1.1j, 2.2j, 4.1j], np.complex128)
+
+    check(assert_type(left - b, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left - i, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left - f, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    # `numpy` typing gives the corresponding `ndarray`s in the static type
+    # checking, where our `__rsub__` cannot override. At runtime, they return
+    # `Series`s with the correct element type.
+    check(assert_type(b - left, NoReturn), pd.Series, np.complexfloating)
+    check(assert_type(i - left, "npt.NDArray[np.int64]"), pd.Series, np.complexfloating)
+    check(
+        assert_type(f - left, "npt.NDArray[np.float64]"), pd.Series, np.complexfloating
+    )
+    check(
+        assert_type(c - left, "npt.NDArray[np.complex128]"),
+        pd.Series,
+        np.complexfloating,
+    )
+
+    check(assert_type(left.sub(b), "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left.sub(i), "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left.sub(f), "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left.sub(c), "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(
+        assert_type(left.rsub(b), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+    check(
+        assert_type(left.rsub(i), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+    check(
+        assert_type(left.rsub(f), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+    check(
+        assert_type(left.rsub(c), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+
+
+def test_sub_pd_series() -> None:
+    """Test pd.Series[complex] - pandas series"""
+    b = pd.Series([True, False, True])
+    i = pd.Series([2, 3, 5])
+    f = pd.Series([1.0, 2.0, 3.0])
+    c = pd.Series([1.1j, 2.2j, 4.1j])
+
+    check(assert_type(left - b, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left - i, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left - f, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(b - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(i - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(f - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(c - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.sub(b), "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left.sub(i), "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left.sub(f), "pd.Series[complex]"), pd.Series, np.complexfloating)
+    check(assert_type(left.sub(c), "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(
+        assert_type(left.rsub(b), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+    check(
+        assert_type(left.rsub(i), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+    check(
+        assert_type(left.rsub(f), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+    check(
+        assert_type(left.rsub(c), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
diff --git a/tests/series/arithmetic/float/test_sub.py b/tests/series/arithmetic/float/test_sub.py
new file mode 100644
index 00000000..c7095765
--- /dev/null
+++ b/tests/series/arithmetic/float/test_sub.py
@@ -0,0 +1,131 @@
+from typing import NoReturn
+
+import numpy as np
+from numpy import typing as npt  # noqa: F401
+import pandas as pd
+from typing_extensions import assert_type
+
+from tests import check
+
+left = pd.Series([1.0, 2.0, 3.0])  # left operand
+
+
+def test_sub_py_scalar() -> None:
+    """Test pd.Series[float] - Python native scalars"""
+    b, i, f, c = True, 1, 1.0, 1j
+
+    check(assert_type(left - b, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - i, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - f, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(b - left, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(i - left, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(f - left, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(c - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.sub(b), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(i), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(c), "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.rsub(b), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.rsub(i), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.rsub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(
+        assert_type(left.rsub(c), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+
+
+def test_sub_py_sequence() -> None:
+    """Test pd.Series[float] - Python native sequence"""
+    b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j]
+
+    check(assert_type(left - b, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - i, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - f, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(b - left, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(i - left, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(f - left, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(c - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.sub(b), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(i), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(c), "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.rsub(b), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.rsub(i), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.rsub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(
+        assert_type(left.rsub(c), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+
+
+def test_sub_numpy_array() -> None:
+    """Test pd.Series[float] - numpy array"""
+    b = np.array([True, False, True], np.bool_)
+    i = np.array([2, 3, 5], np.int64)
+    f = np.array([1.0, 2.0, 3.0], np.float64)
+    c = np.array([1.1j, 2.2j, 4.1j], np.complex128)
+
+    check(assert_type(left - b, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - i, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - f, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    # `numpy` typing gives the corresponding `ndarray`s in the static type
+    # checking, where our `__rsub__` cannot override. At runtime, they return
+    # `Series`s with the correct element type.
+    check(assert_type(b - left, NoReturn), pd.Series, np.floating)
+    check(assert_type(i - left, "npt.NDArray[np.int64]"), pd.Series, np.floating)
+    check(assert_type(f - left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
+    check(
+        assert_type(c - left, "npt.NDArray[np.complex128]"),
+        pd.Series,
+        np.complexfloating,
+    )
+
+    check(assert_type(left.sub(b), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(i), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(c), "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.rsub(b), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.rsub(i), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.rsub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(
+        assert_type(left.rsub(c), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+
+
+def test_sub_pd_series() -> None:
+    """Test pd.Series[float] - pandas series"""
+    b = pd.Series([True, False, True])
+    i = pd.Series([2, 3, 5])
+    f = pd.Series([1.0, 2.0, 3.0])
+    c = pd.Series([1.1j, 2.2j, 4.1j])
+
+    check(assert_type(left - b, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - i, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - f, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(b - left, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(i - left, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(f - left, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(c - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.sub(b), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(i), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(c), "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.rsub(b), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.rsub(i), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.rsub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(
+        assert_type(left.rsub(c), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
diff --git a/tests/series/arithmetic/int/test_sub.py b/tests/series/arithmetic/int/test_sub.py
new file mode 100644
index 00000000..57056e93
--- /dev/null
+++ b/tests/series/arithmetic/int/test_sub.py
@@ -0,0 +1,131 @@
+from typing import NoReturn
+
+import numpy as np
+from numpy import typing as npt  # noqa: F401
+import pandas as pd
+from typing_extensions import assert_type
+
+from tests import check
+
+left = pd.Series([1, 2, 3])  # left operand
+
+
+def test_sub_py_scalar() -> None:
+    """Test pd.Series[int] - Python native scalars"""
+    b, i, f, c = True, 1, 1.0, 1j
+
+    check(assert_type(left - b, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left - i, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left - f, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(b - left, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(i - left, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(f - left, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(c - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.sub(b), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.sub(i), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.sub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(c), "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.rsub(b), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.rsub(i), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.rsub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(
+        assert_type(left.rsub(c), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+
+
+def test_sub_py_sequence() -> None:
+    """Test pd.Series[int] - Python native sequence"""
+    b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j]
+
+    check(assert_type(left - b, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left - i, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left - f, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(b - left, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(i - left, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(f - left, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(c - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.sub(b), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.sub(i), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.sub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(c), "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.rsub(b), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.rsub(i), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.rsub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(
+        assert_type(left.rsub(c), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+
+
+def test_sub_numpy_array() -> None:
+    """Test pd.Series[int] - numpy array"""
+    b = np.array([True, False, True], np.bool_)
+    i = np.array([2, 3, 5], np.int64)
+    f = np.array([1.0, 2.0, 3.0], np.float64)
+    c = np.array([1.1j, 2.2j, 4.1j], np.complex128)
+
+    check(assert_type(left - b, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left - i, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left - f, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    # `numpy` typing gives the corresponding `ndarray`s in the static type
+    # checking, where our `__rsub__` cannot override. At runtime, they return
+    # `Series`s with the correct element type.
+    check(assert_type(b - left, NoReturn), pd.Series, np.integer)
+    check(assert_type(i - left, "npt.NDArray[np.int64]"), pd.Series, np.integer)
+    check(assert_type(f - left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
+    check(
+        assert_type(c - left, "npt.NDArray[np.complex128]"),
+        pd.Series,
+        np.complexfloating,
+    )
+
+    check(assert_type(left.sub(b), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.sub(i), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.sub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(c), "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.rsub(b), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.rsub(i), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.rsub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(
+        assert_type(left.rsub(c), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
+
+
+def test_sub_pd_series() -> None:
+    """Test pd.Series[int] - pandas series"""
+    b = pd.Series([True, False, True])
+    i = pd.Series([2, 3, 5])
+    f = pd.Series([1.0, 2.0, 3.0])
+    c = pd.Series([1.1j, 2.2j, 4.1j])
+
+    check(assert_type(left - b, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left - i, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left - f, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left - c, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(b - left, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(i - left, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(f - left, "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(c - left, "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.sub(b), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.sub(i), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.sub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(assert_type(left.sub(c), "pd.Series[complex]"), pd.Series, np.complexfloating)
+
+    check(assert_type(left.rsub(b), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.rsub(i), "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(left.rsub(f), "pd.Series[float]"), pd.Series, np.floating)
+    check(
+        assert_type(left.rsub(c), "pd.Series[complex]"), pd.Series, np.complexfloating
+    )
diff --git a/tests/series/arithmetic/test_sub.py b/tests/series/arithmetic/test_sub.py
new file mode 100644
index 00000000..9ca8dfd3
--- /dev/null
+++ b/tests/series/arithmetic/test_sub.py
@@ -0,0 +1,126 @@
+from typing import NoReturn
+
+import numpy as np
+from numpy import typing as npt  # noqa: F401
+import pandas as pd
+from typing_extensions import assert_type
+
+from tests import check
+
+left = pd.DataFrame({"a": [1, 2, 3]})["a"]  # left operand
+
+
+def test_sub_py_scalar() -> None:
+    """Test pd.Series[Any] - Python native scalars"""
+    b, i, f, c = True, 1, 1.0, 1j
+
+    check(assert_type(left - b, pd.Series), pd.Series)
+    check(assert_type(left - i, pd.Series), pd.Series)
+    check(assert_type(left - f, pd.Series), pd.Series)
+    check(assert_type(left - c, pd.Series), pd.Series)
+
+    check(assert_type(b - left, pd.Series), pd.Series)
+    check(assert_type(i - left, pd.Series), pd.Series)
+    check(assert_type(f - left, pd.Series), pd.Series)
+    check(assert_type(c - left, pd.Series), pd.Series)
+
+    check(assert_type(left.sub(b), pd.Series), pd.Series)
+    check(assert_type(left.sub(i), pd.Series), pd.Series)
+    check(assert_type(left.sub(f), pd.Series), pd.Series)
+    check(assert_type(left.sub(c), pd.Series), pd.Series)
+
+    check(assert_type(left.rsub(b), pd.Series), pd.Series)
+    check(assert_type(left.rsub(i), pd.Series), pd.Series)
+    check(assert_type(left.rsub(f), pd.Series), pd.Series)
+    check(assert_type(left.rsub(c), pd.Series), pd.Series)
+
+
+def test_sub_py_sequence() -> None:
+    """Test pd.Series[Any] - Python native sequence"""
+    b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j]
+
+    check(assert_type(left - b, pd.Series), pd.Series)
+    check(assert_type(left - i, pd.Series), pd.Series)
+    check(assert_type(left - f, pd.Series), pd.Series)
+    check(assert_type(left - c, pd.Series), pd.Series)
+
+    check(assert_type(b - left, pd.Series), pd.Series)
+    check(assert_type(i - left, pd.Series), pd.Series)
+    check(assert_type(f - left, pd.Series), pd.Series)
+    check(assert_type(c - left, pd.Series), pd.Series)
+
+    check(assert_type(left.sub(b), pd.Series), pd.Series)
+    check(assert_type(left.sub(i), pd.Series), pd.Series)
+    check(assert_type(left.sub(f), pd.Series), pd.Series)
+    check(assert_type(left.sub(c), pd.Series), pd.Series)
+
+    check(assert_type(left.rsub(b), pd.Series), pd.Series)
+    check(assert_type(left.rsub(i), pd.Series), pd.Series)
+    check(assert_type(left.rsub(f), pd.Series), pd.Series)
+    check(assert_type(left.rsub(c), pd.Series), pd.Series)
+
+
+def test_sub_numpy_array() -> None:
+    """Test pd.Series[Any] - numpy array"""
+    b = np.array([True, False, True], np.bool_)
+    i = np.array([2, 3, 5], np.int64)
+    f = np.array([1.0, 2.0, 3.0], np.float64)
+    c = np.array([1.1j, 2.2j, 4.1j], np.complex128)
+
+    check(assert_type(left - b, pd.Series), pd.Series)
+    check(assert_type(left - i, pd.Series), pd.Series)
+    check(assert_type(left - f, pd.Series), pd.Series)
+    check(assert_type(left - c, pd.Series), pd.Series)
+
+    # `numpy` typing gives the corresponding `ndarray`s in the static type
+    # checking, where our `__rsub__` cannot override. At runtime, they return
+    # `Series`s.
+    # `mypy` thinks the return types are `Any`, which is a bug.
+    check(assert_type(b - left, NoReturn), pd.Series)  # type: ignore[assert-type]
+    check(
+        assert_type(i - left, "npt.NDArray[np.int64]"), pd.Series  # type: ignore[assert-type]
+    )
+    check(
+        assert_type(f - left, "npt.NDArray[np.float64]"), pd.Series  # type: ignore[assert-type]
+    )
+    check(
+        assert_type(c - left, "npt.NDArray[np.complex128]"), pd.Series  # type: ignore[assert-type]
+    )
+
+    check(assert_type(left.sub(b), pd.Series), pd.Series)
+    check(assert_type(left.sub(i), pd.Series), pd.Series)
+    check(assert_type(left.sub(f), pd.Series), pd.Series)
+    check(assert_type(left.sub(c), pd.Series), pd.Series)
+
+    check(assert_type(left.rsub(b), pd.Series), pd.Series)
+    check(assert_type(left.rsub(i), pd.Series), pd.Series)
+    check(assert_type(left.rsub(f), pd.Series), pd.Series)
+    check(assert_type(left.rsub(c), pd.Series), pd.Series)
+
+
+def test_sub_pd_series() -> None:
+    """Test pd.Series[Any] - pandas series"""
+    b = pd.Series([True, False, True])
+    i = pd.Series([2, 3, 5])
+    f = pd.Series([1.0, 2.0, 3.0])
+    c = pd.Series([1.1j, 2.2j, 4.1j])
+
+    check(assert_type(left - b, pd.Series), pd.Series)
+    check(assert_type(left - i, pd.Series), pd.Series)
+    check(assert_type(left - f, pd.Series), pd.Series)
+    check(assert_type(left - c, pd.Series), pd.Series)
+
+    check(assert_type(b - left, pd.Series), pd.Series)
+    check(assert_type(i - left, pd.Series), pd.Series)
+    check(assert_type(f - left, pd.Series), pd.Series)
+    check(assert_type(c - left, pd.Series), pd.Series)
+
+    check(assert_type(left.sub(b), pd.Series), pd.Series)
+    check(assert_type(left.sub(i), pd.Series), pd.Series)
+    check(assert_type(left.sub(f), pd.Series), pd.Series)
+    check(assert_type(left.sub(c), pd.Series), pd.Series)
+
+    check(assert_type(left.rsub(b), pd.Series), pd.Series)
+    check(assert_type(left.rsub(i), pd.Series), pd.Series)
+    check(assert_type(left.rsub(f), pd.Series), pd.Series)
+    check(assert_type(left.rsub(c), pd.Series), pd.Series)
diff --git a/tests/series/test_series.py b/tests/series/test_series.py
index 4d1486dc..d9723588 100644
--- a/tests/series/test_series.py
+++ b/tests/series/test_series.py
@@ -818,8 +818,7 @@ def test_types_element_wise_arithmetic() -> None:
     check(assert_type(s + s2, "pd.Series[int]"), pd.Series, np.integer)
     check(assert_type(s.add(s2, fill_value=0), "pd.Series[int]"), pd.Series, np.integer)
 
-    # TODO this one below should type pd.Series[int]
-    check(assert_type(s - s2, pd.Series), pd.Series, np.integer)
+    check(assert_type(s - s2, "pd.Series[int]"), pd.Series, np.integer)
     check(assert_type(s.sub(s2, fill_value=0), "pd.Series[int]"), pd.Series, np.integer)
 
     # TODO these two below should type pd.Series[int]
@@ -1643,7 +1642,7 @@ def test_series_mul() -> None:
     sm = s * 4
     check(assert_type(sm, pd.Series), pd.Series)
     ss = s - 4
-    check(assert_type(ss, pd.Series), pd.Series)
+    check(assert_type(ss, "pd.Series[int]"), pd.Series, np.integer)
     sm2 = s * s
     check(assert_type(sm2, pd.Series), pd.Series)
     sp = s + 4