Mnemonic Systems

Mnemonic Systems Skill

This user has built an interconnected ecosystem for learning, memorizing, and problem-solving at maximum speed across code, math, languages, and domain knowledge.

*Design orientation (read first for why): the stack is aimed at (1) life skills & emotional intelligence, (2) digital & future-ready skills, (3) practical everyday skills, and (4) global citizenship & ethics — with worked examples biased toward STEAM (STEM + Arts) and STEMM (STEM + Medicine*) where high stakes demand extra care. See design-orientation.md for the mapping from those problems to specific protocols (gates, NAVIGATOR, NEDF, CAST, SPEAR, measurement).

The stack has four tiers for encoding and operations, plus an optional NAVIGATOR project wrap (navigator.md) for whole-unit learning — nine phases whose initials spell the word in order (Narrow → Acquire → View → Imprint → Gym → Act → Thread → Outline → Recalibrate).

1. Comprehension & problem-solving — how you understand and solve (not just store) 2. Non-numeric encoding — concepts, formulas, relational networks 3. Numeric encoding — numbers, dates, hex, binary, pegs 4. Operational layer — palaces, retrieval protocols, meta-monitoring

Memorizing this method

Helper: memorization-helpers.md — NEDF/SPEAR lens, minimal first session, stack placement.

---

The Full Stack

Project-scale learning (optional)
  NAVIGATOR               — nine phases: Narrow…Recalibrate (navigator.md)

Comprehension & problem-solving
  Comprehension Protocol  — 5 gates before encoding anything difficult
  Confusion Triage        — 5 kinds of stuck; matched moves for each
  Heuristic Palace        — 6 rooms + wings; walked when stuck on solving
  Domain Patterns         — pattern libraries per domain (algorithms, proofs, debug)
  TRIZ (condensed)        — contradictions, separation, 20 principles, matrix
  Metacognitive Checklist — self-audit during learning

Non-numeric encoding
  NEDF                    — concepts (Name · Essence · Distinguisher · Failure)
  SPEAR                   — procedures (Scene · Preconditions · Execution · Alternatives · Repair)
  Formulas                — symbols + zones (Greek, operators, positional structure)
  CAST + Georgian         — networks (nodes + edges, full relational system)

Numeric encoding
  SEM3                    — sensory prefix for 4-digit chunks
      └── Major           — 2-digit core (00–99 → word/image)
  PAO 10×10×10            — 3-digit chunks (Person + Action + Object)
  Peg Matrix              — 2-digit fallback, lists, simple sequences
  Hex / Binary            — hex values, bitfields, binary data

Operational layer
  Mind Palace             — spatial container for encoded content (`mind-palace.md`)
  ZLP + FRS               — physical zero-loss + Today Core forced recall (`zero-loss-forced-recall.md`)
  Retrieval Protocol      — Anki templates + palace-walk cadence + repair
  Collisions              — cross-system disambiguation rules
  Measurement Framework   — 6 dimensions + belt ranks + LPQ composite

---

Meta: Learning this ecosystem itself

The stack is large on purpose; onboarding is a separate skill from using any one subsystem.

• Memorization helpers (NEDF / SPEAR per method): references/memorization-helpers.md — for every stack doc and the main book workflows (beating-the-red-queen.md), a dedicated “how to memorize this” section: NEDF the protocol itself, SPEAR how to run it, Comprehension mapping, and a 15-minute first session.
• Onboarding path (minimal · mid · maximal): references/onboarding-path.md — week-by-week depth, promotion criteria, spacing defaults, pruning rules, cadence tables, under-load policy, and monthly verification against real sources.
• NAVIGATOR learning loop (optional): references/navigator.md — when taking on a whole unit (course week, large feature, cert block): learning contract, nine ordered phases (acronym = sequence), DOK depth checks, quick-start sprint, tie-in to measurement.
• Read SKILL for the map once, then follow onboarding for order and caps; return to SKILL when choosing which encoder fits a new kind of data.

---

System Reference

Comprehension & Problem-Solving (Tier 1)

These are the moves you make before encoding and when stuck. Comprehension protocols produce the understanding that encoding later stores. Problem-solving protocols apply that understanding under pressure.

C1. Comprehension Protocol (5 gates)

• 5 gates before encoding any difficult concept: Locate · Represent · Minimize · Falsify · Regenerate
• Full protocol: references/comprehension-protocol.md
• Role: produces the understanding that encoding stores. No encoding without passing all gates.
• When to use: any time you encounter a non-trivial new concept

C2. Confusion Triage Protocol

• 5 kinds of "stuck on understanding": Prerequisite gap · Tangled concepts · Wrong mental model · Missing representation · Scale mismatch
• Each has a matched move
• Full protocol: references/confusion-triage.md
• Role: the stuck-path companion to the Comprehension Protocol. When you can't understand, triage which kind of stuck you're in.
• When to use: whenever a comprehension attempt stalls

C3. Heuristic Palace (6 rooms + 4 wings)

• Fixed, permanent palace walked when stuck on solving a problem
• 6 core rooms: Understand · Reframe · Classify · Plan · Execute · Review
• 4 expansion wings: Debug · Proof · Design · Strategy
• ~50 loci total
• Full palace: references/heuristic-palace.md
• Role: the speed layer for problem-solving. Never stuck at a blank wall.
• When to use: any problem where you don't immediately see the path

C4. Domain Pattern Libraries

• ~30 patterns per domain (algorithms, proofs, debug signatures, design patterns, cognitive biases)
• Each pattern: Name · Signature · Mechanism · Canonical use · Variants · Failure mode · Encoding
• Full library structure + seed content: references/domain-patterns.md
• Role: real problem-solving speed comes from pattern recognition. Library grows with your actual work.
• When to use: after Heuristic Palace Room 3 (Classify), match against domain patterns

C5. Metacognitive Checklist

• Self-audit questions at 4 checkpoints: before / mid-session / end / next day
• 9 named self-deception patterns to recognize
• Weekly meta-review protocol
• Full checklist: references/metacognitive-checklist.md
• Role: object-level work without meta-monitoring regresses to mediocrity. This is the active correction layer.
• When to use: transverse — runs above all other systems

C6. TRIZ (Condensed Practical Subset)

• The contradiction-specialist toolkit: 4 moves — Ideality, Separation Principles, 20 Inventive Principles, 12×12 Contradiction Matrix
• Cross-domain (software, math, strategy, physical) — not engineering-only
• Full system: references/triz.md
• Integrated into Heuristic Palace: Ideality as Room 1 locus, 4 Separation loci in Room 2, Contradiction Matrix + 20 Principles in Design Wing
• Role: when a problem has a clear contradiction ("improving X worsens Y" or "must be A and ¬A"), this is the specialized tool
• When to use: after Heuristic Palace Room 1 reveals a contradiction; for design/invention problems; when generic heuristics aren't producing a breakthrough

Numeric Systems

1. Major System (foundation)

• Encodes 2-digit numbers (00–99) into concrete words/images
• Consonant mapping: S/Z=0, D/T=1, N=2, M=3, R=4, L=5, J/SH/CH=6, K/G=7, F/V=8, B/P=9
• Full table: references/major-system.md
• Role: anchor for any numeric encoding — always present as the final 2-digit image

2. PAO 10×10×10 (3-digit encoder)

• 10 People × 10 Actions × 10 Objects, phonetically aligned to Major
• One 3-digit number → one mini-story scene
• Full table: references/pao.md
• Role: natural fit for phone numbers and 3/6/9-digit chunks

3. SEM3 (sensory-prefixed 4-digit encoder)

• First 2 digits of a 4-digit chunk → SEM3 category × item (sensory modifier)
• Last 2 digits → Major System image
• 10 categories × 10 items = 100 entries
• The category modifies how you experience the Major image (smell, sound, touch…)

The 10 SEM3 Categories:

Key notation: SEM3 keys are 4-digit strings in the format CIXX:

• CI = Category × 10 + Item (2 digits, the sensory prefix)
• XX = Major System suffix (2 digits, the visual anchor)

So 2743 decomposes as SEM3 prefix 27 (category 2 Smell, item 7 Coffee) + Major suffix 43 (Ram) → Ram in a coffee shop.

Full 100-entry table: references/sem3-full.md

4. Peg Matrix (audio × visual, 00–99)

• 10×10 grid combining two peg systems:
• Audio pegs (tens digit, rhyme-based): 0=Hero, 1=Bun, 2=Shoe, 3=Tree, 4=Door, 5=Hive, 6=Sticks, 7=Heaven, 8=Gate, 9=Wine
• Visual pegs (units digit, shape-based): 0=Donut, 1=Paintbrush, 2=Swan, 3=Heart, 4=Yacht, 5=Hook, 6=Bomb, 7=Axe, 8=Hourglass, 9=Balloon
• Answer: "AudioPeg + VisualPeg" e.g. 37 = Tree + Axe
• Role: simple 2-digit fallback for everyday lists and ordered sequences

5. Hex System (elemental cross-matrix)

• Encodes hex digits 0–F as Element × State combinations
• Elements: 00 Fire, 01 Air, 10 Water, 11 Earth (high nibble of the 4-bit hex digit)
• States: 00 Solid, 01 Liquid, 10 Gas, 11 Plasma
• Examples: 0=rock wall, 5=dew drop, A=mist veil, F=mantle flare
• Full table: references/binary-hex.md
• Role: hex values, color codes, memory addresses

6. Binary System (4-bit / 8-bit)

• 4-bit: same 16 scenes as hex (one nibble = one hex digit)
• 8-bit: two 4-bit matrices stacked → one scene with 4 slots (AB Character, CD Form, EF Object, GH Setting)
• Cross-matrix insight: core scene = AB × GH; CD and EF add variation
• Full system: references/binary-hex.md
• Role: binary data, bitfields, flags
• Note: the 8-bit scheme is the general form of CAST — CAST just assigns semantic roles (source role, relationship type, stream, stability) to the same 4 slots

Non-Numeric Systems

7. NEDF — Concept Encoding

• Encodes definitions, ideas, and mental models via 4 slots:
• Name-hook · Essence · Distinguisher · Failure
• Full protocol + worked examples: references/concept-encoding.md
• Role: anything that is a thing (concept, term, model, principle)
• When to use: the concept has a name you need to retrieve from, and it has a classic failure mode worth knowing

8. SPEAR — Procedure Encoding

• Encodes algorithms, proof sequences, protocols, and any ordered process via 5 slots:
• Scene · Preconditions · Execution · Alternatives · Repair
• Three execution styles: causal chain (≤7 steps), spatial path (8–20 steps), recursive scene
• Full protocol + worked examples: references/procedure-encoding.md
• Role: anything with steps and order-dependency (algorithms, debugging procedures, proof templates, heuristic sequences)
• When to use: if the learning-load is in how to do something, not what something is (NEDF) or how things connect (CAST)

9. CAST + Georgian Node System — Relational Encoding

• Nodes encoded via Georgian letters (Animal + Person + Adjective + Environment — all starting with the same Georgian letter sound)
• Edges encoded via CAST (8 bits = 4 slots):
• Character (source role + direction) · Action (type + strength) · Stream (what flows) · Time (stability)
• Georgian node table: references/georgian-system.md (full 33-entry canonical table)
• CAST edge system: references/cast-system.md
• Role: anything relational — codebases, math dependencies, historical causation, argument structures
• When to use: the learning-load is in the connections, not the things

10. Formula System — Symbolic Encoding

• Encodes Greek letters, operators, quantifiers, and structural positions into scenes
• Three layers: atom library (Greek + operators as images), structural zones (up/down/left/right/center of scene), composition (sequential / structural / hybrid modes)
• Full system: references/formulas.md
• Role: math formulas, logic expressions, statistical notation, physics equations
• When to use: encoding any expression built from symbols beyond Arabic digits

Operational Layer

11. Mind Palace

• Spatial container — organizes encoded images; it does not replace NEDF/CAST/SPEAR/Major (those are the payloads; the palace is the geography + order + optional proximity semantics)
• Palace vs locus: the palace is the named whole (routes, wings, rules); a locus is one stop on a route where a scene is mounted
• Bind a palace to a stable place (real, imagined, or hybrid) with semantic fit for the domain; freeze the canonical walk order
• Palace = context prefix; loci inherit meaning from neighborhood and direction, not only from a slot number — that is why it beats “just indexing” for large structured material (full spec: references/mind-palace.md)

12. Zero-Loss Protocol (ZLP) + Forced Recall System (FRS)

• ZLP — keys, bag, gear: one anchor each, drop marker (spoken line + exaggerated flash) every placement, identity amplification so objects are never visually neutral; loss means “no encoding,” not “weak memory”
• FRS — deadlines and critical tasks: Today Core (≤5 loci only for hard dates/must-do), triple triggers (wake / door / sleep, 2–3 alarms labeled CHECK SYSTEM, overwhelm → “Check palace”), 10-second rule per trigger, reset protocol when drift returns
• Full spec: references/zero-loss-forced-recall.md
• Role: operational attention hygiene — matter (ZLP) and time (FRS) — orthogonal to encoders; pairs with Mind Palace + Retrieval cadence

13. Retrieval Protocol

• Thin layer on top of Anki: card templates per system + palace-walk cadence + weak-link repair
• Anki handles card-level scheduling; this protocol handles what Anki can't (palace topology, speed training, scene decay repair)
• Full protocol: references/retrieval-protocol.md
• Role: the consolidation layer — what actually turns encoded scenes into durable, fast recall

14. Measurement Framework

• 6 dimensions: Speed · Accuracy · Depth · Durability · Application · Process
• Each has 7 belt ranks (White → Black) with quantitative thresholds
• Daily 30-second log + weekly Anki pull + monthly belt tests + quarterly audits
• LPQ composite (geometric mean × 125) for trajectory tracking — range 125–1000
• Full framework: references/measurement-framework.md
• Role: answers "am I actually improving?" with numbers, not vibes. Catches lagging dimensions early.
• When to use: daily log always on; weekly review; monthly belt tests; quarterly recalibration

---

Decision Logic: Which System to Use?

Master rule

Numeric decision table

Decision questions to ask the user

1. Is the learning-load in the thing or the connections? → NEDF vs. CAST 2. What data type? (number / concept / relation / procedure / formula) 3. How long? (determines chunk stacking for numeric data) 4. How permanent? (long-term → Mind Palace; everyday → Peg Matrix) 5. Does context matter? (yes → anchor to a domain Mind Palace)

---

Designing a New System

When the user wants to create a new deck or encoding scheme:

Step 1 — Identify the data type

• Numbers, words, symbols, concepts, relationships, procedures?
• Natural structure: pairs, triples, ordered sequences, grids, graphs?

Step 2 — Find the natural chunk size

• 2 items → Major / Peg
• 3 items → PAO structure
• 4 items → SEM3 + Major, or NEDF for concepts
• Grid / matrix → cross-matrix approach (row × column = scene)
• Graph → Georgian nodes + CAST edges

Step 3 — Choose an imagery theme

• Pick a domain the user finds vivid (fiction characters, elements, animals, sensory categories)
• Each item must be: visually distinct, emotionally engaging, easy to animate mentally

Step 4 — Align first characters with Major System where possible

• Double-encode: image AND sound reinforce the same digit

Step 5 — Define the scene template

• Fixed output format so every combination yields a unique scene
• Test: can you close your eyes and see it?

Step 6 — Build the JS data file (if computational)

• Pattern: DATA object + META array + IMAGES object
• Zero-padded string keys
• Export: { DECK_DATA, DECK_META, DECK_IMAGES }

---

Key Principles

1. Comprehension precedes encoding. Always. Encoding a concept you don't understand stores confusion. Pass all 5 gates of the Comprehension Protocol first. 2. Images before words — always translate to a concrete visual scene first. 3. Multi-sensory beats single-sensory — SEM3 exists so scenes have smell, sound, touch. 4. Emotion = retention — vivid, bizarre, emotionally charged wins. 5. Major is the anchor — when in doubt for numeric content, fall back to 2-digit Major and build from there. 6. NEDF for things, CAST for relations. If the learning-load is in connections, encode the graph. 7. Classify before plan. Room 3 of the Heuristic Palace (problem genus) is the highest-leverage move. Pattern recognition beats generic reasoning. 8. Regeneration is the only real test. If you can't derive it from scratch, you don't understand it — you recognize it. 9. Metacognition runs above everything. Object-level work without meta-audit regresses. Checkpoint at start, mid, end, next-day. 10. Mind Palace = context, not content — palace organizes; systems encode. 11. Active recall over review — Anki is the retrieval layer; encodings should be Anki-ready. 12. Failure modes belong in scenes — NEDF slot 4 is mandatory; the Heuristic Palace Graveyard stores failed approaches. 13. Collisions are managed, not eliminated — same-image cross-system overlaps resolve by context and role differentiation (see collisions.md). Only same-role collisions require swaps. 14. Measure the trajectory, not the day. The Measurement Framework's 6 dimensions + LPQ composite track direction. Daily numbers are noise; monthly trends are signal. What doesn't get measured doesn't improve reliably. 15. Don't compromise — separate. When a problem contains a contradiction (must be A and ¬A), TRIZ says the answer isn't a middle ground. Separate A and ¬A across time, space, condition, or system level. Use Ideality to redefine the problem before accepting the contradiction as fundamental. 16. Define the stop rule before the sprint. Undefined "mastery" expands until it consumes every hour; NAVIGATOR's Narrow phase + ROI check prevents studying past diminishing returns.

---

Reference Files

Project-scale learning

• references/design-orientation.md — four life/citizenship problem clusters + STEAM / STEMM lanes; maps stack tools to resilience, digital safety, finances, emergencies, sustainability, culture
• references/navigator.md — NAVIGATOR nine phases (Narrow…Recalibrate), learning contract, DOK ladder, diagram, 80/20 companion habits, memory-gym rotation
• references/steam-stemm-examples.md — three worked examples per lane (Science, Technology, Engineering, Arts, Math, Medicine) for almost every subsystem; use when building decks or teaching
• references/memorization-helpers.md — how to memorize each method itself: NEDF + SPEAR + comprehension mapping + first session, for every theSystem spec and major book workflow (beating-the-red-queen.md)

Comprehension & Problem-Solving

• references/comprehension-protocol.md — 5 gates for understanding before encoding (Locate, Represent, Minimize, Falsify, Regenerate)
• references/confusion-triage.md — 5 kinds of stuck + matched moves
• references/heuristic-palace.md — 6 rooms + 4 wings, ~50 loci for problem-solving (now integrates TRIZ Ideality + 4 Separation loci + matrix lookup)
• references/domain-patterns.md — pattern libraries for algorithms, proofs, debug, design, biases
• references/triz.md — Condensed TRIZ (Ideality + 4 Separation Principles + top 20 Inventive Principles + 12×12 Contradiction Matrix)
• references/metacognitive-checklist.md — self-audit at 4 checkpoints + 9 self-deception patterns

Numeric

• references/major-system.md — Full 00–99 Major System table
• references/pao.md — PAO 10×10×10 (people / actions / objects)
• references/sem3-full.md — Full 100-entry SEM3 table (all categories × items)
• references/binary-hex.md — Unified elemental system for hex 0–F, 4-bit, and 8-bit
• references/encoding-examples.md — Worked examples for numeric encoding

Non-numeric

• references/concept-encoding.md — NEDF protocol for concepts and definitions
• references/procedure-encoding.md — SPEAR protocol for algorithms, processes, proof sequences (5 slots: Scene, Preconditions, Execution, Alternatives, Repair; 3 styles: causal chain, spatial path, recursive)
• references/formulas.md — Formula / symbolic encoding (Greek letters, operators, structural zones)
• references/georgian-system.md — 33-letter Georgian system (nodes, calendar, 33-slot peg)
• references/calendar-time-memorization.md — Full date + weekday + event lines; hour-of-day rings; worked clock-timeline deck
• references/bible-memorization.md — Scripture book order (worked 66-book palace example; canon-aware)
• references/lecture-listening-notes.md — Live lectures: semantic listening + note template + delayed encoding (links Semantic Reading + Active Listening)
• references/cast-system.md — CAST edges + graph encoding across domains (code, math, history, argument)

Operational

• references/mind-palace.md — Domain memory palaces: palace vs locus, real vs imagined, benefits/weaknesses, when to use vs flat indexing, structure diagrams, CAST graph embedding, lifecycle (Heuristic Palace stays separate: references/heuristic-palace.md)
• references/zero-loss-forced-recall.md — ZLP + FRS: physical zero-loss (encode on every drop) + forced recall for obligations (Today Core + triggers)
• references/retrieval-protocol.md — Anki card templates + palace-walk cadence + weak-link repair
• references/collisions.md — Cross-system image-collision rules and disambiguation policy
• references/measurement-framework.md — 6 dimensions + 7 belt ranks + LPQ composite + daily/weekly/monthly/quarterly cadence

---

STEAM / STEMM examples (quick index)

Mind palace (domain storage): mind-palace.md · STEAM drill rows: steam-stemm-examples.md — Mind Palace.

Subsystem appendices (each section has 3× Science, Technology, Engineering, Arts, Math, Medicine): Comprehension · Confusion triage · Heuristic Palace · Domain patterns · TRIZ · Metacognitive checklist · NEDF · SPEAR · Formula encoding · CAST + Georgian · Georgian system · Major · PAO · SEM3 + Major · Peg matrix · Binary / hex · Encoding examples · Retrieval protocol · Collisions · Measurement · NAVIGATOR · Onboarding · CAST beginner bilingual · Design orientation.

Memory Palace App — Manual

This file covers how the software works, not the mnemonic theory. For theory see mind-palace.md, cast-system.md, retrieval-protocol.md.

---

Core concepts

---

Atlas path

atlasPath is just a string prefix. Medicine/Anatomy/Skull means:

• Domain: Medicine
• Place: Anatomy
• Section: Skull

The sidebar and Atlas outline split on / and build a collapsible tree. There is no real hierarchy object — two palaces that share a prefix simply appear under the same tree node. Changing the prefix moves the palace in the tree instantly.

Leave it blank if you don't need grouping.

---

Toolbar modes

Double-click empty canvas → creates a new node at that position.

---

Creating content

New palace — sidebar → type name → Enter. Optionally set an atlas path (Domain/Place/Section).

New node — double-click empty canvas space.

New edge — switch to Connect mode (toolbar), click source node, click target node. The CAST dialog opens:

• Tier 1: pick a plain verb (links, triggers, feeds, blocks…).
• Tier 2: full CAST encoding — four dropdowns (AB, CD, EF, GH).

New portal — create a node, open the Node Inspector (right panel), set Kind → Portal, then pick the target palace (and optionally a route + node within it).

New route — Routes panel → New route → switch to Route mode → click nodes in walk order.

---

Atlas graph view

Atlas tab → Graph button shows all palaces as circles with directed edges for portal connections.

• Color = atlas depth (violet = level 1, blue = level 2, sky = level 3, zinc = no path).
• Badge (top-right of circle) = node count in that palace.
• Violet ring = currently open palace.
• Drag any circle to reposition it.
• Click a circle to open that palace.
• Edges are drawn only where a portal node in one palace points to another.

---

Review (walk mode)

Routes tab → select a route → Start walk.

• Cards show the node title as cue; reveal shows content.
• Rate: Again / Hard / Good / Easy → updates the locus interval (spaced repetition).
• Recall mode hides the canvas node label until you reveal.
• Walk summary shows per-rating counts and retention trend after completing the route.

---

Persistence

Changes auto-save as a draft every few seconds (shown in toolbar as a dot indicator). Use the Checkpoint button to create a named save point. The app warns if unsaved draft differs from the last checkpoint.

---

Related files

• mind-palace.md — when and how to build a palace (method of loci theory)
• cast-system.md — CAST edge encoding (AB/CD/EF/GH dimensions)
• retrieval-protocol.md — timed walks, cadence, weak-link repair
• onboarding-path.md — what to learn first and in what order

Bible memorization — books in order (worked example)

How to hold the canonical order of Scripture books as a single walkable sequence (palace + fusion), with a full 66-book teaching deck you can copy, then replace every scene with images that fit your tradition, humor, and dignity rules.

Scope here: Protestant 66 (39 OT + 27 NT), English short names. Catholic / Eastern Orthodox canons add deuterocanonical books and sometimes reorder sections — keep the same method, swap the official list your community uses, and re-run the walk once.

Prerequisites: mind-palace.md, concept-encoding.md (NEDF), retrieval-protocol.md, collisions.md. Optional: georgian-system.md if you anchor OT “Law / History / Poetry / Prophets” wings to letters.

---

Memorizing this method

Helper: memorization-helpers.md — NEDF/SPEAR lens, minimal first session, stack placement.

---

1. Comprehension gate (read once)

• The goal is order + name, not private interpretation on one flashcard. Theology, genre, and application live in study; the palace is a retrieval skeleton.
• Example scenes below are deliberately odd so they stick. They are scaffolding, not claims about the text. Swap anything that feels irreverent or confusing in your context.
• Canon differences: if you memorize 73 (Catholic) or another list, do not mix two canons on one route without a Distinguisher tag (collisions.md).

---

2. Method — one route, six wings

Procedure (SPEAR sketch):

• Scene: one real or imagined building with six connected wings (or six streets); fixed walk order A→F.
• Preconditions: official book list printed once; you’ve passed Gate 1 (Locate) for your canon.
• Execution: place one fusion image per book on the next locus; speak name aloud on each step for the first ten walks.
• Alternatives: OT only first; or two palaces (OT 39 / NT 27) if 66 feels heavy.
• Repair: when 1–2 Samuel or 1–2 Kings blur, add a numeric costume on the second volume (twin crown vs single crown, etc.).

---

3. Full worked example — “Ascent Hall” (66 loci, teaching hooks)

Rule while reading: each Book cell is the target; Teaching hook is a replaceable example only.

---

4. Anki / retrieval (minimal)

• Card front: Book #37 → ? or After Micah → ?.
• Back: Nahum + one word from your personal hook (not the whole paragraph).
• Audio: record yourself naming 1–10, then 11–20, on walks (retrieval-protocol.md).

---

5. Related bundle files

---

STEAM / STEMM note

Treat as Arts / History / Medicine-of-soul practice only if your course needs a label — optional rows in steam-stemm-examples.md are a separate follow-up.

Binary & Hex — Unified Elemental System

A single cross-matrix encodes hex digits (0–F), 4-bit nibbles, and 8-bit bytes. All three share the same elemental vocabulary, so learning one unlocks the others.

Memorizing this method

Helper: memorization-helpers.md — NEDF/SPEAR lens, minimal first session, stack placement.

---

The Core 4-Bit Matrix

Every 4-bit value (hex 0–F) = Element × State.

• High bits (3–2 of the nibble, MSB first): Element — 00 Fire · 01 Air · 10 Water · 11 Earth
• Low bits (1–0): State — 00 Solid · 01 Liquid · 10 Gas · 11 Plasma

                    STATE →
                    00 Solid   01 Liquid   10 Gas      11 Plasma
ELEMENT ↓ (rows match studio matrix top → bottom)
00 Fire             0 (ember)  1 (lava)    2 (smoke)   3 (inferno)
01 Air              4 (crystal)5 (dew)     6 (breeze)  7 (aurora)
10 Water            8 (ice)    9 (ocean)   A (mist)    B (storm)
11 Earth            C (rock)   D (mud)     E (dust)    F (magma)

---

Hex 0–F — Canonical Scenes

Note: Some scenes collide visually (2 smoke vs E dust, A mist vs 6 breeze motion). Disambiguate by the high nibble (00 Fire vs 10 Water gas, 01 Air vs 11 Earth):

• 2 = 00 Fire gas (hot rising smoke)
• E = 11 Earth gas (dry dust lifting)
• A = 10 Water gas (cool vapor bank)
• 6 = 01 Air gas (clear sky motion)

---

4-Bit Nibbles — Same Table, Binary Notation

A 4-bit value = one hex scene. Use when encoding binary directly:

• 1010 → A → Mist veil
• 0101 → 5 → Dew drop
• 1111 → F → Magma flow

Two nibbles chain to form a byte (see 8-bit section).

---

8-Bit Bytes — The Full Cross-Matrix

An 8-bit byte uses two 4-bit matrices stacked into one scene with four slots. This is the same structure as CAST (which specializes for network edges).

Bit layout

Bits:    A B  C D  E F  G H
Slot:    [ AB ][ CD ][ EF ][ GH ]
Matrix1: [Element][State]   = Character × Form
Matrix2: [Element][State]   = Object    × Setting

Slot meanings

The cross-matrix insight

Core scene = AB × GH (Character × Setting). CD (Form) and EF (Object) add variation and detail.

This means you can read a byte at a glance by just checking the outer 4 bits (AB + GH) for the scene skeleton, and use the inner 4 bits (CD + EF) to refine.

Full 8-bit lookup rules

Scene template: "[AB emoji] [AB name] [CD action] [EF emoji] [EF object] in [GH setting]"

AB (Character):
  00 🗿 Giant    01 🧜 Mermaid   10 🧙 Mage    11 🐉 Dragon
CD (Action):
  00 crushing   01 flowing      10 spreading  11 exploding
EF (Object):
  00 🧱 rock    01 💧 water     10 ☁️ cloud    11 🪨 stone
GH (Setting):
  00 🪨 red cave    01 🌊 blue ocean
  10 ☁️ green sky   11 🌋 purple storm volcano

Example encodings

---

Reading Speed Drill

To hit recall speed targets:

1. Single hex digit → scene in < 1 second (16 scenes to memorize) 2. Hex pair (byte) → two scenes in < 2 seconds 3. Full 8-bit byte (CAST-style composite scene) → < 3 seconds

Practice path:

• Week 1: Drill hex 0–F → scene (front) and scene → hex (back). Anki both directions.
• Week 2: Drill hex pairs (00–FF) as two-scene pairs.
• Week 3: Drill 8-bit composite scenes for CAST and binary data.

---

Relationship to CAST

CAST is the specialized version of the 8-bit system for network edges:

The imagery is identical. CAST just assigns semantic roles to each slot for the graph-encoding use case. If you know the 8-bit system, you know CAST.

Explicit slot-value mapping

The elemental "state" axis maps to CAST action verbs, and the elemental "element" axis maps to CAST objects. Same 4 values per slot, different names:

So "solid fire" (hex 0, ember) lines up with the same state slot as CAST "crushing" (solid); the stream image (rock / cloud / water / stone) still names what moves. The verb form is what changes when you shift from binary-value thinking to edge-relationship thinking.

---

Decision Rule: When to Use Which

---

Key Principles

1. One matrix, three uses. Hex, binary, and CAST all draw from the same elemental vocabulary. Learn once, use everywhere. 2. Element = identity, State = behavior. Every 4-bit scene is "what thing, in what form." 3. AB × GH is the skeleton. For 8-bit, get the outer bits first for the scene shape, then fill in CD and EF for detail. 4. Elements are emotional anchors. Earth is heavy/permanent, Water is fluid/change, Air is subtle/invisible, Fire is transformation/destruction. These associations help recall under stress.

---

STEAM / STEMM examples

Three scenarios each for Science, Technology, Engineering, Arts, Math, and Medicine using this method: [steam-stemm-examples.md](./steam-stemm-examples.md#appendix-binary-and-hex).

Calendar & time memorization

Full-stack notes for dates (year-month-day + weekday) and hours (clock time), plus a worked example deck (“famous clocks” timeline) you can copy into Anki or a palace ring.

Prerequisites: georgian-system.md (month/day variants, weekday color banks, Georgia holidays), major-system.md, sem3-full.md, mind-palace.md, retrieval-protocol.md. Optional binary path: binary-hex.md (nibble / byte scenes).

---

Memorizing this method

Helper: memorization-helpers.md — NEDF/SPEAR lens, minimal first session, stack placement.

---

1. One-line log format (history & appointments)

Use a fixed template so every card and journal line has the same shape:

YYYY-MM-DD Weekday — Event

flowchart LR
  Y[YYYY-MM-DD] --> W[Weekday] --> E[Event text]
  Y -."optional clock".-> H[HH:MM]
  H --> E

Add `HH:MM` when the fact needs clock time — see §1.1.

• `YYYY-MM-DD`: ISO order sorts correctly in text files.
• `Weekday`: spell out or use Mon…Sun — pick one style and freeze it.
• Event: short noun phrase; put longer story on the next line or on the card back.

Example history lines (proleptic Gregorian; weekdays checked for study drills)

Encoding recipe (typical):

• Year → SEM3+Major (4+4 digits) or split YY + YY if century is stable in your course.
• Month → Georgian row 1–12 and/or civic month skin (georgian-system.md § optional pegs).
• Day → Major (00–31) or Georgian row 1–31 — one system for the day slot.
• Weekday → ROYGBIV object bank + Sunday/Monday-first table.
• Event → NEDF (Name hook = headline, Failure = common exam mistake).

1.1 Full lines with wall time (YYYY-MM-DD Weekday HH:MM)

When the fact includes clock time, extend the one-line log (still sorts as plain text if weekday stays a word):

YYYY-MM-DD Weekday HH:MM — Event

Rule: Put legal timezone (UTC, America/New_York, Europe/Berlin, Asia/Tokyo, …) and “approximate vs logged” on the card back or the next line. History is full of ship clocks, summer time, and revised official times — your line is the encoding handle, not a court exhibit.

Worked examples (weekdays: proleptic Gregorian; times: common references, rounded)

For fusion with palaces, see §2.4 (date walk → clock alcove vs split cards).

---

2. Hours of the day — do we memorize them?

Previously the bundle had no dedicated “hours” chapter. Here is the default recommendation.

2.1 When you actually need clock time in memory

• Exam / oral board: drug timing, lab schedule, history “at what hour.”
• Story / game design: your own clock-tower deck (see §4).
• Habit stacking: “run at 06:45” — usually better in a real alarm, with memory only for the habit chain (SPEAR), not the digits.

2.2 Twenty-four positions (canonical)

Treat 00:00–23:00 (hour resolution) as 24 loci on one ring:

flowchart TB
  subgraph ring["24 loci on one ring"]
    direction LR
    N00["00 north / midnight"] --> E06["06 east / dawn"]
    E06 --> S12["12 south / noon"]
    S12 --> W18["18 west / dusk"]
    W18 --> N00
  end
  M[Major image per hour] -. placed at .- N00
  M -. each locus .- E06

• Ring A — Civil night→day: start at midnight = north / gate you always enter; proceed clockwise; +1 hour per locus (see §2.25 for vivid compass skins so the ring is not a flat diagram).
• Tag AM vs PM if you collapse to 12 loci instead: add sun vs moon modifier on the same locus (24 distinct scenes).

Encode the hour number:

• Hour `HH` as two-digit Major (00–23 — you need images for 00–23; 20–23 often drilled as extensions of your 00–99 table or as PAO head + Major tail).
• Minutes `MM`: either
• Quarter-hour pegs (00 / 15 / 30 / 45) as four sub-loci inside the hour locus, or
• Full Major for MM if precision matters (flight ops, astronomy).
• Alternative: encode compass + quarter + hour with nibbles / bytes (§2.26) so clock memory reuses the same elemental hex vocabulary as the rest of the stack.

2.25 Compass-locked ring — vivid skins (hours + quarter minutes)

Boring failure mode: four gray labels (“N, E, S, W”) on a mental map. Fix: keep the geometry universal, but dress each cardinal as a permanent gate with smell, sound, temperature, and motion — then make your hour’s Major image fight, hug, or steal from that gate.

Skeleton (keep this boring on purpose — it is the chassis)

1. North-up — N up · E right · S down · W left (same as most maps and map apps). 2. Clockwise = N → E → S → W — matches a clockwise hour ring starting at north. 3. Sun story (rough, mid-latitudes) — rises ~east, sets ~west; use a Distinguisher near the poles or for exact ephemeris.

Everything below is optional skin; pick one skin for the whole ring and stay with it for months.

Compass skins — three worked examples (swap in your own lore)

Each skin is four outrageous stations. Your 24 hour loci sit on the path between these stations (or on the station if you place midnight at North). Quarter minutes :00 :15 :30 :45 reuse N · E · S · W as micro-zones inside the current hour’s scene (e.g. “:15 = east corner of this room = the gargoyle’s left eye”).

Rule of thumb: each cardinal should have one dominant sense (cold / glare / heat / wet, etc.) so you can tell which gate even when the hour story is loud.

Make hours vivid: collide Major with the gate

Static placement is forgettable. Each hour, do one action between your Major image for `HH` and the gate character for that direction:

• North midnight: your 00 image chains the aurora to the organ, or steals a pipe.
• East 06:00: your 06 image rides the cannon shell into the dawn wall.

Same locus tomorrow? Change only the verb, not the geography — keeps palace stable, scenes fresh for spaced review.

Personal body pegs (still allowed)

Nose / eat / soup / water (facing north: up / right / down / left) is fine if it is more vivid for you than abstract maps — paint the soup volcanic, the water bioluminescent, etc. If nose or hands collide with other decks, tag roles (collisions.md) or move the body map onto a giant statue you walk on, not your own skin.

Language rhymes (optional, local)

English NEWS or “Never Eat Soggy Worms” are fine extras; they are not universal. Prefer geometry + one skin + Major-vs-gate action.

2.26 Binary / nibble alternative (compass + quarters + hour)

If you already drill binary-hex.md, you can run the clock ring as bits → hex scenes instead of (or layered under) compass skins and Major for the hour digit.

One nibble = compass + quarter (4 bits → one hex scene)

Pack two choices into a single nibble (16 states = 4 × 4):

flowchart LR
  subgraph nibble["4 bits → one hex scene"]
    CC["high pair cc<br/>compass N E S W"]
    QQ["low pair qq<br/>quarter :00 :15 :30 :45"]
    CC --> H["hex digit → elemental scene"]
    QQ --> H
  end

Example: East + :30 → cc=01, qq=10 → binary `0110` → hex `6` → in the elemental matrix that is Air · Gas (breeze scene in binary-hex.md). One image carries both “which side of the ring” and “which quarter of the hour.”

Failure to avoid: swapping your own bit order between study sessions — freeze high pair = compass, low pair = quarter (or the reverse, but never both).

Hour 00–23 as one byte (two nibbles)

Write the hour as an 8-bit value (pad with leading zeros). Split into two hex digits → two elemental scenes from the same matrix:

Chain nibble (compass+quarter) + nibble-nibble (hour) in one small palace alcove: three scenes, fixed order.

Minute 00–59 (optional second byte)

For full minutes, treat the minute as a number 0–59, pad to 8 bits, read two nibbles (hex 00 … 3B):

Invalid pairs (e.g. high nibble 4–F on the tens side) never occur if you always start from true wall time — still, verify when building cards.

When this path wins

• You want one vocabulary for permissions, CAST edges, and clock/campus direction drills.
• You like composing scenes from a finite table instead of inventing new props per hour.

When to stay with Major + palace

• You do not yet read nibbles in under a second — add latency and errors until drilled.
• You need spoken 12h social fluency first; binary is a second layer, not a replacement for “what time is it out loud?”

2.3 Twelve-hour spoken clock

If your culture defaults to 12h + AM/PM, use 12 loci on the dial and a binary or NEDF tag for AM/PM (sun vs moon, rooster vs owl).

2.4 Fusion with dates

For `YYYY-MM-DD HH:MM`, either:

• One palace corridor: date walk → branch into “clock alcove” for that day’s time, or
• Two cards: date card + time card linked by shared CAST edge appointment → occurs_at → timestamp.

---

3. Famous clocks deck (worked example — hour ↔ landmark year)

The JSON this bundle was seeded from uses `time` as the hour peg (13:00 → 23:00 → wrap to 00:00 midnight → … → 12:00 noon) and a dummy calendar date (YYYY-01-01) only for sorting — not the historical opening date. On each card, store the real “first built / installed” year in the fact field and keep the mnemonic aligned to that year after you verify sources.

Builder hygiene:

• Several rows ship a mnemonic that encodes a different four-digit year than the date field — reconcile before memorizing (example: 07:00 row had 1969 in description but a 1960 mnemonic in the source JSON — pick one year, fix the image).
• 12:00 row mixes 1392 mnemonic with 1960 description — split into two cards or one card with explicit “two historical layers” if you study art history that way.

3.1 Table — hour → clock → mnemonic hook (from project seed)

Poetry lines from the seed JSON are optional Arts hooks — store on card back if they improve recall; skip if they add noise.

3.2 Anki card shape (hour deck)

• Front: 13:00 → ? (image of clock face without caption, or text only).
• Back: landmark name + city + verified year + mnemonic breakdown + Wikipedia link.
• Extra: map thumbnail in images/ folder if you ship this as an app deck.

---

4. Related bundle files

---

STEAM / STEMM examples

Add deck rows under Arts (architecture + poetry), Technology (tower mechanisms), History (political dates), Engineering (tower structures) when you extend steam-stemm-examples.md — optional follow-up.

CAST — Very simple English + Georgian + Russian

This sheet is a teaching aid: tiny words first, then the official CAST English names (what the app and cast-system.md use). If a Georgian or Russian phrase sounds odd, treat the CAST English column as canonical and adjust the gloss to your own voice.

How to use it: pick one row in each block (AB, CD, EF, GH). Same bits as the main doc — only the first column is “extra simple.”

Memorizing this method

Helper: memorization-helpers.md — NEDF/SPEAR lens, minimal first session, stack placement.

---

AB — WHO (Character)

Why AB (WHO) feels confusing — use NEDF on the source, then pick a mask

NEDF (see concept-encoding.md) encodes one concept / thing in four slots:

AB (Character) is not a second NEDF. It answers a smaller question about one directed edge Source → Target:

Given the source is already fixed on the tail of this arrow, which four-way mask best describes how the source shows up on this link — boss, peer, helper, or reverse-pressure?

So the usual confusion is: people try to stuff NEDF Name or the whole Georgian node scene into AB. That’s too much. NEDF (and Georgian) = the node’s identity. AB = the source’s costume on this one edge.

Practical bridge (do this in order):

1. NEDF the source node (at least E + D; F helps when the edge is “painful”). 2. Ignore N for AB — the Giant/Mermaid/Mage/Dragon image is not your name-hook; it’s a reusable edge role from the table above. 3. Ask only about this arrow:

• From Essence: is the source’s core move here one-way control? → Giant
• From Distinguisher + symmetry: could you swap roles without lying about responsibility? → often Mermaid
• From Essence: is the source mainly serving outward without owning the target’s world? → Mage
• From Failure or dynamics: does the target push back or reverse the flow when stressed? → Dragon

One-line example: Edge Router → Middleware. Router’s NEDF essence might be “sorts traffic into lanes.” On that dependency edge the router owns direction → Giant (00). Same router on Router ↔ Metrics might be Mermaid (01) if the story is peer-like exchange of signals.

Concrete arrow stories (same trick as parent → child)

Use two named people or parts, one arrow, same vibe you already liked — then map to AB.

Rule of thumb: draw one arrow. Write who is source (tail). Ask only: on this link, is the tail bossing, peer‑ing, helping out, or getting pushed back on?

Same family picture for CD · EF · GH (optional)

Keep parent → child (or any one edge you like) and vary only the other slots:

You can swap the domain (school, team, code) — keep two nodes, one arrow, and the representation stays easy to sketch.

---

CD — HOW (Action)

---

EF — WHAT (Stream)

Note: In tech Georgian, “cloud” is often ქლაუდი (loanword), which is fine for this layer.

---

GH — WHEN (Time)

---

One-line pattern (all four slots)

English (baby steps): WHO + HOW + WHAT + WHEN — each from the “Very simple” column.

Example: Boss one-way · holds hard · shape · always → same bits as Giant, crushing, rock, red cave (00 00 00 00).

ქართული: აირჩიე თითო სტრიქონი თითო ბლოკიდან; შემდეგ გადაიყვანე ოფიციალურ CAST ინგლისურ სახელებში.

Русский: выбери по одной строке из каждого блока; затем сопоставь с официальными английскими именами CAST.

---

STEAM / STEMM examples

Three scenarios each for Science, Technology, Engineering, Arts, Math, and Medicine using this method: [steam-stemm-examples.md](./steam-stemm-examples.md#appendix-cast-beginner-bilingual).

CAST + Georgian Node System — Full Relational Encoding

Relational knowledge is most of what learning is. Codebases are graphs. Math is dependency graphs. History is causal graphs. Arguments are graphs. This system encodes graphs — nodes and edges — into vivid scenes.

CAST is now a first-class system, not an appendix. For any concept that names a relationship, dependency, flow, or interaction, reach for CAST before NEDF or SEM3+Major.

Memorizing this method

Helper: memorization-helpers.md — NEDF/SPEAR lens, minimal first session, stack placement.

---

System Overview

A network has two kinds of objects:

• Nodes — the things (encoded via the Georgian node system, 4 slots)
• Edges — the relationships (encoded via CAST, 8 bits = 4 slots)

Each node is a scene. Each edge is a scene. The mind palace arranges them spatially so proximity encodes connectivity.

---

Part 1 — The Georgian Node System

Each node is a 4-slot scene built from a Georgian letter's associations. The Georgian alphabet gives you a naturally ordered, phonetically-rich basis with 33 entries — more than enough for most domain vocabularies.

The 4 node slots

The first three are always filled. The fourth is reserved for cases where you have multiple instances of the same type (e.g., three different controllers).

Why Georgian letters?

• 33 letters = enough coverage without collisions
• You (the user) read Georgian, so the letters prime recall naturally
• Each letter has a fixed animal, person, adjective, and environment —

all starting with the same letter sound (quadruple alliteration)

The Georgian node table

The canonical 33-letter table lives in `georgian-system.md`. Each entry has four slots all starting with the same Georgian letter:

1. Animal — node identity 2. Person — (optional) disambiguation when multiple same-type nodes exist 3. Adjective — node state 4. Environment — node cluster

Example:

• ა → Eagle (animal) / Anano (person) / exalted (adj) / balcony (env)
• ვ → Whale (animal) / Vika (person) / vast (adj) / fan (env)

See georgian-system.md for the full 33-entry table.

Node encoding procedure

1. Pick the Georgian letter whose animal best matches the node's identity (by sound, meaning, or domain association). 2. Use that letter's environment as the node's cluster marker — unless the cluster is given externally (e.g., palace location), in which case the environment yields to the palace. 3. Use that letter's adjective as the node's current state. 4. Place the animal in the environment with the adjective active. That scene is the node.

Example: A database in a Laravel app.

• Letter: ვ (Whale) → identity = Whale
• Environment: Deep ocean → cluster = "data layer"
• Adjective: Vast → state = "stable, high-capacity"
• Scene: A vast whale in the deep ocean, calm and dominant

---

Part 2 — CAST Edges (full reference)

CAST encodes every edge as an 8-bit string → one scene with 4 components.

The name: Character · Action · Stream · Time

Studio / tooling: The learning app loads the same row-level lexicon from src/data/castLexicon.js (including short “when to pick” hints in the CAST playground). If you change a row’s meaning here, update that file so the playground and tests stay aligned.

Beginners + bilingual gloss: See `cast-beginner-bilingual.md` for very short English wordings plus Georgian and Russian columns aligned to the same four slots.

C — Character (AB): source role + direction

Rule: The Person in the scene = the source node's role.

A — Action (CD): type + strength

S — Stream (EF): what flows

T — Time (GH): stability

---

Part 3 — Reading and Writing CAST Scenes

Writing a CAST scene from bits

Bits: 00 01 10 00

1. C=00 → Giant, one-way → 2. A=01 → flowing (medium feed) 3. S=10 → cloud (information) 4. T=00 → red cave (permanent)

Scene: A Giant in a red cave, flowing a cloud forward. Meaning: Source permanently feeds information to target, one-way, medium strength.

Writing a CAST scene from a relationship

"The auth service permanently validates every request from the API gateway."

1. Auth is the target here; API gateway is the source. Source dominates? No — source asks, auth answers. Source is calling into auth. Character = Mage (10) — subtle service interaction, one-way. 2. Action = validation is strong/controlling? It's medium — it feeds validated results. Flowing (01). 3. What flows? Data (the request + response). Rock (00). 4. Stability? Every request → permanent. Red cave (00).

Bits: 10 01 00 00 → Mage in red cave, flowing a rock.

---

Part 4 — Worked Examples Across Domains

Example 1 — Code (Laravel app)

Nodes (Georgian):

• ა Eagle = Router (Giant: hub)
• ბ Owl = Middleware (Mage: subtle gatekeeper)
• გ Pig = Controller (Giant: controls logic)
• ვ Whale = Database (Giant: data store)
• ე Raccoon = Model (Mermaid: bidirectional with DB)

Edges:

• Router → Middleware: 10 10 00 00 → Mage spreading rock in red cave (subtle permanent filter)
• Controller → Model: 00 00 00 00 → Giant crushing rock in red cave (controls data structure)
• Model ↔ Database: 01 01 00 01 → Mermaid flowing rock in blue ocean (bidirectional data, mostly active)

Example 2 — Math (dependency graph for proving the Central Limit Theorem)

Nodes:

• Sample mean definition (Mage — helper concept)
• Law of Large Numbers (Giant — foundational theorem)
• Characteristic functions (Mage — tool)
• CLT itself (Giant — target theorem)

Edges:

• LLN → CLT: 00 01 10 00 → Giant flowing cloud in red cave (foundational information, permanent)
• Characteristic fn → CLT: 10 11 10 00 → Mage exploding cloud in red cave (critical tool, transforms the proof)

When you walk this graph in a palace, you see why CLT depends on LLN and characteristic functions before you can write the proof. Problem-solving gold.

Example 3 — History (causes of WWI)

Nodes:

• Alliance system (Giant — structural)
• Assassination of Franz Ferdinand (Dragon — trigger)
• Mobilization schedules (Mage — invisible procedural)
• Great powers (Mermaid — peer rivals)

Edges:

• Assassination → Alliance cascade: 11 11 11 11 → Dragon exploding stone in purple storm (trigger, critical, event, temporal)
• Mobilization → War: 10 11 11 00 → Mage exploding stone in red cave (subtle but permanent transform)
• Great powers ↔ each other: 01 10 10 01 → Mermaid spreading cloud in blue ocean (bidirectional signaling, mostly active)

Example 4 — Argument structure (philosophy paper)

Nodes:

• Premise 1 (Mage — supporting)
• Premise 2 (Mage — supporting)
• Inference rule (Giant — controlling the move)
• Conclusion (Dragon — emerges from trigger)
• Counterexample (Dragon — attacks conclusion)

Edges:

• Premises → Conclusion via Inference: chain of CAST scenes
• Counterexample → Conclusion: 11 11 11 11 → Dragon explosion (critical attack)

This is how you memorize a philosophical argument so you can reconstruct it under questioning — not as words, but as a graph you walk.

---

Part 5 — Decision Rule: CAST vs. NEDF vs. Major+SEM3

When unsure: ask "is the learning-load in the thing or in how it connects?" If connections → CAST. If the thing itself → NEDF.

---

Part 6 — Building a Network from Scratch (learning a codebase / theorem / system)

1. Find the nodes. Folder structure, entity list, concept glossary, chapter titles. 2. Classify each node. Giant / Mermaid / Mage / Dragon based on role in the network. 3. Assign Georgian letters. Match by sound/meaning where possible. 4. Trace one full path end to end. One feature, one proof chain, one causal sequence. 5. Encode each edge along that path as a CAST scene. 6. Ask three questions per node: What calls this? What does this call? What breaks if removed? 7. Let gaps pull you forward. Unknown edges are your next learning target. 8. Feel the shape. After 3–4 paths, step back. Which nodes have surprising centrality? Those are your real hubs.

---

Part 7 — Graph Mind Palace Principle

Canonical companion for vocabulary, tradeoffs, and palace vs indexing: `mind-palace.md`.

• High-connectivity nodes (hubs) → prominent locations (entrance halls, central rooms)
• Clusters → different buildings or neighborhoods
• Edges → physical interactions between locations (paths, doors, pipes)
• The spatial layout is the topology
• Walking the palace is traversing the graph

For Anki: each edge is a card. Front = source + target names. Back = CAST bits + scene. Each node is also a card. Front = Georgian letter or concept name. Back = animal + environment + adjective.

---

Part 8 — Quick Reference Card

NODE (Georgian, 4 slots):
  Animal     — who (identity)
  Environment— cluster (layer/module)
  Adjective  — state (condition)
  [Modifier] — optional disambiguation

CAST EDGE (8 bits, 4 slots):
  AB = C = Character  00 Giant→  01 Mermaid↔  10 Mage→  11 Dragon←
  CD = A = Action     00 crush   01 flow      10 spread  11 explode
  EF = S = Stream     00 rock    01 water     10 cloud   11 stone
  GH = T = Time       00 cave    01 ocean     10 sky     11 volcano

READING ORDER: WHO / HOW / WHAT / WHEN

---

Representation atlas — every surface in this app

CAST is intentionally mirrored across modalities so you can choose the channel that matches how you think day-to-day. The markdown body is the canonical prose specification with tables, worked domains, and quick reference cards. The atlas map places this file on the concept tier so you can see which neighbors to open next — binary-hex for the shared bit vocabulary, georgian-system for node identity, retrieval-protocol for how decks consume edges, and collisions for disambiguation rules. The weight spectrum treats the document as a signal about how central relational encoding is to your current study session. On the document route, the orbit widget renders related files as a small graph so you can jump outward without losing the CAST frame. Finally, the learning studio compresses the same story into a walkthrough that follows headings, guided examples that rehearse forward and backward prompts, and a playground that adds live composition plus decode drills. Use every representation once during onboarding, then lean on the two that stick.

---

Matrix view — CAST as a specialized 8-bit grid

Treat the four two-bit pairs as the rows of a mental matrix: Character versus Action versus Stream versus Time. Each row has exactly four legal states, which keeps combinatorics bounded while still expressive enough for real software graphs, proof nets, and causal histories. When you are unsure which row is wrong during recall, compare against the generic elemental matrix in binary-hex.md — the bits are the same even when the labels change. CAST simply renames the axes so the first pair always answers who the source behaves as, the second pair names the relationship verb family, the third names what substance moves, and the fourth names how durable the dependency feels. Matrix thinking helps when you are debugging a stuck edge: rotate through the four rows and ask which answer feels false compared to the codebase.

---

List representation — CAST decision checklist

Work the edge through this ordered list before you freeze a palace location: (1) Confirm the endpoints already have Georgian node scenes so the hop is anchored. (2) Decide whether the source acts as hub, peer, helper, or reactor for this specific hop — that pins Character. (3) Classify the interaction as control, feed, influence, or rupture — that pins Action strength. (4) Name whether structure, resources, signals, or discrete events move — that pins Stream. (5) State permanence, active maintenance, conditionality, or volatility — that pins Time. (6) Speak the full scene aloud in WHO then HOW then WHAT then WHEN order to catch awkward grammar early. (7) Write the eight bits on the Anki back beside a one-line natural language gloss. Lists complement tables because they give you a repeatable audit path under stress.

---

Diagram vocabulary — spatial graph mnemonics

Even without drawing on paper, you should be able to narrate a diagram: hubs occupy architectural centers, satellites ring them, bottlenecks become narrow chokepoints, and bidirectional edges borrow symmetrical props such as bridges with two-way lanterns. CAST bytes decorate each connector object in that diagram — a door, cable, river, or contract scroll — so the visual metaphor stays consistent with the bitstring. When you promote an edge from temporary sketch to long-term memory, upgrade the prop fidelity instead of inventing a second scene. Spatial vocabulary also explains why CAST pairs naturally with measurement frameworks that track graph size and retrieval decay: if the palace no longer matches the topology, the bytes will not retrieve cleanly either.

---

Narrative arc — story-first encoding order

Some learners prefer to start from a plot beat and only then derive bits. Tell the relationship as a micro-story with a named protagonist drawn from the Character roster, give them an Action verb that matches emotional torque, let Stream supply the prop they manipulate, and let Time set the weather or lighting that signals stability. Once the story feels honest, peel off the four pairs in reading order and confirm the byte matches what you would have chosen analytically. Narrative-first encoding is slower at first but reduces collisions when two different edges want similar verbs because the plot beat forces disambiguation. The learning studio playground exists to rapid-fire this arc without opening the full document.

---

Key Principles

1. Nodes before edges. Classify and encode nodes first, then draw edges between them. 2. One edge = one scene = 8 bits. Never split an edge across multiple scenes. 3. Direction lives in Character. The Person's stance encodes the arrow. 4. Strength lives in Action. The verb encodes the line weight. 5. Content lives in Stream. The object encodes what flows. 6. Stability lives in Time. The environment encodes permanence. 7. Spatial arrangement matters. Palace layout must mirror topology — otherwise you're paying for a graph and using it as a list.

---

STEAM / STEMM examples

Three scenarios each for Science, Technology, Engineering, Arts, Math, and Medicine using this method: [steam-stemm-examples.md](./steam-stemm-examples.md#appendix-cast-and-georgian-nodes).

Collision Resolution Rules

Some images legitimately appear in multiple canonical tables. This file states, for each known collision, which system wins at encoding and retrieval time based on context.

The core principle: a mnemonic system works if, at retrieval time, the scene fires the correct meaning. Same-image collisions are only a problem when two meanings compete in the same context. Different contexts → no conflict.

This file lists every known cross-system image overlap and the rule that disambiguates it. Consult when building scenes that mix multiple systems.

Memorizing this method

Helper: memorization-helpers.md — NEDF/SPEAR lens, minimal first session, stack placement.

---

Section A — Fixed Collisions (already corrected)

These were real conflicts. They've been resolved by swapping one side:

Follow-up note on Mask and Bell:

• "Mask" also appears in formula θ (Theta theater mask). Different contexts: PAO Mask is in a 3-item phone-number scene; Greek mask is in a formula scene. Covered by B6.
• "Bell" also appears in physics constant k_B (Thermometer with bell). Same disambiguation: PAO Bell in number scenes; k_B bell is a small detail inside a formula scene. Covered by B6.

---

Section B — Accepted Collisions (context disambiguates)

These remain as-is. The rule states when each image means what.

B1 — SEM3 animals ↔ Georgian animals

Several animals appear in both SEM3 (as numeric prefixes) and the Georgian system (as node identities):

The rule: SEM3 animals only appear in numeric scenes; Georgian animals only appear in node/graph scenes.

Context markers that tell you which system is active:

• SEM3 scene — has a sensory category modifier (smell, sound, touch, etc.) and a Major image following it. Always 4 digits being encoded.
• Georgian scene — has the quadruple-alliteration signature (animal + person + adjective + environment, all starting with the same Georgian letter). Usually appears inside a palace or a CAST edge context.

If you can't tell from context which system is active, your scene needs a stronger system-marker. Fix: thicken the SEM3 sensory anchor, or add the Georgian person slot for disambiguation.

B2 — Elemental vocabulary in SEM3, Hex/Binary, and CAST

The words rock, lightning, lava, mud, cloud, ocean, storm, wave, fire, water, ice appear across three systems:

• SEM3 uses them as category items (e.g., Touch 44 = Rock, Vision 05 = Lightning)
• Hex/Binary uses them as element×state scenes (Hex 0 = Ember / fire-solid, Hex B = Lightning storm / water-plasma)
• CAST uses them as stream/time values (Stream 00 = rock, Time 11 = purple storm)

The rule: role in the scene determines the system.

Concretely:

• SEM3 rock (touch 44) is held, felt, stepped on
• Hex C (earth-solid) is the rock wall — structural backdrop; hex 0 is fire-solid (ember), not a wall
• CAST rock is data moving along an edge

If the scene has multiple rocks, add a distinguishing detail: sensory rock is always pressed against a character; hex rock is a wall; CAST rock is in motion.

B3 — Colors in SEM3 vs CAST Time

*The rule: SEM3 colors appear as the thing itself (a red object, a blue object). CAST colors are always environmental — a cave, ocean, or sky.*

If you need a red object inside a CAST scene, make it a non-red object that happens to glow red (distinction: object with color vs color-as-environment).

B4 — Major ↔ Georgian shared words (fan, chair, tree, forest, bread, gate)

These are environment words that appear as Major 2-digit images AND as Georgian environments:

The rule: Major images appear in number-chunk scenes; Georgian environments appear in node/palace scenes.

A Georgian environment is always "[animal] doing [adjective] something in [environment]" — part of the quadruple alliteration. A Major image is always part of a number decomposition. If your scene is a full Georgian 4-slot sentence, the "fan" is the Georgian ვ environment. Otherwise it's Major 82.

B5 — Heuristic Palace loci vs other systems

Palace loci reuse common words (duck, case, base, door, scale, window, painting). These never conflict because the Heuristic Palace is always walked as a palace, not recalled as an encoding.

The rule: you only encounter Heuristic Palace images when you deliberately walk the palace. They don't interfere with encoding-time recall.

B6 — Greek uppercase/lowercase pairs

Ψ and ψ both relate to "psi." Ω and ω both relate to "omega." Σ and ∑ are the same symbol used in different contexts.

The rule: uppercase = structural/aggregate operation (Σ summation, Π product). Lowercase = variable/constant (σ std dev, π ≈ 3.14).

This is the standard math convention; the mnemonic system just mirrors it. Not a collision — a feature.

B7 — Operators that reuse Greek imagery

• Σ (Greek uppercase) = Sigma stacker = ∑ operator = Stacker crane
• Ψ trident ≈ ∇ downward trident

The rule: Σ and ∑ are intentionally the same image — they're the same symbol in math, and the mnemonic reflects reality. For Ψ vs ∇, the difference is orientation: Ψ is upright (3 prongs up), ∇ points downward.

B8 — Cross-system elemental words

Words like giant, dragon, mage, mermaid appear only in CAST (as Character roles). They might seem to collide with Δ "giant triangle mountain" but don't: CAST giants are person-shaped; Δ giant is a mountain. Different image shapes despite shared word.

The rule: CAST characters are always humanoid. Formula "giants" are always geometric (Δ mountain, etc.).

---

Section C — The General Disambiguation Algorithm

When you're building a scene that might mix systems, ask in order:

1. What kind of thing am I encoding? (number / concept / relationship / formula) 2. Which system does that type belong to? (Major / NEDF / CAST / Formula) 3. Do I need a second system layered on top? (e.g., a CAST edge whose weight is a number needs CAST + Major) 4. If yes — do the images of both systems clash in this scene? Check this table. 5. If they clash — apply the rule above (role differentiation or scene markers).

---

Section D — How to Add a New Collision Rule

When you discover a new collision during encoding:

1. Note the image, both systems it appears in, and both meanings. 2. Ask: does the context naturally separate them? (90% of the time yes) 3. If not, decide:

• Add a role-differentiation rule (like B2)
• Swap one side (like Section A — rare)
• Add a scene marker (special object that flags which system is active)

4. Append the new rule to Section B of this file.

---

Key Principles

1. Most collisions are fine. Context does the disambiguating work. 2. Same-role collisions are NOT fine — swap one side immediately. 3. SEM3 and Georgian share animals by design — phonetic alignment means convergent choices. Accept and differentiate by context. 4. System-markers help — always include the signature element of each system (SEM3 sensory anchor, Georgian quadruple-alliteration, CAST edge flow) so scenes self-identify. 5. If a scene can't self-identify which system is active, the scene is under-specified. Fix by adding a system-marker, not by renaming imagery.

---

STEAM / STEMM examples

Three scenarios each for Science, Technology, Engineering, Arts, Math, and Medicine using this method: [steam-stemm-examples.md](./steam-stemm-examples.md#appendix-collisions).

Comprehension Protocol

Memory systems encode what you already understand. They don't produce understanding. This protocol is the missing layer: the sequence of moves you make when first encountering a difficult topic, before any encoding.

Rule: Never encode a concept you haven't fully understood. Encoding confusion produces confused retrieval.

Memorizing this method

Helper: memorization-helpers.md — NEDF/SPEAR lens, minimal first session, stack placement.

---

The Five Gates

You do not "understand" a topic until all five gates are open. Check each, in order, before declaring comprehension.

Gate 1: Locate     — where does this sit in my knowledge map?
Gate 2: Represent  — can I express it in ≥3 distinct forms?
Gate 3: Minimize   — what's the smallest example that exhibits it?
Gate 4: Falsify    — what would break this? where are the edges?
Gate 5: Regenerate — can I derive it from scratch without notes?

Only after Gate 5 do you encode.

Live lectures: speech is faster than careful gates — use a thin live pass (Locate + Represent skeleton + tagged keywords) and schedule Gate 5 soon after class before heavy encoding. Playbook: `lecture-listening-notes.md`.

---

Gate 1 — Locate

Before reading deeply, answer: where does this concept live?

• What field is it in? What subfield?
• What concepts are its neighbors (adjacent, related, similar)?
• What is it a special case of? What is a special case of it?
• What problem does it solve? Whose problem? Why did anyone invent this?

If you can't place the concept in at least a rough map after 5 minutes, your background is too thin — stop and backfill prerequisites (see confusion-triage.md) before continuing.

Anti-pattern: Starting to read a technical explanation of a concept before knowing what category of thing it is. This produces the "reading with eyes but not mind" failure mode.

Tactic — The 1-minute map: Before opening the source, write 2 sentences: "This is a [category] that does [function] for [purpose]." If you can't write it, locate it first.

---

Gate 2 — Represent

A concept you understand can be expressed in at least three distinct representations. One is recognition; three is understanding.

The representation checklist

Force yourself to produce each of these before moving on:

1. Verbal / prose — explain in plain English, no jargon 2. Symbolic / formal — the mathematical/logical/code expression 3. Geometric / visual — a picture, diagram, or spatial metaphor 4. Computational / operational — what steps would you execute? 5. Adversarial / counter — a case that nearly breaks it but doesn't 6. Extreme case — what happens at the limits (0, ∞, trivial, boundary)

Minimum bar: at least 3 of the 6. Ideally 4+.

Worked example — "continuity" (calculus)

1. Verbal: a function has no sudden jumps; you can trace it without lifting your pencil 2. Symbolic: ∀ε>0 ∃δ>0 such that |x-a|<δ ⇒ |f(x)-f(a)|<ε 3. Geometric: the graph has no gaps, holes, or jumps 4. Computational: given ε, can you produce a δ that works? 5. Adversarial: the Dirichlet function (1 on rationals, 0 on irrationals) is nowhere continuous — shows how strict the definition is 6. Extreme case: continuity at an isolated point of the domain is trivially true — shows the condition's dependence on neighborhoods

If you can only do 1–2 of these, you recognize the concept but don't understand it.

Anti-pattern

Reading a textbook definition and thinking "yes I get it" without producing any representation yourself. Recognition is not comprehension.

---

Gate 3 — Minimize

For any concept, find the smallest possible example that still exhibits the phenomenon.

This is Terence Tao's signature move and Feynman's as well. The minimum example is where the concept's essential mechanism is visible, stripped of complexity.

How to minimize

1. Find any example of the concept. 2. Ask: "can I remove something and still have an example?" 3. Remove it. Verify you still have the concept. 4. Repeat until further removal breaks the example. 5. That's your minimum working example (MWE).

Worked example — "recursion"

• Large example: a recursive tree traversal of a filesystem
• Smaller: recursive Fibonacci
• Smaller: f(n) = 1 if n=0 else f(n-1) — counts down
• Minimum: f(n) = f(n) — pure self-reference (and it hangs; good — shows you need a base case)

The minimum both reveals the mechanism AND reveals what goes wrong when you remove the supporting structure.

Why this gate matters

• If you can't produce an MWE, you don't actually know what's essential about the concept.
• MWEs compress to a single retrievable image — ideal for encoding.
• Debugging is often "find the MWE of the bug."

---

Gate 4 — Falsify

Actively try to break the concept. Don't wait for reality to test your understanding — test it yourself, now.

The falsification checklist

Ask for each concept:

• Counterexample: is there a case where the claim fails? If claimed to be true, where does it not apply?
• Edge cases: what about zero, empty, infinity, negative, one element, all elements the same?
• Nearest neighbor: what's the almost-but-not-quite version? What distinguishes them?
• Wrong version: what would the concept look like if it were wrong? Can you describe that clearly?
• Scope: what's outside the scope of this concept? When does it stop applying?

Worked example — "pure function" (programming)

• Counterexample: Math.random() — no input change, different output → not pure
• Edge case: a function that throws on certain inputs — is it still pure? (arguably yes if deterministic)
• Nearest neighbor: referentially transparent expressions — broader than pure functions
• Wrong version: "pure function = no side effects" misses determinism requirement
• Scope: doesn't apply to interactive systems at the top level; applies to interior computations

The failure-mode as encoding anchor

Whatever breaks the concept is your NEDF Failure slot. This gate directly feeds the encoding step. If Gate 4 produces nothing, the encoding will be weaker — no clear Failure to anchor it.

---

Gate 5 — Regenerate

Can you derive the concept from scratch, without looking?

Not explain — derive. Given the setup but not the answer, can you produce the result? This is the only real comprehension test; recognition is not.

The regeneration test

1. Close the source. 2. Take a blank page. 3. Write down the minimum setup that leads to the concept. 4. Derive the concept from that setup. 5. Compare to the original.

If you can't do this cleanly, you haven't understood — you've absorbed.

What to do when regeneration fails

Go back to the specific step where you couldn't continue. That's the weak link. Either:

• A prerequisite is missing → backfill (confusion-triage)
• A representation isn't there → redo Gate 2 with that representation
• The minimum example wasn't minimum enough → redo Gate 3

Worked example — "variance"

Setup: we want to measure how spread out a random variable is.

Derivation: 1. Natural first try: average the deviation from the mean. But E[X - μ] = 0 by definition of mean. Dead end. 2. Fix: make deviations positive. Two options: absolute value or square. 3. Square is analytically cleaner (differentiable, behaves well algebraically). 4. So: Var(X) = E[(X - μ)²]

If you can't walk this argument, you have the formula but not the concept.

---

The Full Protocol — Walk-Through

For any difficult topic:

1. Locate      — 2 minutes, place it on the map
2. Represent   — 10–30 minutes, produce 3+ representations
3. Minimize    — 5–15 minutes, find the MWE
4. Falsify     — 10–20 minutes, attack it
5. Regenerate  — 5–10 minutes, derive without notes
                 If fails → loop back to the gate that broke
6. Encode      — NEDF + CAST + formula-system as applicable
7. Apply       — use it on a real problem within 48h (otherwise it fades)

Total budget for a hard concept: 30–90 minutes before encoding. This is the real cost of understanding, and no shortcut exists. The memory systems speed up the "encode and retrieve" portion — the comprehension cost stays.

---

When to Use the Full Protocol vs. Abbreviated

Full protocol (all 5 gates):

• Load-bearing concepts you'll use repeatedly
• Foundational concepts in a new domain
• Concepts where you've previously had the illusion of understanding but got burned
• Anything you intend to teach

Abbreviated (Gates 1, 2, 5):

• Auxiliary concepts used once
• Concepts clearly subordinate to a deeper idea you've already mastered
• Under time pressure

Minimal (Gate 1 only, then encode):

• Vocabulary terms with no conceptual depth
• Factual information (names, dates, constants)

Rule of thumb: if the concept has a Wikipedia article longer than 3 screens, use the full protocol. If it's a paragraph, Gate 1 + encode.

---

Integration with the Rest of the System

• Gate 1 (Locate) → uses your existing CAST graph. Find the neighbors. If no neighbors → you need prerequisites first.
• Gate 2 (Represent) → the verbal and symbolic representations feed NEDF's Essence slot. Geometric feeds the image. Computational feeds a PAO chain.
• Gate 3 (Minimize) → the MWE is often the single best encoding image.
• Gate 4 (Falsify) → the strongest failure feeds NEDF's Failure slot directly.
• Gate 5 (Regenerate) → this is the Anki card (Format C in concept-encoding.md): "given setup, produce concept."

The protocol and the encoding system are complementary: comprehension produces the raw material; encoding stores it. Without comprehension, encoding is storage of confusion. Without encoding, comprehension decays.

---

Anti-Patterns — What to Watch For

These are the comprehension failure modes. Learn to notice them in yourself:

1. Fake-reading

Eyes move, pages turn, nothing sticks. Test: stop and try to summarize. If you can't, you weren't reading, you were scanning.

2. Illusion of explanatory depth

Feeling you understand because the explanation made sense to read. Different from being able to produce it. Gate 5 catches this.

3. Confabulation

Filling gaps with plausible-sounding but unverified logic. Happens under social pressure or time pressure. Test: can you point to the source for each claim?

4. Jargon substitution

Using the technical term as if it were an explanation. "It's a closure" instead of explaining how it works. Gate 2 prose-representation catches this.

5. Premature encoding

Trying to compress a concept into a mnemonic before understanding it. The scene will be weak and retrieval will fail. All five gates must precede encoding.

6. Teaching-the-test

Understanding only the specific examples given, not the general pattern. Gate 3 (minimum example) and Gate 4 (falsify at edges) catch this.

---

Key Principles

1. Understanding precedes encoding. Always. If a gate fails, don't encode. 2. Representation plurality is non-negotiable. One form = recognition, not understanding. 3. Minimum examples are disproportionately valuable. One MWE is worth ten complex examples. 4. Falsification is constructive. Breaking a concept strengthens your grasp of it. 5. Regeneration is the only real test. Recognition lies; regeneration doesn't. 6. Time cost is real and unavoidable. Difficult concepts cost 30–90 min of protocol work. No system reduces this below a floor. 7. Apply within 48 hours. Comprehension without application decays faster than encoded-but-applied.

---

End-to-end failure map (which layer broke?)

When output is wrong but you are unsure where, walk this stack top-down (from Beating the Red Queen (beating-the-red-queen.md) Master System Map, adapted to this ecosystem):

1. Attention — never selected the load-bearing idea (noise, passive skim). 2. Representation — wrong form for the material (needs diagram, map, or decomposition before encoding). 3. Encode — skipped gates, weak NEDF/CAST/SPEAR, or rushed scene. 4. Retrieve — no spaced retrieval, no palace walk, or cards never drilled both directions. 5. Apply — no mini-mission / real task; stayed at recognition (navigator.md DOK check; Act phase). 6. Maintain — deck/palace drifted from source truth; prune and verify (onboarding-path.md verification cadence).

Fix the first layer that failed; re-running later layers without fixing the root layer wastes cycles.

---

STEAM / STEMM examples

Three scenarios each for Science, Technology, Engineering, Arts, Math, and Medicine using this method: [steam-stemm-examples.md](./steam-stemm-examples.md#appendix-comprehension-protocol).

Design orientation — what this stack is for

The mnemonic ecosystem is built for usable competence under real constraints, not only for exams or code. It is explicitly aligned with four problem clusters, with STEAM (STEM + Arts) and STEMM (STEM + Medicine) treated as first-class lanes for examples and decks.

This file is the values + use-case map. Technical specs stay in the encoder files; this answers: why these tools, and where do I point them in life?

Memorizing this method

Helper: memorization-helpers.md — NEDF/SPEAR lens, minimal first session, stack placement.

---

The four clusters (problems the stack serves)

1. Life skills & emotional intelligence

• Resilience & adaptability: stress physiology, reappraisal, sleep/exercise as levers, “after-action” habits — encode as NEDF (especially Failure slots for your common collapse patterns), then Act in NAVIGATOR with tiny behavioral reps.
• Critical thinking & problem-solving: not memorizing conclusions — use Comprehension Protocol + Heuristic Palace + Domain Patterns so analysis becomes a walkable procedure, not a mood.
• Empathy & collaboration: perspective-taking frameworks, conflict scripts, listening checkpoints — Represent gate (multiple forms) + short CAST graphs (“their constraint → my move → shared outcome”).
• Decision making: explicit pros/cons, reversible vs irreversible bets — NAVIGATOR Narrow (contract + stop rule) + Measurement (track decision quality, not only outcomes).

2. Digital & future-ready skills

• Digital literacy & safety: phishing patterns, 2FA habits, password manager workflow, “verify sender” sequences — SPEAR for procedures, NEDF for concepts (“what breaks if I skip this?”).
• Adaptable tech skills: APIs and tools churn — CAST for dependency graphs (what calls what), Narrow scope per migration so the stack does not drown.
• Creativity: Arts lane — use Represent gate (sketch, storyboard, metaphor) before compressing; mnemonics then preserve images that stay emotionally alive without becoming vague.

3. Practical everyday skills

• Financial literacy: interest, inflation, fees, risk — NEDF + numeric encoders for numbers you must not garble; Act with spreadsheet or bank-app checks.
• Self-management: calendars, energy budgets, weekly reviews — externalize commitments; memory holds cues and stories, not the only copy.
• Independence (household): cooking ratios, cleaning order, tool names — SPEAR on a kitchen/hall palace; Peg for short material lists.
• Safety & emergency response: PASS for extinguisher, DRABC-style checks, “when to call EMS” — SPEAR chains (order-sensitive, high-stakes); refresh on a calendar, not hero memory.

4. Global citizenship & ethics

• Environmental sustainability: carbon cycle, feedback loops, policy tradeoffs — CAST graphs + Zoom In / Zoom Out maps; Falsify gate for greenwash claims.
• Cultural awareness: timelines of movements, ethical tensions, who is affected — history-style story spine + Graphs; Fairness from Thinking Standards when comparing sources.

---

STEAM and STEMM (explicit lanes)

Arts are not decoration: they supply representation plurality (Gate 2) and metaphor discipline — the same gates stop “pretty but wrong” images.

Medicine is a high-consequence domain: this stack improves retrieval and organization of what you are already authorized to learn; it does not replace clinicians, simulators, or local regulation.

---

Quick map: cluster → subsystem

---

How NAVIGATOR uses these domains

Run Narrow with a human outcome (“fewer panic spend moments”, “calmer handoffs at work”), not only a syllabus. Act should produce observable behavior in the world — a conversation, a budget line changed, a drill completed — not only a flashcard streak.

---

Growth rule

Add one new pattern or one new palace corridor per month from real life/digital/practice/citizenship work — not from abstract “should learn” lists. The libraries in domain-patterns.md grow from your actual failures and wins.

---

STEAM / STEMM examples

Three scenarios each for Science, Technology, Engineering, Arts, Math, and Medicine using this method: [steam-stemm-examples.md](./steam-stemm-examples.md#appendix-design-orientation).

Major System — Full Table (00–99)

Consonant mapping: S/Z=0 · D/T=1 · N=2 · M=3 · R=4 · L=5 · J/SH/CH=6 · K/G=7 · F/V=8 · B/P=9

Memorizing this method

Helper: memorization-helpers.md — NEDF/SPEAR lens, minimal first session, stack placement.

---

STEAM / STEMM examples

Three scenarios each for Science, Technology, Engineering, Arts, Math, and Medicine using this method: [steam-stemm-examples.md](./steam-stemm-examples.md#appendix-major-system).