How does superintelligence work when an AI needs to find one code among hundreds of ordered records? If the records are sorted, the assistant need not read every entry from the beginning. It can inspect a middle value, decide whether the target belongs to the left or right half, and repeatedly eliminate the half that cannot contain it. This method is called binary search, and it is a simple example of why data organisation matters as much as raw computing speed.
The mechanism is divide-and-conquer search. Binary search works on an ordered collection with a reliable comparison rule. At each step it maintains the range that might still contain the target, inspects its midpoint, and removes one part using the ordering guarantee. An AI system should verify that the data meet those assumptions and distinguish a genuine not-found result in a complete list from missing or unindexed records outside the search.
This reader-friendly guide works through fifteen fictional library identifiers and two complete searches: one for a code that exists and one for a code that does not. It explains every comparison, a small correctness invariant and twenty-four checkable claims. The codes and algorithms are a teaching fixture, not a real database query or a measured model benchmark. “How Superintelligence Works” is an educational series title, not a claim that current AI systems are artificial superintelligence.
The method in a nutshell
- The list must be in a reliably sorted order.
- Inspect the middle candidate.
- If it equals the target, stop with a found result.
- If the target is larger, retain only the right-hand part.
- If the target is smaller, retain only the left-hand part.
- The fifteen-entry fictional list finds code 173 in four comparisons.
- A separate search establishes that code 150 is absent from this complete fifteen-entry list, also in four comparisons.
- Sorted-list absence does not establish absence from the whole world.
1. Why searching every entry can be slow
Imagine a library database displaying identifiers in a long list. A linear scan can begin at the first record and inspect each one until it finds the target or reaches the end. This works even if the list is not sorted, but it may inspect many irrelevant entries.
Binary search uses a stronger assumption: the identifiers are ordered by a consistent rule. It exploits that structure to skip entire regions at each step. The difference is especially useful for large, well-organised collections.
2. What does sorted mean?
Sorted means the entries follow a defined nondecreasing or nonincreasing comparison order. In our example the codes are increasing integers, from smallest to largest. Therefore everything to the left of a code is no larger, and everything to the right is no smaller.
An AI must know which field is sorted. If a table is alphabetically sorted by title but the assistant searches numeric IDs as though those IDs were sorted, the midpoint reasoning may discard the wrong records.
3. Binary search needs random access
An array lets software inspect a middle element by index without sequentially walking through every earlier entry. That makes repeated halving practical. Other storage structures may have different access costs.
The textbook comparison count is not a complete measure of real system latency. Disk access, indexing, network requests and data transformations can dominate performance in a deployed search tool.
4. The three choices at a midpoint
When the middle value equals the target, the search succeeds. When the target is smaller, only the lower half can contain it. When the target is larger, only the upper half can contain it.
This reasoning is valid only under the sorted-order guarantee. Without that invariant, a discarded region might contain the target even though the middle comparison suggested otherwise.
5. The fictional Cedar Library Index
Imagine exactly fifteen distinct book-copy codes stored in ascending numeric order. We use one-based positions for explanation: the first entry is position 1 and the final entry is position 15.
Every listed code is an invented identifier. We assume the list is complete for this particular fictional indexed collection, but it says nothing about other libraries, books not yet indexed, current borrowing availability or real-world code issuance.
6. The full ordered fifteen-code reference
- Position 1 — 102.
- Position 2 — 107.
- Position 3 — 113.
- Position 4 — 118.
- Position 5 — 124.
- Position 6 — 131.
- Position 7 — 139.
- Position 8 — 146.
- Position 9 — 152.
- Position 10 — 161.
- Position 11 — 173.
- Position 12 — 184.
- Position 13 — 195.
- Position 14 — 207.
- Position 15 — 219.
- The sequence is strictly ascending and contains no duplicate codes.
7. Define the first target
The first search asks whether the invented code 173 belongs to this exact fifteen-record list. The target is a numeric identifier for lookup purposes rather than a quantity of books.
Before beginning, the possible position range is 1 through 15 inclusive. The assistant should not use a similar-looking title or an approximate nearest code as a substitute for exact identity.
8. First comparison: position eight
The middle of positions 1 through 15 is position 8. Its value is 146. The target 173 is larger than 146.
Because the entries are ascending, every position from 1 through 8 contains a value no greater than 146. None can equal 173. The remaining search range is therefore positions 9 through 15.
9. Second comparison: position twelve
The middle of positions 9 through 15 is position 12, containing 184. The target 173 is smaller than 184.
Every value from position 12 through 15 is at least 184 and therefore too large. The possible positions shrink to 9 through 11. This comparison removes four entries from further consideration.
10. Third comparison: position ten
The middle of positions 9 through 11 is position 10, containing 161. The target 173 is larger than 161.
All values at positions 9 and 10 are now excluded by the ordering rule. The only remaining possible position is 11.
11. Fourth comparison: position eleven
Position 11 contains 173. The target equals the midpoint value, so the search returns found at position 11.
The four inspected values were 146, 184, 161 and 173. The algorithm did not need to compare the target with every other record. A system should report the actual located record, not merely announce success with no identifier.
12. The complete found-search trace
- Target: 173.
- Step 1 — range 1–15; compare position 8 = 146; go right.
- Step 2 — range 9–15; compare position 12 = 184; go left.
- Step 3 — range 9–11; compare position 10 = 161; go right.
- Step 4 — range 11–11; compare position 11 = 173; FOUND.
- Comparisons: 4.
- Returned one-based position: 11.
- The record exists in the fifteen-code fictional index.
13. Why the range keeps shrinking
After each unsuccessful comparison, the midpoint and the half of the list known to be impossible are discarded. The remaining interval always contains every position that could still hold the target.
This is the search invariant. A careful implementation maintains it after every step and does not accidentally reintroduce discarded positions or skip the only possible match.
14. A second target that does not exist
Now search for 150 in the same sorted list. The list includes 146 at position 8 and 152 at position 9, but no entry equal to 150.
The purpose is to demonstrate a legitimate absence result within a defined complete index. This differs from claiming that no book with code 150 could ever exist in another catalogue or later version.
15. First missing-target comparison
The middle position 8 contains 146. Since 150 is greater, positions 1 through 8 cannot contain the target.
Keep positions 9 through 15. The logic is identical to the first step of the successful search because the target remains greater than the same midpoint.
16. Second missing-target comparison
Position 12 contains 184. Since 150 is smaller, eliminate positions 12 through 15. The remaining possible interval is positions 9 through 11.
The operation has used only the ordering rule, not any knowledge about why the target is absent. It does not yet establish a no-match result until the remaining candidates are eliminated.
17. Third missing-target comparison
Position 10 contains 161. Since 150 is smaller, positions 10 and 11 are excluded. The only remaining possible position is 9.
An assistant should not prematurely stop at position 10 and call the target absent. It still needs to inspect the candidate at position 9.
18. Fourth missing-target comparison
Position 9 contains 152. The target 150 is smaller, so the interval becomes empty: the lower endpoint would be position 9 and the upper endpoint position 8.
No candidate position remains. The algorithm concludes that 150 is absent from the frozen complete fifteen-code index. It has not concluded that 150 is nonexistent in every other dataset.
19. The complete absent-search trace
- Target: 150.
- Step 1 — range 1–15; position 8 = 146; retain 9–15.
- Step 2 — range 9–15; position 12 = 184; retain 9–11.
- Step 3 — range 9–11; position 10 = 161; retain 9–9.
- Step 4 — range 9–9; position 9 = 152; retain the empty range.
- Comparisons: 4.
- Result: NOT FOUND within the specified fifteen-code index.
- The nearest neighbouring indexed values are 146 and 152, not an exact 150 match.
20. A near match is not an exact match
The values 146 and 152 lie close to the absent target 150. A search for exact book-copy code 150 should not quietly substitute one of them.
Some user interfaces offer nearest suggestions, but the suggestion must be labelled separately from an exact match. The role of the identifier is to distinguish records, not to estimate a quantity within a tolerance.
21. The easiest target is the initial midpoint
If the search target is 146, the very first midpoint at position 8 matches. That requires one comparison.
The number of comparisons therefore varies with the target and the list length. A four-comparison trace does not prove that every possible target takes exactly four comparisons.
22. The lowest target can take several steps
For target 102, the algorithm inspects position 8 = 146, then position 4 = 118, then position 2 = 107, and finally position 1 = 102.
It finds 102 after four comparisons. This shows why the value’s apparent position near the beginning does not guarantee fewer binary-search comparisons than a central value.
23. What is the comparison bound?
For fifteen distinct sorted entries, standard midpoint binary search needs at most four comparisons for an exact found or absent outcome under this particular index approach.
The general search cost grows logarithmically with list size, commonly described as O(log n) comparisons. That does not mean the runtime is literally the logarithm in seconds; it describes how the comparison count scales asymptotically under the model.
24. Why doubling data does not double comparisons
Halving the remaining candidate range means each extra comparison can rule out roughly half the current possibilities. Increasing a sorted list from about a thousand entries to about two thousand often adds only around one comparison in a conventional binary-search bound.
This improvement assumes efficient indexed access and consistent ordering. The cost of building or maintaining the sorted collection must be considered separately.
25. An unsorted list breaks the guarantee
Imagine swapping the values 161 and 173 at positions 10 and 11 while continuing to claim the list is ascending. A target comparison could discard the side that now contains its true match.
Binary search on a list without a valid ordering guarantee can return a false negative. An AI must not apply the method merely because a list looks approximately sorted or because most entries appear in order.
26. Duplicate values require a different question
Our fixture contains unique codes. If a sorted list has repeated entries, ordinary binary search can find a matching position, but a user may instead ask for the first match, last match or every record with the value.
Those require suitable boundary-search rules and identity checks. A returned match does not automatically prove only one record exists.
27. Numeric order differs from text order
The strings “10” and “2” sort differently as text than the integers 10 and 2. Lexicographically, “10” may come before “2”; numerically, 2 is smaller.
An AI should verify the type and comparator. If the list is sorted as text but comparisons are performed numerically, the binary-search assumption can be violated even though the original sort was consistent under its own rule.
28. Why the same comparator matters
Search and sorting must use consistent definitions of less than, greater than and equality. A case-insensitive title sort needs matching comparison rules during lookup.
Inconsistent comparison can make an algorithm appear broken when the real problem is that the query and index use different order conventions. A reliable system records its comparator with the data.
29. Search results still have evidence limits
Binary search can prove absence from a known complete finite list under the algorithm’s conditions. It cannot by itself verify whether the list covers every physical book or is current.
An incomplete catalogue may omit a physical item. That is an evidence problem rather than a failure of the binary-search mathematics. The search’s conclusion must stay within the dataset that was actually examined.
30. Twenty-four claims for an AI to classify
Mark each statement SUPPORTED, CONTRADICTED or NOT ESTABLISHED under the frozen fifteen-entry list and the two search traces. Supported statements follow from the list or arithmetic. Contradicted claims conflict with it. Not-established claims demand information about real books or outside repositories.
The task distinguishes what a correctly implemented search proves about its own indexed data from what it cannot establish about the world.
- 01. “The list contains fifteen codes” — SUPPORTED.
- 02. “The codes are strictly ascending” — SUPPORTED.
- 03. “Position 8 contains 146” — SUPPORTED.
- 04. “Position 11 contains 173” — SUPPORTED.
- 05. “Position 12 contains 184” — SUPPORTED.
- 06. “The first comparison for target 173 checks 146” — SUPPORTED.
- 07. “The second comparison for target 173 checks 184” — SUPPORTED.
- 08. “The third comparison for target 173 checks 161” — SUPPORTED.
- 09. “Target 173 is found after four comparisons” — SUPPORTED.
- 10. “Target 173 is at one-based position 10” — CONTRADICTED.
- 11. “The target 150 is present in the frozen list” — CONTRADICTED.
- 12. “The target 150 search makes four comparisons” — SUPPORTED.
- 13. “The target 150 search ends with an empty candidate interval” — SUPPORTED.
- 14. “The neighbouring indexed values around 150 are 146 and 152” — SUPPORTED.
- 15. “Target 146 can be found with one comparison” — SUPPORTED.
- 16. “Target 102 is at position 1” — SUPPORTED.
- 17. “The specified search trace for 102 takes four comparisons” — SUPPORTED.
- 18. “Binary search is valid without knowing whether the entries are sorted” — CONTRADICTED.
- 19. “The target 150 is nonexistent in every library in the world” — NOT ESTABLISHED.
- 20. “The source proves a physical copy with code 173 is currently borrowable” — NOT ESTABLISHED.
- 21. “The list contains the number 219 at position 15” — SUPPORTED.
- 22. “The code at position 9 is 152” — SUPPORTED.
- 23. “A near code is automatically an exact identity match” — CONTRADICTED.
- 24. “The index is a fictional example, not a live library database” — SUPPORTED.
31. Reconcile the twenty-four labels
The answer key contains 18 SUPPORTED, 4 CONTRADICTED and 2 NOT ESTABLISHED statements. They sum to 24. Every supported lookup fact can be recovered from the exact list and search traces.
The unknown claims concern real-world book ownership and availability outside this artificial index. A search method verifies its defined input, not records that were never supplied.
32. A classroom paper-card activity
Write the fifteen numeric codes onto cards and arrange them in ascending order. Have pupils search for 173 by checking only the middle cards and moving the visible candidate-range markers.
Repeat with absent target 150, and ask why the final two neighbouring codes do not count as a match. The physical movement helps pupils see how the range is cut rather than merely memorise a formula.
33. A transfer exercise with dictionary words
A dictionary sorted alphabetically can support a related middle-first search for a word. Compare the target against the midpoint word, then use alphabetical order to choose the remaining half.
Real digital dictionaries may use richer indexes and language-specific rules. The useful conceptual idea is that ordering gives information which allows large groups of impossible candidates to be removed.
34. A transfer exercise with score thresholds
Suppose a sorted list contains increasingly high qualifying scores and a teacher wants the first value at least seventy-five. A lower-bound variant of binary search can find the boundary without enumerating every score.
This differs from searching for an exact 75: a suitable answer may be a value above 75 if the exact number is absent. The assistant must distinguish exact lookup from threshold lookup.
35. What should an AI do when data are unsorted?
If the collection is unsorted, a direct linear search may be appropriate, or the system can sort the data first when permitted and worthwhile. Sorting adds a preprocessing cost.
Repeated queries against the same dataset may justify maintaining an index, while a one-time query on a very short list may not. The algorithm choice depends on the actual data structure and task.
36. A software implementation must handle empty ranges
An implementation can maintain lower and upper index bounds. When the lower bound exceeds the upper bound, no candidate remains and the exact-search procedure returns not found.
A common programming mistake is updating a bound without excluding the failed midpoint, leading to an infinite loop or repeated comparison. Testing the last one-element interval is therefore important.
37. A high-quality AI explanation
“I searched the fifteen sorted fictional codes for 173. Midpoint comparisons were 146, 184, 161 and 173, so the target was found at position 11. Searching the same list for 150 exhausted the candidate interval after comparing 146, 184, 161 and 152.”
This explanation provides the actual source scope and reproducible trace. It does not claim that an external catalogue was searched or that a real book is available.
38. The central lesson
Binary search is powerful because it uses a reliable ordering to remove half the candidates repeatedly. Its correctness depends on the list, comparator, midpoint rules and accurate handling of search boundaries.
A trustworthy AI assistant should exploit sorted data when appropriate while preserving the difference between a result inside one index and a claim about the whole world. Faster search does not remove the need for good evidence.
Frequently asked questions
- What is binary search? — A midpoint-based search that repeatedly halves a sorted candidate range.
- Must the data be sorted? — Yes, under a consistent comparator for the algorithm’s guarantee.
- How many comparisons find 173 here? — Four.
- Why is 150 absent? — Its exact numeric value is not among the fifteen listed identifiers.
- Does 152 count as a match for 150? — No, they are distinct identifiers.
- Does not found mean the book does not exist anywhere? — No, only that the search found no match in its defined source.
- Can the same technique find a threshold boundary? — Yes, with an appropriate lower- or upper-bound variant.
Connected reading and authoritative resources
- How Super Intelligence Works — main curriculum.
- Negative Evidence — limits of an empty search result.
- Ranking and Filtering — how ordered candidates are used.
- Greedy Algorithms — another fundamental strategy.
- Python bisect module — maintaining sorted arrays and locating insertion points.
- NIST Dictionary of Algorithms and Data Structures: Binary Search — the ordered-list method.