46:"/_next/static/chunks/33yus346z0l_n.js" 47:"/_next/static/chunks/1r8ezocsukqp8.js" 48:"/_next/static/chunks/0iv56yrji_20j.js" 49:"/_next/static/chunks/0wa9m1-tphf9u.js" 4a:"/_next/static/chunks/08cuqqn_f60pp.js" 4b:"/_next/static/chunks/3zdsl3f9b0--r.js" 4c:"/_next/static/chunks/2j22cxchii_xx.js" 4d:"/_next/static/chunks/3bgoyiso1rhn7.js" 4e:"/_next/static/chunks/01a-3hvnqu8wl.js" 4f:"/_next/static/chunks/3m1xjj5kw5fie.js" 50:"/_next/static/chunks/0om3fkgfnicab.js" 51:"/_next/static/chunks/0gafyzg9j9yqj.js" 52:"/_next/static/chunks/20w4eaqlekefm.js" 53:"/_next/static/chunks/449--h5z1s6nq.js" 54:"/_next/static/chunks/3k2gyg36fnag_.js" 55:"/_next/static/chunks/18ggtgz2yf759.js" 56:"/_next/static/chunks/0hlb44ca7-4a2.js" 57:"/_next/static/chunks/253gnmj0-cj17.js" 58:"/_next/static/chunks/09nq57stwzkgf.js" 59:"/_next/static/chunks/082jo-0ajazgr.js" 5a:"/_next/static/chunks/2ozcrjb_hh74t.js" 5b:"/_next/static/chunks/05i8en-x14ibi.js" 5c:"/_next/static/chunks/32izpn90gvm22.js" 5d:"/_next/static/chunks/0jbzid2v9xv3h.js" 5e:"/_next/static/chunks/0i3-eynrkvqi7.js" 5f:"/_next/static/chunks/1tn-0fivsxsv1.js" 60:"/_next/static/chunks/34h36hyf_ggow.js" 61:"/_next/static/chunks/20329i6m_04t6.js" 62:"/_next/static/chunks/161uxd62cjny2.js" 63:"/_next/static/chunks/2k8pepwc4pxns.js" 64:I[593304,["$2b","$2c","$2d","$2e","$2f","$30","$46","$47","$48","$49","$4a","$4b","$4c","$4d","$4e","$4f","$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63"],"OwnedHydration"] 65:T468,// UNSORTED ARRAY: No elimination possible function linearSearch(arr: number[], target: number): number { // Each element must be checked individually // Checking arr[i] tells us nothing about arr[j] for j ≠ i for (let i = 0; i < arr.length; i++) { if (arr[i] === target) return i; } return -1; } // Time: O(n) — no elimination possible // SORTED ARRAY: Massive elimination possible function binarySearch(arr: number[], target: number): number { let left = 0, right = arr.length - 1; while (left <= right) { const mid = left + Math.floor((right - left) / 2); if (arr[mid] === target) { return mid; // Found } else if (arr[mid] < target) { // KEY INSIGHT: All elements arr[left..mid] are < target // They can ALL be eliminated with a single comparison! left = mid + 1; // Eliminate left half } else { // All elements arr[mid..right] are > target right = mid - 1; // Eliminate right half } } return -1; } // Time: O(log n) — half eliminated each step66:T53e,/** * Search in a row-sorted and column-sorted matrix * * Matrix property: Each row is sorted left-to-right * Each column is sorted top-to-bottom * * Start from top-right corner: * - If current > target: eliminate entire column (all below are larger) * - If current < target: eliminate entire row (all left are smaller) */ function searchMatrix(matrix: number[][], target: number): boolean { if (!matrix.length || !matrix[0].length) return false; let row = 0; let col = matrix[0].length - 1; while (row < matrix.length && col >= 0) { const current = matrix[row][col]; if (current === target) { return true; // Found! } else if (current > target) { // Current is too big. Since column is sorted (top-to-bottom), // ALL elements below current are also too big. // ELIMINATE THE ENTIRE COLUMN col--; } else { // Current is too small. Since row is sorted (left-to-right), // ALL elements to the left are also too small. // ELIMINATE THE ENTIRE ROW row++; } } return false; // Exhausted search space } // Time: O(m + n) — we eliminate one row or one column per step // Without elimination: O(m × n) to check every cell67:T4d8,// BUGGY: Infinite loop when target is not present function binarySearchBuggy(arr: number[], target: number): number { let left = 0, right = arr.length - 1; while (left < right) { // BUG 1: Should be <= const mid = Math.floor((left + right) / 2); if (arr[mid] === target) { return mid; } else if (arr[mid] < target) { left = mid; // BUG 2: Should be mid + 1 } else { right = mid; // BUG 3: Should be mid - 1 } } return -1; // Never reached if left = right and arr[left] = target } // CORRECT: Proper elimination ensures termination function binarySearchCorrect(arr: number[], target: number): number { let left = 0, right = arr.length - 1; while (left <= right) { // ✓ Include single-element case const mid = left + Math.floor((right - left) / 2); // ✓ Avoid overflow if (arr[mid] === target) { return mid; } else if (arr[mid] < target) { left = mid + 1; // ✓ Eliminate mid (already checked) } else { right = mid - 1; // ✓ Eliminate mid (already checked) } } return -1; // Correctly returns -1 when not found }45:["$","$L64",null,{"owner":"anonymous","state":{"mutations":[],"queries":[{"dehydratedAt":1792320177570,"state":{"data":{"json":{"id":"seed_748fc354d5049d470131b66b8b9205ce","slug":"search-space-reduction-patterns","category":"Data Structures & Algorithms","topic":"Search Space Reduction Patterns","title":"Search Space Reduction Patterns","description":"Master the art of eliminating impossible regions, maintaining search invariants, and applying half-interval elimination. Learn to think in terms of search space reduction—a paradigm that underlies not just binary search, but countless efficient algorithms.","difficulty":"INTERMEDIATE","estimatedMinutes":60,"pages":[{"id":"seed_a98ab615b3ded68418f3769ffc552ebf","title":"Eliminating Impossible Regions","order":0,"content":[{"id":"opening-hook","title":"The Art of Knowing Where Not to Look","content":[{"data":{"content":"Imagine you're searching for a specific book in a vast library. A novice might walk through every aisle, examining each shelf systematically. But a seasoned librarian knows something profound: **the most efficient way to find something is often by eliminating where it cannot be**.\n\nIf you're looking for a book on quantum physics, you don't need to check the fiction section, the cooking aisle, or the children's area. By understanding the library's organization, you've eliminated perhaps 80% of the search space before examining a single book.\n\nThis principle—**eliminating impossible regions**—is the philosophical foundation of efficient search algorithms. It's not about searching faster through everything; it's about searching through dramatically less."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will understand: (1) the formal concept of search space and how to reason about it mathematically, (2) how impossibility arguments enable exponential speedups, (3) the conditions under which regions can be safely eliminated, and (4) how this principle transforms naive algorithms into elegant, efficient solutions.","variant":"info"},"type":"callout"}]},{"id":"defining-search-space","title":"Defining the Search Space","content":[{"data":{"content":"Before we can eliminate regions, we must rigorously define what we mean by a **search space**. This formalization is critical—sloppy thinking about search spaces leads to incorrect algorithms.\n\n**Definition:** A search space is the complete set of candidate solutions that an algorithm must consider to guarantee finding the correct answer.\n\nLet's denote the search space as **S**. For any search problem, we can characterize it with three components:"},"type":"text"},{"data":{"type":"ordered","items":["**Search Space S** — The universe of all possible candidates. In array search, this is all indices [0, n-1]. In a chess engine, it's all possible game states.","**Target Predicate P(x)** — A boolean function that identifies valid solutions. P(x) = true if and only if x is a solution we're seeking.","**Structure/Properties** — Any known relationships between elements of S that allow us to reason about groups rather than individuals."],"title":{"icon":"Layers","text":"Components of a Search Problem","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**The size of S determines the baseline complexity.** If S contains n elements and we have no structural knowledge, we must examine all n elements in the worst case—giving O(n) complexity. The goal of search space reduction is to exploit structure to examine far fewer than n elements."},"type":"text"},{"data":{"code":"// Conceptually, any search algorithm works within this framework\ninterface SearchProblem {\n // The complete search space - all possible candidates\n searchSpace: T[];\n \n // The target predicate - returns true for solutions\n isTarget: (candidate: T) => boolean;\n \n // Optional: Structure that enables elimination\n canEliminate?: (region: T[]) => boolean;\n}\n\n// Example: Finding a value in a sorted array\nconst binarySearchProblem: SearchProblem = {\n // S = all indices [0, n-1]\n searchSpace: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n \n // P(x) = array[x] === target\n isTarget: (index) => sortedArray[index] === target,\n \n // We can eliminate half the indices based on one comparison\n canEliminate: (indices) => {\n // If we know the middle element is less than target,\n // we can eliminate all indices less than or equal to middle\n return true; // The \"how\" is the algorithm's logic\n }\n};","title":"Search Space: Conceptual Framework","language":"typescript","description":"Abstracting the search problem as a formal structure"},"type":"code"},{"data":{"icon":"Info","title":"Abstract vs. Concrete Search Spaces","content":"Sometimes the search space is explicit (an array of values). Sometimes it's implicit (all possible arrangements, all paths through a graph, all subsets of items). The principles of elimination apply equally—we just need to think carefully about what constitutes the 'space' we're searching.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":1},{"id":"elimination-principle","title":"The Elimination Principle","content":[{"data":{"content":"At the heart of efficient search lies a deceptively simple principle:\n\n> **If we can prove that a subset R ⊆ S cannot contain the target, we can safely remove R from consideration without examining any of its elements.**\n\nThis sounds obvious, but its implications are profound. Consider the mathematics:"},"type":"text"},{"data":{"content":"**Quantitative Impact of Elimination:**\n\nLet S be our initial search space with |S| = n elements.\n\nAfter eliminating region R with |R| = k elements, we have:\n- Remaining search space: S' = S - R\n- Size: |S'| = n - k\n\nIf we can repeatedly eliminate a constant fraction of the remaining space:\n- After 1 elimination: n/2 elements remain\n- After 2 eliminations: n/4 elements remain\n- After 3 eliminations: n/8 elements remain\n- After k eliminations: n/2^k elements remain\n\n**Solving for when 1 element remains:** n/2^k = 1 → k = log₂(n)\n\nThis is the magic of binary search: by eliminating half the search space with each step, we reduce n elements to 1 in just O(log n) steps. The exponential reduction in search space translates to logarithmic time complexity."},"type":"text"},{"data":{"rows":[["1 element (constant)","n - 1 steps","O(n)"],["1/10 of remaining","log₁₀(n) · constant steps","O(log n)"],["1/3 of remaining","log₁.₅(n) steps","O(log n)"],["1/2 of remaining","log₂(n) steps","O(log n)"],["2/3 of remaining","log₃(n) steps","O(log n)"],["√n elements","log(n) / log(√n) = 2 steps","O(log n)"]],"caption":"Impact of Elimination Ratio on Complexity","headers":["Elimination Ratio per Step","Steps to Find Target","Time Complexity"]},"type":"table"},{"data":{"icon":"AlertTriangle","title":"The Elimination Must Be Sound","content":"The power of elimination comes with a critical requirement: we must be absolutely certain the eliminated region cannot contain the target. A false elimination can cause the algorithm to miss the correct answer entirely. This is why rigorous invariants are essential—they guarantee our eliminations are sound.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":2},{"id":"conditions-safe-elimination","title":"Conditions for Safe Elimination","content":[{"data":{"content":"Not every search space admits efficient elimination. Certain structural properties must hold. Understanding these conditions helps us recognize when elimination-based algorithms are applicable.\n\n**The Fundamental Question:** Given limited information (typically O(1) queries), can we prove that a large portion of the search space is eliminable?\n\nThis depends on the search space's **structure** and our ability to exploit it:"},"type":"text"},{"data":{"items":["**Order (Monotonicity)** — Elements are arranged in a defined order. If we know element at position i has a certain property, we can deduce properties of elements before or after i. This is the classic enabler for binary search.","**Transitivity** — If position A relates to position B, and B to C, then A relates to C. This allows conclusions to cascade across regions.","**Locality** — Elements 'near' each other share properties. If a region's boundary has a certain property, interior elements likely do too.","**Partitioning Structure** — The space naturally divides into non-overlapping regions with predictable properties. Decision trees exploit this.","**Exclusivity** — Finding the target at one location implies it cannot exist elsewhere (for unique-target problems). This ensures each elimination is permanent."],"title":{"icon":"CheckCircle","text":"Properties That Enable Elimination","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**Counter-example: When Elimination Fails**\n\nConsider searching an unsorted array for a specific value. After checking position i:\n- If array[i] = target, we're done\n- If array[i] ≠ target, what have we learned?\n\nNothing about any other position! The element at position j could be anything regardless of what position i contained. Without order or structure, we cannot eliminate any region—we're forced to linear search.\n\nThis is why **preprocessing costs matter**. Sorting an array takes O(n log n), but enables O(log n) searches. If you perform multiple searches, the preprocessing pays for itself."},"type":"text"},{"data":{"code":"$65","title":"Contrasting Structured vs. Unstructured Search","language":"typescript","description":"The presence of structure determines whether elimination is possible"},"type":"code"},{"data":{"icon":"Scale","title":"The Sorting Tax","content":"When is sorting worth it? If you have an unsorted array of n elements and need to perform k searches: Linear search per query: O(k · n), Sort once + binary search: O(n log n + k · log n). Sorting wins when k > log n. For large datasets with many queries, preprocessing is almost always worthwhile.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":3},{"id":"visualizing-reduction","title":"Visualizing Search Space Reduction","content":[{"data":{"content":"One of the most powerful ways to internalize search space reduction is through visual reasoning. Let's trace through a binary search execution to see elimination in action.\n\n**Problem:** Find target = 42 in sorted array [3, 7, 14, 23, 31, 42, 55, 67, 78, 91]"},"type":"text"},{"data":{"rows":[["1","[0-9] (10 elements)","4","31","31 < 42","Eliminate [0-4], keep [5-9]"],["2","[5-9] (5 elements)","7","67","67 > 42","Eliminate [7-9], keep [5-6]"],["3","[5-6] (2 elements)","5","42","42 = 42","Found at index 5!"]],"caption":"Binary Search Trace: Watching the Search Space Shrink","headers":["Step","Search Space","Mid Index","Mid Value","Comparison","Action"]},"type":"table"},{"data":{"content":"**Visual Evolution of the Search Space:**\n\n```\nInitial: [3, 7, 14, 23, 31, 42, 55, 67, 78, 91]\n ↑ ↑\n left=0 right=9\n ↑\n mid=4 (value=31 < 42)\n\nAfter Step 1: Eliminate indices 0-4\n [3, 7, 14, 23, 31, 42, 55, 67, 78, 91]\n ╳ ╳ ╳ ╳ ╳ ↑ ↑\n (eliminated) left=5 right=9\n ↑\n mid=7 (value=67 > 42)\n\nAfter Step 2: Eliminate indices 7-9\n [3, 7, 14, 23, 31, 42, 55, 67, 78, 91]\n ╳ ╳ ╳ ╳ ╳ ↑ ↑ ╳ ╳ ╳\n left=5 right=6\n ↑\n mid=5 (value=42 = 42) ✓\n```\n\nIn just 3 comparisons, we examined only 3 elements (positions 4, 7, 5) out of 10. The remaining 7 elements were eliminated through logical deduction, never examined."},"type":"text"},{"data":{"icon":"Lightbulb","title":"The Power of Deduction","content":"Notice that we never compared target against values 3, 7, 14, 23, 55, 67, 78, or 91. We *knew* they couldn't be the answer because of the sorted order and our previous comparisons. This is the essence of elimination—deducing impossibility without direct examination.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":4},{"id":"beyond-binary-search","title":"Elimination Beyond Binary Search","content":[{"data":{"content":"While binary search is the canonical example, the elimination principle appears throughout computer science in various guises. Understanding the pattern helps you recognize opportunities in novel problems."},"type":"text"},{"data":{"items":["**Branch and Bound** — In optimization, we compute bounds on subproblems. If a branch's best possible solution is worse than our current best, the entire branch is eliminated. This prunes exponential search trees dramatically.","**Alpha-Beta Pruning** — In game-tree search, if we know a position leads to a bad outcome for the current player, we skip exploring its subtrees. Chess engines would be impossibly slow without this elimination.","**Constraint Propagation** — In constraint satisfaction, assigning a variable can eliminate values from other variables' domains. Sudoku solvers use this extensively—placing a '5' eliminates '5' from the entire row, column, and box.","**Database Query Optimization** — Indexes enable 'early termination' by eliminating rows that cannot match predicates. A B-tree index lets us skip irrelevant disk pages entirely.","**Bloom Filters** — A probabilistic structure that definitively answers 'not present' but may have false positives for 'present'. When it says 'no', we eliminate expensive lookups.","**Graph Search Pruning** — In pathfinding, if we know the minimum distance to a goal exceeds our budget, we prune that path. A* search's heuristic enables massive elimination."],"title":{"icon":"Workflow","text":"Elimination Patterns in Different Domains","type":"icon","color":"primary","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"code":"$66","title":"Elimination in a 2D Sorted Matrix","language":"typescript","description":"When structure exists in two dimensions, we eliminate rows AND columns"},"type":"code"},{"data":{"content":"**The Staircase Pattern:**\n\nNotice how the algorithm traces a 'staircase' path through the matrix—moving left or down but never right or up. Each step eliminates an entire row or column:\n\n```\n 1 4 7 11 [15] ← Start top-right\n 2 5 8 12 [19] ↓ eliminated\n 3 6 9 16 [22] (if 15 > target, column 4 gone)\n 10 13 14 17 [24]\n\n→ eliminated ← (if 15 < target, row 0 gone)\n```\n\nThis is elimination at work in 2D: instead of n² cell checks, we make at most m + n steps because each step permanently removes one row *or* one column."},"type":"text"}],"titleType":"number","titleNumber":5},{"id":"philosophy-of-elimination","title":"The Philosophy of Elimination","content":[{"data":{"content":"Elimination-based thinking represents a fundamental shift in how we approach problem-solving. Rather than asking \"which candidate is correct?\", we ask **\"which candidates are provably incorrect?\"**\n\nThis shift has profound implications:"},"type":"text"},{"data":{"left":[{"data":{"items":["Check each candidate one by one","Ask 'Is this the answer?'","Progress is +1 candidate examined","Worst case equals average case","No exploitation of structure"],"title":{"icon":"XCircle","text":"Direct Search Mindset","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"accent"},"type":"list"}],"right":[{"data":{"items":["Prove regions impossible","Ask 'Why can't it be here?'","Progress is ÷2 (or more) candidates remaining","Average case dramatically faster","Actively seeks and exploits structure"],"title":{"icon":"CheckCircle","text":"Elimination Mindset","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"}]},"type":"two-column"},{"data":{"content":"**Sherlock Holmes' Method:**\n\n> \"When you have eliminated the impossible, whatever remains, however improbable, must be the truth.\" — Arthur Conan Doyle\n\nHolmes' approach mirrors optimal search algorithms. He doesn't check every person in London to find a culprit. He uses deduction to eliminate the impossible, narrowing the field until only the truth remains.\n\n**Designing for Elimination:**\n\nWhen you encounter a new search problem, train yourself to ask:\n\n1. What is the search space? How large is it?\n2. What structure exists? (order, partitioning, constraints)\n3. What single observation could eliminate a large region?\n4. Can I design my search to maximize elimination per observation?\n\nThis is the thought process that leads from O(n) algorithms to O(log n) algorithms. It's not about being clever—it's about systematically exploiting structure."},"type":"text"},{"data":{"icon":"Lightbulb","title":"The 80/20 Rule of Search","content":"In many search problems, a single well-chosen observation can eliminate 80% or more of the search space. Finding these high-leverage observations is the art of algorithm design. Binary search achieves exactly 50% elimination per step—but that's enough to turn O(n) into O(log n).","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":6},{"id":"common-mistakes","title":"Common Mistakes in Elimination","content":[{"data":{"content":"The elegance of elimination can lead to subtle errors. Here are critical mistakes to avoid:"},"type":"text"},{"data":{"items":["**False Elimination** — Incorrectly concluding a region is impossible when it actually contains the target. This causes the algorithm to miss valid solutions. Always verify your elimination logic with rigorous invariants.","**Off-by-One Errors** — Eliminating one too many or one too few elements. In 'left = mid + 1', forgetting the '+1' includes an already-checked element, potentially causing infinite loops.","**Incorrect Inequality Direction** — Confusing < with ≤, or > with ≥. In a sorted array, 'arr[mid] < target' means mid could not be the answer, but 'arr[mid] ≤ target' includes the target case!","**Assuming Structure That Doesn't Exist** — Applying binary search to unsorted data, or assuming monotonicity when the function isn't actually monotonic.","**Non-Exhaustive Elimination** — Failing to consider all cases. If your elimination covers 'target < mid' and 'target > mid' but not 'target = mid', you'll miss exact matches."],"title":{"icon":"AlertTriangle","text":"Elimination Pitfalls","type":"icon","color":"accent","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"code":"$67","title":"Classic Off-by-One Error in Binary Search","language":"typescript","description":"A subtle bug that can cause infinite loops"},"type":"code"},{"data":{"icon":"AlertCircle","title":"The Infinite Loop Trap","content":"The most dangerous elimination bug is the infinite loop: when left = mid creates a scenario where 'left' never advances. Always ensure that your update guarantees progress—the search space MUST shrink on every iteration. Use 'mid + 1' or 'mid - 1' to exclude already-checked elements.","variant":"error"},"type":"callout"}],"titleType":"number","titleNumber":7},{"id":"summary","title":"Summary: The Power of Elimination","content":[{"data":{"content":"We've explored the foundational principle underlying efficient search: **elimination of impossible regions**. Let's consolidate the key insights:"},"type":"text"},{"data":{"type":"ordered","items":["**Search space is the universe of candidates** — Understanding its size and structure is the first step to efficient algorithms.","**Elimination enables exponential speedups** — Removing half the search space per step transforms O(n) to O(log n).","**Structure enables elimination** — Sorted order, transitivity, and partitioning allow us to deduce properties of unexamined elements.","**Without structure, elimination is impossible** — Unsorted arrays force linear search. Preprocessing (sorting) can add structure.","**Elimination must be sound** — Incorrect elimination causes missed solutions. Rigorous invariants prevent this.","**The principle is universal** — From binary search to branch-and-bound to database indexes, elimination powers efficient algorithms across domains."],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**Looking Ahead:**\n\nElimination is step one—but how do we *guarantee* our eliminations are correct throughout an algorithm's execution? This is where **invariants** come in. In the next page, we'll explore how to maintain precise logical conditions that ensure our search remains valid even as the search space shrinks.\n\nInvariants transform the art of elimination into a rigorous science."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now understand the philosophical and mathematical foundation of search space reduction: elimination of impossible regions. This principle—proving where the answer cannot be—is the key insight behind all logarithmic search algorithms. Next, we'll learn how to maintain invariants that guarantee our eliminations are always correct.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":8}],"isLocked":false},{"id":"seed_ea192d8f6b0b03a5802bf83e3ec3b8b7","title":"Maintaining Invariants During Search","order":1,"content":null,"isLocked":true},{"id":"seed_66bcdd540062bf1d3bd2b14262151ea2","title":"Half-Interval Elimination","order":2,"content":null,"isLocked":true},{"id":"seed_e001987d3cdf8bb04425a991d92fac2d","title":"General Problem-Solving with Search Reduction","order":3,"content":null,"isLocked":true}]}},"dataUpdateCount":1,"dataUpdatedAt":1792320177564,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["learningContent","getModule"],{"input":{"slug":"search-space-reduction-patterns"},"type":"query"}],"queryHash":"[[\"learningContent\",\"getModule\"],{\"input\":{\"slug\":\"search-space-reduction-patterns\"},\"type\":\"query\"}]"},{"dehydratedAt":1792320177572,"state":{"data":{"json":null},"dataUpdateCount":1,"dataUpdatedAt":1792320177569,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["learningContent","getProgress"],{"input":{"moduleId":"seed_748fc354d5049d470131b66b8b9205ce"},"type":"query"}],"queryHash":"[[\"learningContent\",\"getProgress\"],{\"input\":{\"moduleId\":\"seed_748fc354d5049d470131b66b8b9205ce\"},\"type\":\"query\"}]"},{"dehydratedAt":1792320177572,"state":{"data":{"json":null},"dataUpdateCount":1,"dataUpdatedAt":1792320177570,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["feedback","get"],{"input":{"contentType":"LEARNING_PAGE","contentId":"seed_ea192d8f6b0b03a5802bf83e3ec3b8b7"},"type":"query"}],"queryHash":"[[\"feedback\",\"get\"],{\"input\":{\"contentId\":\"seed_ea192d8f6b0b03a5802bf83e3ec3b8b7\",\"contentType\":\"LEARNING_PAGE\"},\"type\":\"query\"}]"},{"dehydratedAt":1792320177572,"state":{"data":{"json":null},"dataUpdateCount":1,"dataUpdatedAt":1792320177570,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["feedback","getUserLike"],{"input":{"contentType":"LEARNING_PAGE","contentId":"seed_ea192d8f6b0b03a5802bf83e3ec3b8b7"},"type":"query"}],"queryHash":"[[\"feedback\",\"getUserLike\"],{\"input\":{\"contentId\":\"seed_ea192d8f6b0b03a5802bf83e3ec3b8b7\",\"contentType\":\"LEARNING_PAGE\"},\"type\":\"query\"}]"},{"dehydratedAt":1792320177572,"state":{"data":{"json":[]},"dataUpdateCount":1,"dataUpdatedAt":1792320177570,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["highlights","getHighlights"],{"input":{"contentType":"LEARNING_PAGE","contentId":"seed_ea192d8f6b0b03a5802bf83e3ec3b8b7"},"type":"query"}],"queryHash":"[[\"highlights\",\"getHighlights\"],{\"input\":{\"contentId\":\"seed_ea192d8f6b0b03a5802bf83e3ec3b8b7\",\"contentType\":\"LEARNING_PAGE\"},\"type\":\"query\"}]"},{"dehydratedAt":1792320177572,"state":{"data":"$undefined","dataUpdateCount":0,"dataUpdatedAt":0,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"pending","fetchStatus":"fetching"},"queryKey":[["highlights","getPopularHighlights"],{"input":{"contentType":"LEARNING_PAGE","contentId":"seed_ea192d8f6b0b03a5802bf83e3ec3b8b7","minCount":2},"type":"query"}],"queryHash":"[[\"highlights\",\"getPopularHighlights\"],{\"input\":{\"contentId\":\"seed_ea192d8f6b0b03a5802bf83e3ec3b8b7\",\"contentType\":\"LEARNING_PAGE\",\"minCount\":2},\"type\":\"query\"}]","promise":"$@68"}]},"children":"$L69"}]