@@ -3727,6 +3727,122 @@ exact_class: type[Just[object]] = object  # no diagnostic
 subclass_class: type[Just[object]] = Custom  # error: [invalid-assignment]
 ```
 
+## Recursive protocol receiver restrictions
+
+An implementation can use the same receiver restriction as a generic protocol. Its other parameters
+and return types must still match.
+
+```py
+from __future__ import annotations
+from collections.abc import Callable, Iterable
+from typing import Generic, Protocol, TypeVar
+
+T = TypeVar("T")
+S = TypeVar("S")
+
+class Chain(Protocol[T]):
+    def value(self) -> T:
+        raise RuntimeError
+    def step(self: Chain[tuple[S]], callback: Callable[[S], T]) -> None:
+        raise RuntimeError
+
+class Inherited(Chain[T]):
+    def __init__(self, values: Iterable[T]) -> None: ...
+
+class Structural(Generic[T]):
+    def value(self) -> T:
+        raise NotImplementedError
+    def step(self: Chain[tuple[S]], callback: Callable[[S], T]) -> None:
+        raise NotImplementedError
+
+class Invalid(Generic[T]):
+    def value(self) -> T:
+        raise NotImplementedError
+    def step(self: Chain[tuple[S]], callback: Callable[[S], str]) -> None:
+        raise NotImplementedError
+
+def accepts(value: Chain[int]) -> None: ...
+def check(inherited: Inherited[int], structural: Structural[int], wrong: Structural[str], invalid: Invalid[int]):
+    accepts(inherited)  # no diagnostic
+    accepts(structural)  # no diagnostic
+    accepts(wrong)  # error: [invalid-argument-type]
+    accepts(invalid)  # error: [invalid-argument-type]
+```
+
+A subprotocol must pass the same assignability check.
+
+```py
+class StructuralProtocol(Protocol[T]):
+    def value(self) -> T: ...
+    def step(self: Chain[tuple[S]], callback: Callable[[S], T]) -> None: ...
+
+def check_protocol(valid: StructuralProtocol[int], invalid: StructuralProtocol[str]):
+    accepts(valid)  # no diagnostic
+    accepts(invalid)  # error: [invalid-argument-type]
+```
+
+The expected protocol also supplies the inherited constructor's type argument.
+
+```py
+contextual: Chain[int] = Inherited(())  # no diagnostic
+reveal_type(contextual)  # revealed: Inherited[int]
+```
+
+## Variance of protocol receiver restrictions
+
+An implementation can accept a broader receiver than a protocol requires.
+
+```py
+from __future__ import annotations
+from typing import Protocol, TypeVar
+
+T_co = TypeVar("T_co", covariant=True)
+
+class Reader(Protocol[T_co]):
+    def read(self) -> T_co: ...
+
+class Required(Protocol):
+    def method(self: Reader[bool]) -> None: ...
+
+class Broad:
+    def method(self: Reader[int]) -> None: ...
+
+class Incompatible:
+    def method(self: Reader[str]) -> None: ...
+
+def accepts(value: Required) -> None: ...
+def check(broad: Broad, incompatible: Incompatible):
+    accepts(broad)  # no diagnostic
+    accepts(incompatible)  # error: [invalid-argument-type]
+```
+
+## Structurally equivalent protocol receiver restrictions
+
+Receiver annotations can match structurally even when their type arguments do not satisfy the
+protocol's declared variance.
+
+```py
+from __future__ import annotations
+from typing import Protocol, TypeVar
+
+T_co = TypeVar("T_co", covariant=True)
+
+class Recursive(Protocol[T_co]):
+    def child(self) -> Recursive[T_co]: ...
+
+class Required(Protocol):
+    def method(self: Recursive[int]) -> None: ...
+
+class Implementation:
+    def child(self) -> Implementation:
+        return self
+    def method(self: Recursive[str]) -> None: ...
+
+def accepts(value: Required) -> None: ...
+def check(value: Implementation):
+    accepts(value)  # no diagnostic
+```
+
 ## Aliased `Self` in explicit receivers
 
 Specializing a generic class also specializes the upper bound of `Self` inside type alias arguments.
 
@@ -2834,6 +2834,90 @@ def invalid() -> Nested:
     return Box("wrong")  # error: [invalid-return-type]
 ```
 
+## Recursive protocol receiver restrictions
+
+An implementation can use the same receiver restriction as a generic protocol. Its other parameters
+and return types must still match.
+
+```py
+from __future__ import annotations
+from collections.abc import Callable, Iterable
+from typing import Protocol
+
+class Chain[T](Protocol):
+    def value(self) -> T:
+        raise RuntimeError
+    def step[S](self: Chain[tuple[S]], callback: Callable[[S], T]) -> None:
+        raise RuntimeError
+
+class Inherited[T](Chain[T]):
+    def __init__(self, values: Iterable[T]) -> None: ...
+
+class Structural[T]:
+    def value(self) -> T:
+        raise NotImplementedError
+    def step[S](self: Chain[tuple[S]], callback: Callable[[S], T]) -> None:
+        raise NotImplementedError
+
+class Invalid[T]:
+    def value(self) -> T:
+        raise NotImplementedError
+    def step[S](self: Chain[tuple[S]], callback: Callable[[S], str]) -> None:
+        raise NotImplementedError
+
+def accepts(value: Chain[int]) -> None: ...
+def check(inherited: Inherited[int], structural: Structural[int], wrong: Structural[str], invalid: Invalid[int]):
+    accepts(inherited)  # no diagnostic
+    accepts(structural)  # no diagnostic
+    accepts(wrong)  # error: [invalid-argument-type]
+    accepts(invalid)  # error: [invalid-argument-type]
+```
+
+A subprotocol must pass the same assignability check.
+
+```py
+class StructuralProtocol[T](Protocol):
+    def value(self) -> T: ...
+    def step[S](self: Chain[tuple[S]], callback: Callable[[S], T]) -> None: ...
+
+def check_protocol(valid: StructuralProtocol[int], invalid: StructuralProtocol[str]):
+    accepts(valid)  # no diagnostic
+    accepts(invalid)  # error: [invalid-argument-type]
+```
+
+The expected protocol also supplies the inherited constructor's type argument.
+
+```py
+contextual: Chain[int] = Inherited(())  # no diagnostic
+reveal_type(contextual)  # revealed: Inherited[int]
+```
+
+## Variance of protocol receiver restrictions
+
+An implementation can accept a broader receiver than a protocol requires.
+
+```py
+from __future__ import annotations
+from typing import Protocol
+
+class Reader[T](Protocol):
+    def read(self) -> T: ...
+
+class Required(Protocol):
+    def method(self: Reader[bool]) -> None: ...
+
+class Broad:
+    def method(self: Reader[int]) -> None: ...
+
+class Incompatible:
+    def method(self: Reader[str]) -> None: ...
+
+def accepts(value: Required) -> None: ...
+def check(broad: Broad, incompatible: Incompatible):
+    accepts(broad)  # no diagnostic
+    accepts(incompatible)  # error: [invalid-argument-type]
+```
+
 ## Aliased `Self` in explicit receivers
 
 Specializing a generic class also specializes the upper bound of `Self` inside type alias arguments.
 
@@ -4430,6 +4430,27 @@ static_assert(is_subtype_of(Text, ConsoleRenderable))
 static_assert(is_assignable_to(Text, ConsoleRenderable))
 ```
 
+## Receiver parameter names
+
+Receiver parameter names do not affect method compatibility, including methods with explicit
+protocol receiver restrictions.
+
+```py
+from typing import Protocol
+
+class Receiver(Protocol):
+    value: int
+
+class Required(Protocol):
+    def method(self: Receiver) -> None: ...
+
+class Implementation:
+    def method(receiver: Receiver) -> None: ...
+
+def check(value: Implementation) -> Required:
+    return value  # no diagnostic
+```
+
 ## Recursive protocol receiver binding
 
 A classmethod on a generic protocol can cause receiver binding for another method to depend on
 
@@ -12,7 +12,7 @@ use crate::types::attribute_write::{
     property_setter_value_type,
 };
 use crate::types::overrides::{VariableKind, effective_superclass_variable_kind};
-use crate::types::relation::{DisjointnessChecker, TypeRelationChecker};
+use crate::types::relation::{DisjointnessChecker, TypeRelationChecker, TypeVarEvaluation};
 use crate::types::visitor::any_over_type_expanding_aliases;
 use crate::types::{TypeContext, UpcastPolicy};
 use crate::{
@@ -1451,6 +1451,19 @@ struct ProtocolMemberAccess<'a, 'db> {
 }
 
 impl<'a, 'db> ProtocolMemberAccess<'a, 'db> {
+    fn unbound_instance_method(self, db: &'db dyn Db) -> Option<&'db CallableSignature<'db>> {
+        // Raw declaration signatures do not include a pending materialization.
+        if self.mode != ProtocolMemberAccessMode::Instance || self.materialization.is_some() {
+            return None;
+        }
+        let ProtocolMemberKind::Method(Type::Callable(callable), ProtocolMethodKind::Instance) =
+            self.declaration.kind
+        else {
+            return None;
+        };
+        Some(callable.signatures(db))
+    }
+
     fn read(self) -> Option<ProtocolMemberReadAccess<'a, 'db>> {
         let supported = match self.declaration.kind {
             ProtocolMemberKind::Method(..) => true,
@@ -2596,6 +2609,46 @@ fn protocol_member_read_type<'db>(
 }
 
 impl<'c, 'db> TypeRelationChecker<'_, 'c, 'db> {
+    /// Prove receiver compatibility without unfolding two instances of the same protocol.
+    ///
+    /// A target receiver restriction `P[B]` implies a source restriction `P[A]` if `P[B]`
+    /// is assignable to `P[A]`. Comparing their type arguments using the protocol's variance
+    /// is sufficient; checking the implementing instance against both annotations would
+    /// recursively check this same method with fresh type variables. Retaining the receiver
+    /// parameter keeps its constraints in the same scope as the other parameters and return type.
+    fn try_check_protocol_receiver_pair(
+        &self,
+        db: &'db dyn Db,
+        source: &CallableSignature<'db>,
+        target: &CallableSignature<'db>,
+        source_self_type: Type<'db>,
+        target_self_type: Type<'db>,
+    ) -> Option<ConstraintSet<'db, 'c>> {
+        let target_receiver = target.overloads.first()?.parameters().get_positional(0)?;
+        let receiver_protocol = target_receiver
+            .annotated_type()
+            .resolve_type_alias(db)
+            .as_protocol_instance()?;
+        let origin = receiver_protocol.class_origin(db)?.class_literal(db);
+        let prepare = |signatures: &CallableSignature<'db>, self_type| {
+            signatures
+                .iter()
+                .map(|signature| {
+                    signature.with_nominal_protocol_receiver(db, self.env, origin, self_type)
+                })
+                .collect::<Option<Vec<_>>>()
+                .map(CallableSignature::from_overloads)
+        };
+        let source = prepare(source, source_self_type)?;
+        let target = prepare(target, target_self_type)?;
+        let mut checker = self.clone();
+        checker.typevar_evaluation = TypeVarEvaluation::Lazy;
+        let result = checker.check_callable_signature_pair(db, &source, &target);
+        // This is a sufficient proof. A failed nominal comparison does not rule out a
+        // structural match, even between specializations of the same protocol.
+        (!result.is_never_satisfied(db, self.env, self.inferable)).then_some(result)
+    }
+
     fn check_protocol_member_read(
         &self,
         db: &'db dyn Db,
@@ -2667,6 +2720,36 @@ impl<'c, 'db> TypeRelationChecker<'_, 'c, 'db> {
                 (implementation_self_binding_ty, protocol_self_binding_ty)
             };
 
+        if let Some(target) = required.unbound_instance_method(db)
+            && let Type::BoundMethod(method) = attribute_type
+            && method.signature_receiver(db) == protocol_receiver_binding_ty
+            && let Some(source) = method.unbound_signatures(db)
+        {
+            // A stored bound method keeps its captured receiver; only descriptor binding to
+            // this object lets us use the target's receiver restriction as a premise.
+            let source_descriptor = ty
+                .class_member_with_policy(
+                    db,
+                    env,
+                    member.name,
+                    MemberLookupPolicy::NO_INSTANCE_FALLBACK,
+                )
+                .place
+                .ignore_possibly_undefined();
+            if source_descriptor
+                .is_some_and(|descriptor| descriptor.function_like_kind(db).is_some())
+                && let Some(result) = self.try_check_protocol_receiver_pair(
+                    db,
+                    source,
+                    target,
+                    method.typing_self_type(db),
+                    protocol_self_binding_ty,
+                )
+            {
+                return result;
+            }
+        }
+
         let Some(Type::Callable(required_callable)) = required
             .read()
             .and_then(|read| read.result_type(db, env, None))
@@ -3006,6 +3089,12 @@ impl<'c, 'db> TypeRelationChecker<'_, 'c, 'db> {
             self.always()
         } else if source.read().is_none() {
             self.never()
+        } else if let Some(source) = source.unbound_instance_method(db)
+            && let Some(target) = target.unbound_instance_method(db)
+            && let Some(result) =
+                self.try_check_protocol_receiver_pair(db, source, target, source_type, source_type)
+        {
+            result
         } else {
             let bind_read = |access: ProtocolMemberAccess<'_, 'db>,
                              member: &ProtocolMember<'_, 'db>| {