Fix: Correct complexity documentation details

Co-Authored-By: Claude <noreply@anthropic.com>

Co-Authored-By: Codex <codex@openai.com>

Author: heikkitoivonen

docs/builtins/chr.md

@@ -200,7 +200,7 @@ chr(65)        # 'A'
 
 # TypeError - non-integer
 try:
-    chr(65.0)  # Works! Floats converted to int
+    chr(65.0)  # TypeError - float not accepted
 except TypeError:
     pass
 

docs/builtins/int.md

@@ -49,7 +49,7 @@ The `int` type represents arbitrary precision integers. Python 3 has a single in
 
 | Operation | Time | Space | Notes |
 |-----------|------|-------|-------|
-| `hash(x)` | O(1) | O(1) | Hash value |
+| `hash(x)` | O(n)* | O(1) | Iterates over internal digits; O(1) for compact one-digit ints (roughly \|x\| <= 2^30-1 on typical 64-bit builds) |
 | `str(x)` | O(n) | O(n) | Convert to string |
 | `repr(x)` | O(n) | O(n) | String representation |
 | `int(x)` | O(1) | O(1) | No-op if already int |

docs/builtins/sorted.md

@@ -156,14 +156,14 @@ original.sort()  # [1, 1, 3, 4, 5]
 ### Expensive Key Functions
 
 ```python
-# O(n log n * k) - k = key function time
+# O(n*k + n log n) - key computed once per element, then cached
 def expensive_key(x):
     # O(m) - expensive computation
     return sum(range(x))
 
 numbers = list(range(1000))
 result = sorted(numbers, key=expensive_key)
-# Complexity: O(n log n * m)
+# Complexity: O(n*m + n log n) - key called n times, then n log n comparisons
 
 # Better: pre-compute keys
 from operator import itemgetter
@@ -180,7 +180,7 @@ def get_sort_key(item):
     # Some expensive computation
     return complex_calculation(item)
 
-# Slow: O(n log n * k)
+# With key: O(n*k + n log n) - key computed once per element
 result = sorted(items, key=get_sort_key)
 
 # Faster: O(n*k + n log n)

docs/builtins/tuple.md

@@ -14,7 +14,7 @@ The `tuple` type is an immutable, ordered sequence. Being immutable allows vario
 | `copy()` | O(1) | O(1) | Just increments reference count |
 | `x + y` (concatenation) | O(m+n) | O(m+n) | m, n are lengths |
 | `t * n` (repetition) | O(n*len(t)) | O(n*len(t)) | Creates new tuple |
-| `hash()` | O(n) | O(1) | Computes hash by iterating all elements |
+| `hash()` | O(n) first call, O(1) cached | O(1) | Hash computed once then cached in `ob_hash` |
 | `reversed()` | O(1) | O(1) | Iterator, not materialized |
 | `tuple()` constructor | O(n) | O(n) | n = iterable length |
 | `slice [::2]` | O(k) | O(k) | k = slice length |
@@ -37,11 +37,11 @@ s = {(0, 0), (1, 1)}
 ```python
 # hash() computes hash value by iterating all elements
 t = (1, 2, 3)
-h1 = hash(t)  # O(n) - computes by iterating elements
+h1 = hash(t)  # O(n) first call - computes by iterating elements
 
-# Note: Unlike strings, tuples do NOT cache their hash
-# Each call recomputes: O(n) every time
-h2 = hash(t)  # O(n) - recomputes hash
+# CPython caches the hash in the tuple's ob_hash field
+# Subsequent calls return the cached value
+h2 = hash(t)  # O(1) - returns cached hash
 ```
 
 ### Reference vs Copy

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 by multiple AI coding agents (Amp, Claude, Gemini CLI, Kiro, Copilot, Codex) and models (Opus 4.5, Sonnet 4.5, Gemini 3 Pro, gpt-5.2-codex, ...) working alongside human contributors. Each agent brings different perspectives and catches different issues, resulting in thorough cross-validation. A growing unit test suite validates complexity claims against actual Python behavior.
+This documentation has been reviewed and refined by multiple AI coding agents (Amp, Claude, Gemini CLI, Kiro, Copilot, Codex) and models (Opus 4.(5|6), Sonnet 4.5, Gemini 3 Pro, gpt-5.(2|3)-codex, ...) working alongside human contributors. Each agent brings different perspectives and catches different issues, resulting in thorough cross-validation. A growing unit test suite validates complexity claims against actual Python behavior.
 
 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/stdlib/array.md

@@ -84,9 +84,6 @@ lst = arr.tolist()  # O(3)
 
 # To bytes - O(n)
 bytes_data = arr.tobytes()  # O(3)
-
-# To string - O(n)
-str_data = arr.tostring()  # O(3)
 ```
 
 ## Performance Comparison

docs/stdlib/bisect.md

@@ -9,14 +9,14 @@ The `bisect` module provides binary search operations for sorted lists.
 | `bisect_left(a, x)` | O(log n) | O(1) | Find leftmost position |
 | `bisect_right(a, x)` | O(log n) | O(1) | Find rightmost position |
 | `bisect(a, x)` | O(log n) | O(1) | Alias for bisect_right |
-| `insort_left(a, x)` | O(n) | O(n) | O(log n) search + O(n) insert |
-| `insort_right(a, x)` | O(n) | O(n) | O(log n) search + O(n) insert |
-| `insort(a, x)` | O(n) | O(n) | Alias for insort_right |
+| `insort_left(a, x)` | O(n) | O(1) | O(log n) search + O(n) insert (shifts elements in place) |
+| `insort_right(a, x)` | O(n) | O(1) | O(log n) search + O(n) insert (shifts elements in place) |
+| `insort(a, x)` | O(n) | O(1) | Alias for insort_right |
 
 ## Space Complexity
 
 - Binary search operations: O(1) additional space
-- Insert operations: O(n) due to list shifting
+- Insert operations: O(1) additional space (shifts elements within the existing list)
 
 ## Implementation Details
 

docs/stdlib/collections.md

@@ -222,7 +222,7 @@ from collections import ChainMap
 | `access[key]` | O(n) | O(1) | n = number of maps; searches until found |
 | `set[key]` | O(1) avg | O(1) | Sets in first map; O(m) worst case where m = first map size |
 | `del[key]` | O(1) avg | O(1) | Deletes from first map; O(m) worst case where m = first map size |
-| `len()` | O(n) | O(1) | Must check all maps |
+| `len()` | O(N) | O(N) | N = total keys across all maps; builds set union internally |
 | `in` | O(n) | O(1) | Checks all maps |
 
 ### Use Cases

docs/stdlib/graphlib.md

@@ -208,23 +208,25 @@ class BuildSystem:
     def build(self):
         """Build all targets in order - O(v + e)"""
         self.sorter.prepare()
-        
+
         built = set()
-        while True:
-            target = self.sorter.get_node()
-            if target is None:
+        while self.sorter.is_active():
+            # get_ready() returns a tuple of ready nodes
+            ready = self.sorter.get_ready()
+            if not ready:
                 break
-            
-            # Skip already built
-            if target in built:
+
+            for target in ready:
+                # Skip already built
+                if target in built:
+                    self.sorter.done(target)
+                    continue
+
+                print(f"Building {target}...")
+                # Simulate build
+                built.add(target)
                 self.sorter.done(target)
-                continue
-            
-            print(f"Building {target}...")
-            # Simulate build
-            built.add(target)
-            self.sorter.done(target)
-        
+
         return built
 
 # Usage
@@ -271,23 +273,24 @@ class TaskScheduler:
         executed = {}
         start_time = time.time()
 
-        while True:
-            # Get next ready task - O(1) amortized
-            task_name = self.sorter.get_node()
-            if task_name is None:
+        while self.sorter.is_active():
+            # Get all ready tasks - O(1) amortized
+            ready = self.sorter.get_ready()
+            if not ready:
                 break
-            
-            # Execute task - O(?)
-            if task_name in self.tasks:
-                print(f"Executing {task_name}...")
-                start = time.time()
-                result = self.tasks[task_name]()
-                elapsed = time.time() - start
-                executed[task_name] = (result, elapsed)
-                print(f"  Completed in {elapsed:.3f}s")
-            
-            # Mark done - O(d)
-            self.sorter.done(task_name)
+
+            for task_name in ready:
+                # Execute task - O(?)
+                if task_name in self.tasks:
+                    print(f"Executing {task_name}...")
+                    start = time.time()
+                    result = self.tasks[task_name]()
+                    elapsed = time.time() - start
+                    executed[task_name] = (result, elapsed)
+                    print(f"  Completed in {elapsed:.3f}s")
+
+                # Mark done - O(d)
+                self.sorter.done(task_name)
 
         total = time.time() - start_time
         print(f"Total execution time: {total:.3f}s")