Cache _natural_simpler_chars and extend candidates with all chars

Per review:
- ``.update()`` the candidate set with every character of the case-mapped
  and decomposed forms instead of only single-character results. This
  lets e.g. ``ß`` shrink to ``s`` via ``casefold() == "ss"``, and adds
  ``i`` (alongside ``f``) as a candidate when shrinking the ``fi`` ligature.
- Wrap the helper in ``lru_cache(maxsize=4096)`` since it gets called in
  tight loops from the shrink pass's chooser predicates.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: DRMacIver

hypothesis-python/src/hypothesis/internal/conjecture/shrinker.py

@@ -13,6 +13,7 @@
 from collections import defaultdict
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass
+from functools import lru_cache
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -90,20 +91,24 @@ def sort_key(nodes: Sequence[ChoiceNode]) -> tuple[int, tuple[int, ...]]:
     )
 
 
+@lru_cache(maxsize=4096)
 def _natural_simpler_chars(c, intervals):
     """Return single-char replacements for ``c`` derived from natural text
     transformations - case mapping (upper, lower, casefold) and unicode
-    decomposition (NFD, NFKD - taking just the base character).
+    decomposition (NFD, NFKD). We take each individual character of the
+    transformed form so that e.g. ``ß`` can shrink to ``s`` via casefold
+    even though the full case-folded form is two characters.
 
     Only candidates which are in ``intervals`` and which have a strictly
     smaller index in shrink order than ``c`` are returned, sorted by that
     shrink-order index. Callers must pass a single character that is itself
     in ``intervals``.
     """
-    candidates = {unicodedata.normalize(form, c)[0] for form in ("NFKD", "NFD")}
+    candidates: set[str] = set()
+    for form in ("NFKD", "NFD"):
+        candidates.update(unicodedata.normalize(form, c))
     for transformed in (c.upper(), c.lower(), c.casefold()):
-        if len(transformed) == 1:
-            candidates.add(transformed)
+        candidates.update(transformed)
     candidates.discard(c)
     original_idx = intervals.index_from_char_in_shrink_order(c)
     result = sorted(

hypothesis-python/tests/conjecture/test_shrinker.py

@@ -804,6 +804,10 @@ def shrinker(data: ConjectureData):
         ("Ｂ", "B"),
         # Ligatures decompose to their first base char under NFKD.
         ("fi", "f"),
+        # Case mapping that produces multiple chars: ``ß.casefold() == "ss"``,
+        # and we accept any of the individual characters of the case-mapped
+        # form as a single-char replacement.
+        ("ß", "s"),
         # Case mapping: uppercase has a smaller shrink-order index than
         # lowercase, so we can swap a→A.
         ("a", "A"),