Skip to content

Prerequisite Tree

Artifact — instantiates Knowledge Map Navigation

A dependency diagram showing what must be understood before what — its roots the safe places to start, its depth the climb in difficulty.

A Prerequisite Tree is the bare dependency structure of a body of knowledge: each topic is a node, and an arrow from A to B means you must understand A before B makes sense. Its defining trait is that it captures only the ordering constraint — not what topics mean, not how to teach them, not one learner's goal — just the "before/after" relation, laid out as a directed graph. Because the relation is dependency, the tree reads at a glance: the roots (nodes with nothing before them) are the only safe places to start, and depth — how many dependencies stack beneath a topic — is a direct proxy for how much groundwork it demands, i.e. its difficulty. It is the skeleton other navigation artifacts are built on: a learning path is one legal walk through it, a curriculum is it plus outcomes and institutions.

Example

An online math platform wants learners to be able to jump in anywhere without hitting a wall of unexplained prerequisites. It builds a Prerequisite Tree over its topics: addition → multiplication → fractions → ratios → …, fractions + variables → algebraic fractions, and so on, each arrow a hard "needs-before" dependency drawn after the fashion of formal prerequisite structures in learning research.[1] The tree's shape does the work. Its roots — counting, basic addition — are flagged as the entry points a total beginner can start from with nothing assumed. A topic like solving rational equations sits deep in the tree, and that depth is the warning: it stacks a dozen dependencies, so the platform knows to gate it rather than surface it early. When a learner fails at ratios, the tree instantly names the suspects — the parents fractions and division — as where the missing foundation probably is. The tree stores no lesson content; it stores only order, and that turns out to be enough to locate starting points, sequence difficulty, and diagnose gaps.

How it works

  • Model topics as nodes, dependencies as arrows. Each edge asserts one thing only: the tail must be understood before the head.
  • Keep it acyclic. A cycle would mean "A needs B needs A" — an impossible ordering — so detecting and breaking cycles is a core validity check.
  • Read roots as entry points. Nodes with no incoming dependency are exactly the topics needing no prior knowledge — the legitimate starting places.
  • Read depth as difficulty. How deep a node sits (how many prerequisites stack beneath it) gives a structural difficulty ordering without anyone grading topics by hand.

What distinguishes it from its siblings is minimalism: it is only the dependency graph. A learning path adds a goal and a learner's state; a curriculum adds outcomes and program structure; the tree adds nothing but order.

Tuning parameters

  • Prerequisite strictness — marking only hard "impossible without" dependencies keeps the tree lean and permissive; adding soft "helps to know first" edges is safer but over-constrains and deepens the tree.
  • Node granularity — coarse nodes (whole courses) give a small readable tree; fine nodes (individual skills) enable precise gap-diagnosis but explode the graph.
  • Edge confidence — treating every prerequisite as certain is simple but wrong at the margins; annotating contested edges is honest but complicates the "before/after" clarity.
  • Multiplicity handling — allowing a topic several prerequisites (a true DAG) is realistic; forcing a strict single-parent tree is simpler to draw but falsifies genuinely convergent dependencies.

When it helps, and when it misleads

Its strength is that a single structural relation yields three navigation goods at once: legitimate starting points (roots), a difficulty ordering (depth), and a diagnostic for failure (check the parents). It is the reusable foundation that learning paths and curricula are derived from rather than reinvented.

Its failure mode is mistaking a modelling choice for a fact of the subject. Prerequisite relations are often softer and more negotiable than the hard arrows suggest — plenty of people learn topics "out of order" productively — and an over-strict tree can gate learners out of material they could have handled, entrenching a single canonical ordering as if it were the only one. The classic misuse is drawing the dependencies to match how the material happens to be packaged (this chapter comes before that one) rather than genuine conceptual dependence. The discipline is to justify each edge as a real "can't understand B without A," keep the graph acyclic, and treat soft prerequisites as advisory rather than hard gates.

How it implements the components

A Prerequisite Tree fills the archetype's dependency-ordering slots:

  • prerequisite_link — its sole content: directed "must-know-before" edges between topics.
  • entry_point — the roots (dependency-free nodes) are exactly the topics a newcomer can start from.
  • difficulty_gradient — depth in the tree gives a structural difficulty ordering for free.

It does not attach a goal or a learner's current state (navigation_goal, user_state_marker — that's Learning Path Guide), record learning outcomes or program strands (cluster_boundary, outcomes — that's Curriculum Map), or name and define the topics themselves (concept_node with meaning — that's Concept Map).

  • Instantiates: Knowledge Map Navigation — the Prerequisite Tree is the bare dependency skeleton other navigation artifacts build on.
  • Sibling mechanisms: Learning Path Guide · Curriculum Map · Domain Map · Concept Map · Ontology Map · Knowledge Graph · Research Landscape Map · Documentation Navigation Map · Knowledge Gap Register · Map Navigation User Test

Notes

The Prerequisite Tree is a source artifact: a Learning Path Guide is a goal-directed walk through it starting from a learner's state, and a Curriculum Map is it enriched with outcomes and institutional structure. Keeping the tree free of goals and outcomes is what lets many different paths and programs be derived from the same dependency skeleton.

References

[1] Knowledge space theory (Jean-Paul Doignon and Jean-Claude Falmagne) formalizes exactly this kind of structure — the prerequisite relations among the items of a domain and the "knowledge states" a learner can be in — and underlies adaptive systems that decide what a learner is ready to attempt next. ↩