Catalog of 14 learning graph lenses

Every visualization is a projection of the same versioned knowledge model. No graph owns facts, and no graph is maintained by hand after its source records exist.

Each commercial visualization ships in two complete locales:

HTML/zh/graphs/<graph-id>.html
HTML/en/graphs/<graph-id>.html

Personal graphs are generated only inside the private local build.

1. Concept relation graph

Question answered: “How do reusable templates relate?”

• Nodes: foundations, leaf templates, and composite patterns.
• Edges: specializes, prerequisite, alternative, dual,

combines_with.

• Interaction: select a concept to isolate its one-hop neighborhood and inspect

the reason for each typed edge.

• Scope: commercial.
• Scale rule: show every concept, but only reviewed relations.

2. Problem similarity graph

Question answered: “Which problems train the same invariant, and what is the smallest useful next step?”

• Nodes: externally referenced practice problems.
• Edges: same core invariant, same recipe, variant, prerequisite, contrast, or

same objective with a different engine.

• Similarity is sparse: top 3–5 neighbors per problem, with degree caps and

mutual-kNN preference.

• Navigation uses an offline typeahead rather than a full-catalog selector.

Search can be scoped to all results, problems, or templates and ranks exact IDs before title, tag, template/family, and fuzzy matches. At most 10 result options are rendered, while URL state restores the selected ego graph.

• Scope: private personal by default. A commercial version is disabled until

every source/problem mapping has documented commercial permission.

3. Prerequisite learning roadmap

Question answered: “What should I learn before this, and what does it unlock?”

• Nodes: concepts/templates.
• Directed edges: prerequisite_of only.
• Layers: foundations → reusable engines → composite recipes → advanced

variants.

• Interaction: choose a destination template to highlight the shortest study

path and missing prerequisites.

• Scope: commercial.

4. Algorithm-selection decision graph

Question answered: “Given a new prompt, which questions should I ask before choosing an algorithm?”

• The entry gate asks whether explicit or implicit graph adjacency is natural and

whether the goal is reachability/connectivity, dependency order, or path optimization; merely being able to name “states” is not enough.

• Later decision nodes cover objective, cost model, monotonicity, ordering,

constraint size, and output shape.

• Outcome nodes: candidate templates, not guaranteed answers.
• A terminal advice node explicitly stops template guessing and asks the learner

to rewrite state, transition, objective, constraints, and the state budget.

• Edges: labeled yes/no/value branches.
• Interaction: step through one diagnostic path; every outcome shows assumptions

that still require proof.

• Scope: commercial.

This graph is the visual counterpart of the interview thought process:

abstract the objective
→ identify state and transition
→ extract constraints
→ test algorithm preconditions
→ choose an engine
→ state the invariant

5. Constraint-to-template graph

Question answered: “What does a constraint such as n <= 20, sorted input, 0/1 weights, or monotone feasibility make possible?”

• Left nodes: structural and numeric constraint signals.
• Right nodes: templates.
• Edges: enables, suggests, or rules_out, each with a reason.
• Interaction: select a signal to see candidates and false positives.
• Scope: commercial.

This is deliberately separate from topic tags. A tag says what appears in the problem; a constraint often decides what can run.

The graph distinguishes general merge-only connectivity—where Union–Find works without any threshold order—from the more specialized offline sorted-activation signal.

6. Composite recipe graph

Question answered: “Which hard problems are built by composing familiar stages?”

• Nodes: templates and recipes.
• Directed step edges: stage order and role (preprocess, rank-lookup, core,

checker, reconstruct, optimize).

• Examples are source-neutral recipes such as:
  • multi-source BFS → assign a nonnegative cost field → minimize the maximum

path cost with minimax relaxation;

• sort events → activate components → answer offline connectivity queries;
• binary search on answer → greedy/BFS feasibility checker.

• Coordinate compression explicitly separates sort/deduplicate/rank creation

from optional binary-search rank lookup. Length search with rolling hash is offered only after feasible(length) monotonicity has been proved.

• Scope: commercial.

7. Contrast and dual graph

Question answered: “Which techniques look similar but differ in one decisive invariant?”

• Nodes: templates/objectives.
• Edges: dual_of, contrast_with, and same_shape_different_operator.
• High-value pairs: minimax vs maximin, BFS vs Dijkstra, prefix sum vs sliding

window, monotonic stack vs monotonic deque, offline DSU vs repeated search.

• Interaction: select one pair to see the decision boundary in one sentence.
• Scope: commercial.

8. Error-pattern to invariant graph

Question answered: “What bug am I making, and which invariant did it violate?”

• Nodes: reusable error patterns, invariants, and templates.
• Edges: violates, appears_in, and prevented_by.
• Interaction: start from a symptom such as “mark visited on push” or “binary

search does not converge” and trace to the broken invariant and fix checklist.

• Scope: commercial.

This turns debugging experience into reusable intellectual property rather than a list of isolated mistakes.

9. Complexity feasibility map

Question answered: “For this input scale, which complexity families are plausible?”

• Horizontal dimension: approximate input scale / state count.
• Vertical groups: exponential, cubic, quadratic, n log n, linear, and

logarithmic families.

• Marks: templates with assumptions and hidden dimensions (V, E, alphabet,

bitmask size, value range).

• Mixed-granularity entries stay explicit: orientation is O(1) per predicate

and O(n) or O(n log n) in a batch, while simulation uses O(K·C) for K processed events and worst-case transition cost C.

• Interaction: choose an input scale to highlight plausible regions; ceilings

are guidance, not guarantees.

• Scope: commercial.

This is a map rather than a network graph because a shared scale communicates the relationship more truthfully.

10. Personal mastery and forgetting graph

Question answered: “What should I review today, and which concepts are weak because of repeated mistakes?”

• Nodes: the user's concepts and private practice references.
• Size: review urgency; visual state: mastery band; edges: prerequisite or

repeated-confusion relation.

• Inputs: recall ratings, last review, error types, solve history, and manual

confidence.

• Scope: private personal only; never enters analytics or commercial exports.

11. Transfer ladder graph

Question answered: “After I know an anchor pattern, which variation best tests transfer instead of rote memory?”

• Nodes: anchor, core, contrast, and stretch exercises.
• Directed edges: one changed dimension at a time—state space, objective,

transition operator, constraint, or reconstruction requirement.

• The “why an order is valid” ladder explicitly contrasts order-free frequency

summaries, dependency-forced topological order, exchange-proved greedy order, and an online rank boundary maintained by two heaps.

• Scope: the graph engine and original exercises are commercial; mappings to

third-party problem banks require permission.

12. Coverage and quality graph

Question answered: “Where is the atlas incomplete or unreliable?”

• Nodes: templates and content units.
• Signals: missing locale, missing invariant, absent code test, low-confidence

private mappings, no reviewed relation, or insufficient anchor examples.

• Interaction: filter by release blocker and open the authoring source.
• Scope: internal authoring tool, not a customer-facing graph.

13. Modeling-transform graph

Question answered: “How do I turn the surface story into an algorithmic model?”

• Left nodes: source representations such as grids, intervals, dependencies,

thresholds, subsets, streams, and operation sequences.

• Right nodes: model transformations such as grid → graph, adjacency → reachable

components, intervals → sorted events, threshold → monotone predicate, bounded integer → digit automaton, pointer chain → cut/splice boundaries, and subset → bitmask state.

• Edges: reframe_as, with both the evidence that permits the transformation

and the information that would be lost.

• Interaction: start from the representation visible in a prompt, then inspect

the candidate models and their required assumptions.

• Scope: commercial.

This view trains modeling skill. It deliberately sits before algorithm selection: the same algorithm can become obvious only after the right state space or event representation exists.

14. Proof-obligation graph

Question answered: “What must I prove before I trust this template?”

• Left nodes: proof obligations such as monotone feasibility, settled-frontier

finality, dominance safety, exchange safety, optimal substructure, and state-sufficiency.

• Right nodes: templates.
• Edges: requires_proof, with a compact falsification question.
• Interaction: select a candidate algorithm to reveal the claims that still

need justification before coding.

• Scope: commercial.

This graph prevents pattern matching from becoming cargo culting: a template is a candidate only until its preconditions and invariant are proved.

Review Cheatsheet index

The final review-cheatsheet.html is not another graph. It is the navigational compression layer over the whole system:

• 18 families and all reusable templates;
• one recognition line, invariant, canonical skeleton, complexity, and top

failure mode per template;

• direct links into every rich Markdown/HTML page and visualization;
• a compact decision route for selecting a candidate template;
• complete zh and en builds from the same locale records.

It must remain useful as a fast scan: graph exploration is optional, while the index always exposes the core memory hooks directly.

Shared graph QA

• Node IDs are stable and locale-independent.
• All visible labels have both locales.
• Typed edges have direction and a human-readable reason.
• No self-edge, missing endpoint, or orphan caused by a broken ID.
• Dense graphs enforce degree caps and do not create cluster cliques.
• Canvas/SVG has a concise accessible summary and keyboard-accessible selection.
• Every commercial node/edge passes provenance policy.
• HTML node/edge counts match the build manifest.

My notes