Fix: clarify substring search complexity — O(n+m) vs O(n*m)

Co-Authored-By: Copilot CLI <copilot-cli@example.invalid>

Author: heikkitoivonen

docs/builtins/bytes.md

@@ -16,7 +16,7 @@ The `bytes` type is an immutable sequence of bytes, while `bytearray` is the mut
 | `copy()` | O(n) | Creates new bytes object |
 | `join()` | O(n) | Single pass, n = total output length |
 | `split()` | O(n) | Single pass |
-| `find(sub)` | O(n*m) | n = bytes length, m = pattern length |
+| `find(sub)` | O(n + m) worst for long strings, O(n*m) worst for pathological cases | n = bytes length, m = pattern length |
 | `replace(old, new)` | O(n) | Creates new bytes object |
 | `decode()` | O(n) | Convert to string |
 | `hex()` | O(n) | Convert to hex |
@@ -105,7 +105,7 @@ s = b.decode('ascii')      # O(n)
 ### Searching and Replacing
 
 ```python
-# Find substring: O(n*m)
+# Find substring: O(n + m) worst for long strings, O(n*m) worst for pathological cases
 data = b"hello world"
 idx = data.find(b"world")  # O(n)
 

docs/builtins/str.md

@@ -8,9 +8,9 @@ The `str` type is an immutable sequence of Unicode characters. Python strings ha
 |-----------|------|-------|
 | `len()` | O(1) | Direct lookup |
 | `access[i]` | O(1) | Direct indexing |
-| `in` (substring) | O(n*m) worst, O(n) avg | Uses fast skip algorithm in CPython |
-| `count(sub)` | O(n*m) worst | n = string, m = substring; uses fast algorithm |
-| `find(sub)` | O(n*m) worst, O(n) avg | Uses two-way or similar fast algorithm |
+| `in` (substring) | O(n + m) worst for long strings, O(n*m) worst for pathological cases | Uses Two-Way / fastsearch algorithm in CPython (linear worst-case) |
+| `count(sub)` | O(n + m) worst for long strings, O(n*m) worst for pathological cases | n = string, m = substring; uses Two-Way/fastsearch (linear worst-case) |
+| `find(sub)` | O(n + m) worst for long strings, O(n*m) worst for pathological cases | Uses Two-Way / fastsearch algorithm in CPython (linear worst-case) |
 | `replace(old, new)` | O(n) | Single pass |
 | `split(sep)` | O(n) | Single pass |
 | `join()` | O(n) | n = total chars |
@@ -80,8 +80,8 @@ result = "".join(str(i) for i in range(10000))
 
 | Method | Complexity | Notes |
 |--------|-----------|-------|
-| `str.find()` | O(n*m) worst, O(n) avg | CPython uses two-way algorithm |
-| `str.count()` | O(n*m) worst, O(n) avg | Non-overlapping searches |
+| `str.find()` | O(n + m) worst for long strings, O(n*m) worst for pathological cases | CPython uses Two-Way / fastsearch algorithm (linear worst-case) |
+| `str.count()` | O(n + m) worst for long strings, O(n*m) worst for pathological cases | Non-overlapping searches (Two-Way/fastsearch) |
 | `str.replace()` | O(n) | Single pass with copy |
 | `str.split()` | O(n) | Single pass |
 | `str.startswith()` | O(m) | m = prefix length |

docs/implementations/cpython.md

@@ -113,7 +113,7 @@ gc.collect()  # O(n) where n = tracked objects
 
 | Operation | CPython Notes |
 |-----------|---|
-| `in` (substring) | O(n*m) worst, but highly optimized |
+| `in` (substring) | O(n + m) worst for long strings, O(n*m) worst for pathological cases |
 | `split()` | O(n) with specialized fast path |
 | `replace()` | O(n) with careful copying |
 

docs/index.md

@@ -49,7 +49,7 @@ See [Built-in Types](builtins/list.md) for detailed analysis.
 
 ## Why Trust This Documentation?
 
-This documentation has been reviewed and refined through **100+ commits** by multiple AI coding agents (Amp, Claude, Antigravity, Kiro) working alongside human contributors. Each agent brings different perspectives and catches different issues, resulting in thorough cross-validation.
+This documentation has been reviewed and refined through **100+ commits** by multiple AI coding agents (Amp, Claude, Antigravity, Kiro, Copilot) working alongside human contributors. Each agent brings different perspectives and catches different issues, resulting in thorough cross-validation.
 
 It's also **fully open source**—anyone can review the content, [file issues](https://github.com/heikkitoivonen/python-time-space-complexity/issues), or [submit improvements](https://github.com/heikkitoivonen/python-time-space-complexity/pulls). All sources are cited, and claims are based on official Python documentation and CPython source code.
 

docs/versions/index.md

@@ -219,8 +219,8 @@ Python 3.13 → Python 3.14  Better GC pauses, new heapq functions
 
 | Version | Lookup | Contains | Notes |
 |---------|--------|----------|-------|
-| 3.3+ | O(1) | O(n*m) | Flexible representation |
-| 3.11+ | O(1) | O(n*m)* | Faster due to inline caching |
+| 3.3+ | O(1) | O(n + m) worst for long strings, O(n*m) worst for pathological cases | Flexible representation |
+| 3.11+ | O(1) | O(n + m) worst for long strings, O(n*m) worst for pathological cases* | Faster due to inline caching |
 
 ## Upgrading Python
 

docs/versions/py311.md

@@ -84,7 +84,7 @@ All standard complexities remain the same as Python 3.10:
 | list | insert | O(n) | Unchanged |
 | dict | lookup | O(1) avg | Unchanged |
 | set | add | O(1) amortized | Unchanged |
-| str | find | O(n*m) | Unchanged |
+| str | find | O(n + m) worst for long strings, O(n*m) worst for pathological cases | Unchanged |
 
 *Amortized or average case, but faster in practice
 

docs/versions/py39.md

@@ -76,7 +76,7 @@ All data structure complexities same as 3.8:
 | dict | lookup | O(1) avg |
 | dict | insert | O(1) avg |
 | set | add | O(1) amortized |
-| str | find | O(n*m) |
+| str | find | O(n + m) worst for long strings, O(n*m) worst for pathological cases |
 
 ## Data Structure Examples