Chapter 21 Exercises: Mental Models

Exercise 1: Schema Mapping

Time required: 30–45 minutes Best for: Any domain where you've been building knowledge

This exercise makes your current schema visible — so you can see where it's rich, where it's sparse, and where it needs to be built.

Step 1: Free map Take a blank page. Write your domain in the center (or a sub-domain — "cardiovascular physiology," "machine learning," "classical harmony"). Set a timer for 10 minutes and write everything you know that connects to that central concept. Use lines to show connections. Label the connections (causes, prevents, requires, is-a-type-of, contrasts-with).

Don't worry about completeness or correctness — just map what you currently have.

Step 2: Analysis Look at your map: - Where are the clusters of richly connected knowledge? - Where are isolated facts with no connections? - Where are there nodes that should connect but you don't know how they connect? - Where are there gaps you know exist but can't yet fill?

Step 3: Prioritization Identify three areas where you could meaningfully strengthen your schema by building more connections. For each: what specific knowledge would you need to acquire to build those connections?

Exercise 2: The Self-Explanation Protocol

Time required: 30–45 minutes (can extend any study session) What you need: A worked example from your domain — a solved problem, a case study, a proof, a diagnosis

Take any worked example from your domain and apply the self-explanation protocol:

For every step in the worked example, before reading the explanation (if one is provided), ask yourself: 1. Why is this the next step? What principle determines that this is what should happen here? 2. What would happen if this step were skipped? What would go wrong? 3. How does this step connect to what came before? What is the causal link? 4. Is this a specific instance of a general pattern? If so, name the pattern.

After completing the example with self-explanation, close your notes and try to reconstruct the reasoning — not the steps, but the reasoning. "At this point, we needed to do X because of principle Y. Then because of Z, the next move was..."

The check: If you can reconstruct the reasoning without the steps, you've built schema. If you can only recall the steps without the reasoning, you have procedural knowledge that may not transfer.

Exercise 3: The Comparison Method

Time required: 30–40 minutes What you need: Three examples of the same concept from different contexts

This exercise uses comparison to extract abstract schemas — one of the fastest paths to transferable conceptual knowledge.

Step 1: Identify a concept you want to deepen your understanding of.

Step 2: Find three different examples of this concept, drawn from as different contexts as possible. (If you're studying feedback control, one example might be a thermostat, one might be a biological regulation system, one might be a business pricing mechanism.)

Step 3: For each example, describe it without using the concept's name — just describe what's happening structurally.

Step 4: Find the shared structure. What is the same across all three descriptions? This shared structure is your abstract schema.

Step 5: Write a definition of the concept that captures only the shared structure — no specific examples. This is the most portable, transferable form of the concept.

Step 6: Generate a fourth example from a domain you haven't yet connected to this concept. Does your abstract definition apply?

Exercise 4: Case Library Building

Time required: Ongoing practice, 15 minutes per case

Expert knowledge is partly stored as case libraries — organized memories of specific instances that exemplify principles. This exercise builds your case library deliberately.

For any case, worked example, or real incident you encounter in your domain:

Write a case note with four components: 1. Situation: What was the specific situation? (Brief, specific description) 2. Key feature: What was the diagnostic, identifying, or critical feature of this case? What made it what it was rather than something else? 3. Resolution: How did it resolve, and why? What principle determined the outcome? 4. Pattern label: What category does this case exemplify? If you encountered a similar case in a different context, what would you call it?

Over time, review your case library regularly: - Are patterns emerging across multiple cases? - Are there cases that you initially categorized one way but now see differently? - Can you predict what would happen in a novel variation of each case?

Exercise 5: The Navigable Model Test

Time required: 20–30 minutes

This exercise tests whether your knowledge is navigable — structured enough to reason through, not just recall from.

Choose an area of your domain where you believe you have solid knowledge. Then answer these questions without looking at your notes:

  1. Starting point question: How would you explain [concept A] to someone who has never encountered it?

  2. Navigation question: Starting from [concept A], reason your way to [concept B] that you haven't directly studied in relation to A. Trace the connections.

  3. Prediction question: If [concept A] were modified in [specific way], what would be the downstream effects on [concept B] and [concept C]?

  4. Novel case question: Here is a situation you haven't seen before: [describe novel situation in your domain]. Based on your model, what would you predict? Why?

If you can answer questions 3 and 4 — the prediction and novel case questions — without looking things up, you have a working mental model, not just a collection of facts.

Exercise 6: Chunk Identification Practice

Time required: 20 minutes Best for: Pattern-heavy domains (chess, music, programming, mathematics)

This exercise is inspired directly by Chase and Simon's chess research: practicing recognizing patterns (chunks) in your domain rather than processing individual elements.

Step 1: Find a complex example in your domain — a chess position, a piece of music notation, a code snippet, a data structure diagram, a clinical case.

Step 2: Look at it for 30 seconds, then cover it.

Step 3: Reconstruct it from memory.

Step 4: Note: what did you remember as a unit (a chunk — you got all of it right because you recognized it as a pattern) versus what you remembered element by element (you got some right and some wrong because you were trying to memorize individual items)?

Step 5: For anything you reconstructed element-by-element: can you identify the underlying pattern or principle that would turn it into a chunk? If there's no pattern (random arrangement), that's expected — you can't chunk the unchunkable. If there is a pattern you missed — that's what you should study next.

Repeat this exercise regularly with increasingly complex examples. Over time, the chunks will grow — you'll recognize larger and larger patterns as units.