Compression, But Make It Pedagogical: Rate–Distortion KGs for Smarter AI Learning Assistants

Training teams know the ritual.

Someone uploads lecture slides, notebooks, policy manuals, onboarding decks, or certification material into an AI tool. The system dutifully produces quiz questions. Some are useful. Some are bland. Some include giveaway answers. Some test trivia. Some hallucinate just enough to be annoying but not enough to be obviously illegal. Everyone nods, calls it “AI-assisted learning,” and then quietly sends the outputs to a human reviewer. Automation, but with adult supervision. So, normal Tuesday.

The paper behind this article proposes a more disciplined version of that pipeline. In Rate-Distortion Guided Knowledge Graph Construction from Lecture Notes Using Gromov-Wasserstein Optimal Transport, Yuan An and colleagues argue that lecture-note-to-knowledge-graph construction should be treated as a compression problem, not just an extraction problem.¹ The goal is not to stuff every possible concept into a graph. The goal is to find the graph that preserves the useful instructional structure of the source while avoiding unnecessary complexity.

That sounds abstract, because rate–distortion theory and fused Gromov-Wasserstein optimal transport are not exactly phrases one casually drops into a Monday curriculum meeting without losing the room. But the operational idea is simple: a learning assistant needs a representation that is rich enough to support good questions and compact enough not to become an overgrown semantic hedge. The paper offers a way to measure that trade-off.

The important move is not “use a knowledge graph.” We already knew that structured knowledge can help language models behave less like caffeinated autocomplete. The important move is “use a measurable stopping rule for how much graph is enough.” That is where the paper becomes commercially interesting.

The problem is not missing structure; it is uncontrolled structure

AI learning assistants often need to generate retrieval-practice questions from messy educational content. Lecture notes, Jupyter notebooks, slides, and internal training materials are not naturally arranged as machine-friendly concept maps. They mix narrative sequence, definitions, examples, code, prerequisites, and occasionally the instructor’s personality. Charming for humans. Less charming for automated assessment.

A common response is to extract a knowledge graph: identify concepts, define relations, and use that graph as a structured substrate for question generation. The problem is that extraction alone does not solve the control problem.

A graph can fail in two opposite ways.

It can be too small. Important material collapses into vague nodes, so the model generates shallow questions. A “pandas” node that quietly absorbs indexing, grouping, aggregation, missing values, reshaping, and time series will not support precise assessment. It is a suitcase, not a curriculum model.

It can also be too large. Every heading, subheading, minor example, and adjacent concept becomes a node. The graph looks thorough, but it is noisy, redundant, expensive to maintain, and harder to use. This is the enterprise knowledge-management equivalent of saying “we solved search by uploading everything.” Brave. Also false.

The paper’s central contribution is to formalize this as a rate–distortion trade-off. The lecture material is the source. The knowledge graph is the compressed representation. The “rate” is the complexity of the graph. The “distortion” is how much instructional meaning is lost when the lecture material is represented by that graph.

In implementation, the rate is approximated by graph description length: roughly the number of nodes plus half the number of edges:

The objective combines graph complexity and representational loss:

where $D$ is distortion and $\beta$ controls how strongly the system penalizes distortion relative to graph size. In the reported experiments, the authors use $\beta = 100$ because the rate term is usually tens to hundreds, while the fused Gromov-Wasserstein distortion is a fractional value below 1.

This is the paper’s quiet correction to a likely misconception: the method is not saying “bigger knowledge graphs make better learning assistants.” It is saying that a graph should keep growing only while added complexity buys meaningful reduction in distortion. After that, the graph is just wearing a lab coat.

Lecture notes become a metric space before they become a graph

The mechanism begins by turning lecture material into a metric-measure space. That phrase is doing real work, but it can be unpacked.

The source lecture notes are first converted from Markdown into atomic instructional units. Each unit receives three kinds of context:

1. its chronological position in the lecture;
2. its hierarchical section path;
3. its textual content, embedded into a semantic vector space.

From those components, the system builds distances between lecture elements. Two lecture segments may be close because they occur near each other, because they live under similar headings, or because their text embeddings are semantically similar. The paper combines chronological, logical, and semantic distances using weights initialized as:

That weighting says something sensible: semantic similarity matters most, but lecture order and document structure still carry pedagogical signal. In teaching material, proximity is not just spatial. It often encodes dependency, sequence, or emphasis.

The initial knowledge graph is then bootstrapped with an LLM using a predefined relation ontology. The allowed relations include categories such as isA, partOf, prerequisiteOf, dependsOn, uses, exampleOf, contrastsWith, implies, provedBy, produces, consumes, and assessedBy.

That relation constraint matters. Without it, LLM-generated graphs can drift into semantic soup: plausible labels, inconsistent edges, unclear hierarchy, and relations that feel right until someone needs to maintain them. Here, each node and edge is also annotated with provenance, line span, text excerpt, confidence score, and rationale. That makes the graph auditable, not just decorative.

The graph itself is also converted into a metric-measure space. Node distances combine graph topology and semantic distance between node texts. The paper initializes the graph-distance fusion with:

Again, the weighting leans semantic while preserving topology. This is appropriate for educational KGs because a graph edge is not merely a link. It can encode prerequisite structure, contrast, example, use, or assessment relationship. The structure is part of the pedagogy.

FGW is the measuring device, not the product

Once the lecture and the knowledge graph are both represented as metric-measure spaces, the system needs to compare them. But they do not live in the same space. Lecture segments are ordered text units. KG nodes are graph concepts. Ordinary distance measures are not enough.

The paper uses fused Gromov-Wasserstein optimal transport. In practical terms, FGW finds a soft alignment between lecture segments and graph nodes while considering two kinds of mismatch:

• semantic mismatch, where a lecture segment is paired with a graph concept that does not mean the same thing;
• structural mismatch, where relationships among lecture segments are not preserved by relationships among graph nodes.

The distortion term is minimized over possible couplings between source elements and graph nodes. The paper’s distortion objective includes a structural component based on pairwise distance differences and a feature component based on semantic cost. The feature weight $\lambda$ balances those two parts. In the experiments, $\lambda_{\text{feat}} = 0.6$.

This is the technical heart of the paper. FGW does not merely ask whether every term appears somewhere in the graph. It asks whether the graph preserves enough of the source’s geometry: which things are near, which things are far, and which things belong together.

That distinction is important for education. A learning assistant that knows the word “MultiIndex” exists is less useful than one that knows how MultiIndex relates to hierarchical indexing, stacking, unstacking, set_index, and reset_index. Vocabulary coverage is not curriculum understanding. It is the start of curriculum understanding, and occasionally its cheap impersonator.

The graph edits are local, but the objective makes them disciplined

After computing FGW alignment, the system refines the graph through local operations. These are familiar knowledge-graph edits, but the rate–distortion objective gives them a reason to exist.

The example in the paper is concrete enough to show how this behaves. In a pandas lecture segment, the system identifies hierarchical indexing content as under-covered and adds a “MultiIndex basics” node. It then splits an overloaded “indexing” node into set_index and reset_index, merges redundant “groupby aggregation” and “groupby-agg” nodes, adds a relation between set_index and sort_index, and prunes a weak relation elsewhere.

This is not a fully autonomous curriculum designer. It is a graph-refinement loop with a measurable objective. That difference matters. The system proposes edits because the coupling says the current representation is distorting the source, not because an LLM had a sudden aesthetic preference for more arrows.

The refinement loop records rate, distortion, structural and feature components, and the combined objective. It accepts changes that improve the trade-off and stops when the objective converges or when the empirical rate–distortion curve reaches its knee.

The knee point is the article’s central business metaphor, and unlike most business metaphors, it actually means something. The paper identifies the knee geometrically: the refinement step with the maximum perpendicular distance from the line joining the first and last RD points. In human terms, it is the point where more graph complexity starts buying much less reduction in distortion.

That is the “enough” signal.

The main evidence is encouraging, but it is not an ablation buffet

The experiments use eight weeks of lecture notes from an introductory data science programming course. The materials started as Jupyter notebooks and covered topics including NumPy, pandas, data aggregation, and time series analysis. Each week gets an initial LLM-bootstrapped KG, then RD-guided refinement.

The paper reports three main evidence streams: coverage improvement, rate–distortion behaviour, and downstream MCQ quality. It does not report a broad ablation study, a multi-domain benchmark, a human instructor evaluation, or a direct comparison against several prior KG-construction systems. Those absences do not invalidate the work. They do tell us what kind of claim the paper supports.

This distinction is important because the paper’s evidence is best read as a prototype demonstration, not as a final platform benchmark. It shows a promising control mechanism. It does not settle procurement, pedagogy, or scaling.

Still, the numbers are not trivial.

The refined KGs improved coverage by an average absolute +0.304 over the initial LLM-bootstrapped KGs. Coverage here means the fraction of lecture segments matched to at least one KG node under a low feature-distance threshold, with the tolerance set at the 30th percentile of the feature-distance distribution.

That is a meaningful representation result. It says the refinement process is not just rearranging graph furniture. It is increasing the fraction of lecture material that the graph can plausibly explain.

The RD behaviour also matches the theory: early refinements substantially reduce distortion, while later refinements flatten out. On average, the knee point corresponds to roughly 50% reduction in distortion with only roughly 30% of the total rate cost. Beyond that point, additional refinements still improve coverage marginally, but complexity grows disproportionately.

That is the part learning-platform teams should notice. A graph may keep getting “better” by one metric while becoming worse as an operational artefact. More nodes mean more maintenance, more review, more inconsistencies, and more opportunities for downstream generation to anchor on narrow or ambiguous concepts. The best graph for a business process is not necessarily the largest graph the system can extract before lunch.

The MCQ results improve most where structure helps most

The downstream test is MCQ generation. For each of the eight lectures, the authors prompt the LLM to generate 25 MCQs directly from raw lecture notes and another 25 from the refined KG. That yields 400 MCQs in total: 8 lectures × 50 questions. Each MCQ is evaluated against 15 criteria on a 1–5 scale.

The headline result: KG-based MCQs average 4.70, while lecture-based MCQs average 4.08. The paper describes this as approximately +15% total quality improvement.

The criterion-level results are more revealing than the average. The largest improvements are:

• no_answer_hints: +1.805
• hard_to_guess: +1.210
• no_duplicates: +1.190
• option_balance: +1.110
• plausible_distractors: +1.095
• cognitive_engagement: +0.995
• grammar_fluency: +0.925

This pattern makes sense. Structured concept graphs are especially useful for producing balanced alternatives, plausible distractors, and questions that do not accidentally reveal their own answer. A graph gives the generator nearby but distinct concepts. That is exactly what good distractors need.

The improvements are smaller on factual correctness criteria: correct_key_answer improves by +0.190, unambiguous_correctness by +0.090, and factual_accuracy by +0.085. Those are positive, but modest.

More interestingly, three criteria get worse:

• incorrect_assumption: -0.010
• no_hallucinations: -0.150
• unambiguous_options: -0.185

This is not a footnote. It is a warning label with manners.

The paper suggests a plausible explanation: KGs are concise and abstract, so they may provide fewer textual cues than raw lecture notes. A graph can structure the generator’s choices while also stripping away context that helps avoid ambiguity or unsupported detail. That is the trade-off. Compression makes structure more usable, but it can also remove some grounding.

For business use, this means RD-guided KGs should not be sold as a complete replacement for source-context retrieval. A better production architecture would likely pair the refined KG with source snippets, provenance, and retrieval over original materials. The KG should decide what conceptual neighbourhood the question belongs to. The source text should still help decide exactly what can be safely said.

The business value is quality control, not graph enthusiasm

The commercial reading of this paper is straightforward: AI learning systems need intermediate representations that can be tested, edited, and governed. Raw-document prompting is too loose. Fully manual curriculum engineering is too slow. A rate–distortion KG sits between them.

The business pathway looks like this:

1. Convert training material into structured source units.
2. Bootstrap a task-oriented KG with provenance.
3. Use FGW alignment to measure what the KG misses or distorts.
4. Apply graph edits only when they improve the rate–distortion objective.
5. Stop near the knee point instead of endlessly expanding the graph.
6. Generate assessments from the refined KG, preferably with source retrieval for grounding.
7. Use criterion-level evaluation to identify where the system helps and where humans still need to review.

For edtech companies, this becomes a better MCQ-generation backend. For corporate learning teams, it becomes a way to turn compliance, onboarding, product, and technical-training materials into assessment-ready structures. For AI tutoring platforms, it becomes a curriculum representation layer that supports question generation, personalised review, and concept-level remediation.

The value is not that a KG exists. The value is that the KG has a measured relationship to the source material. That makes it governable.

A useful analogy is not “an AI tutor with a bigger brain.” Please, spare us. It is closer to a compression codec for instructional content. The system takes a messy source, produces a compact representation, estimates loss, and stops where additional detail becomes inefficient. The compression is pedagogical because the retained structure is meant to support learning tasks, not just storage.

The operating model changes from prompt engineering to representation governance

Many current learning-assistant workflows treat prompting as the main control surface. If the output is poor, add instructions. If it is still poor, add examples. If it is still poor, add a larger model and a document that begins “You are an expert educator…” because apparently we are still doing theatre.

The paper points toward a different operating model. Instead of asking the model to infer everything at generation time, build a task-specific representation first, then evaluate whether that representation preserves the instructional structure needed for the task.

That shift has practical consequences.

First, quality review moves upstream. Instead of reviewing hundreds of generated questions one by one, teams can inspect graph coverage, provenance, overloaded nodes, missing concepts, and weak relations. Human experts still matter, but they review structure and boundary conditions rather than only final outputs.

Second, the graph becomes a reusable asset. Once a data-science module has a refined KG, it can support MCQs, adaptive review, prerequisite checks, concept maps, student diagnostics, and retrieval routing. The return on engineering effort improves if the representation serves multiple learning functions.

Third, the rate–distortion curve gives product managers an argument against infinite enrichment. In many organizations, “more complete” wins because nobody has a formal way to price complexity. RD analysis gives the team a curve, a knee, and an explicit trade-off. It turns “this graph feels too big” into “after this point, added rate buys little distortion reduction.”

That is not just mathematically cleaner. It is politically useful. Enterprise AI projects often fail less from missing technology than from lacking a stopping rule.

The method is narrow enough to trust cautiously

The boundaries are clear.

The experimental dataset is one introductory data-science programming course, eight lecture weeks, and materials converted from Jupyter notebooks into Markdown. That is useful, but narrow. Legal training, medical education, sales onboarding, manufacturing safety, and executive leadership modules may have very different structure. Some domains depend heavily on procedural steps, exceptions, case law, diagrams, tacit judgement, or policy nuance. The paper does not prove that the same hyperparameters or relation ontology transfer.

The evaluation task is MCQ generation. MCQs are important for retrieval practice, but they are not the whole of learning. The paper does not measure student outcomes, long-term retention, instructor grading time, expert satisfaction, or tutoring dialogue quality. It shows that refined KGs improve evaluated MCQ quality under a 15-criterion rubric. That is valuable. It is not the same as proving better learning.

The evaluation appears to rely on LLM-based generation and scoring rather than a large human-rater study. The paper describes independent evaluation against the criteria, but the evidence is still downstream of model-mediated assessment. For production deployment, human validation would be needed, especially in regulated or high-stakes education.

The method also contains several design choices that deserve sensitivity testing: distance weights for lecture elements, graph-distance weights, feature-vs-structure balance, threshold choices for adding, splitting, merging, relating, pruning, and the selected $\beta$. The paper reports the chosen hyperparameters, but it does not provide a full robustness analysis showing how results change under alternatives.

Most importantly, the negative criterion results are telling. KG-based generation slightly underperforms raw lecture notes on hallucination avoidance and option ambiguity. This means the KG is not enough by itself. It should be treated as a structured guide, not as the entire source of truth.

That boundary is not a weakness of the idea. It is the shape of the product.

A production version would combine KG structure with source-grounded retrieval

The natural next step is not to throw away raw notes. It is to coordinate them.

A production architecture might use the refined KG for concept selection, prerequisite awareness, distractor generation, and assessment coverage. Then it would retrieve source passages linked by provenance to support factual wording, examples, and answer validation. The KG gives shape. The notes give texture. The evaluator checks both.

A disciplined implementation would also separate three layers:

This is where the paper becomes more than an educational research prototype. It offers a way to formalize an intermediate control layer for learning automation.

The same logic could apply outside universities. Corporate training teams have similar problems: onboarding content sprawls across decks, videos, SOPs, wikis, Slack exports, and “ask Sarah, she knows” folklore. A rate–distortion KG would not magically solve organizational entropy. Let us stay adults. But it could help identify which concepts are actually represented, which are redundant, which are missing, and where assessment generation is likely to fail.

That is useful because training content often ages badly. New products, rules, policies, and internal processes change faster than assessment banks. A representation layer with provenance and distortion metrics gives teams a way to update the structure systematically instead of rewriting quiz banks by vibes.

The real claim is about controlled compression

The best way to read this paper is not as “knowledge graphs improve LLM question generation,” although the MCQ results support that in this setting. The sharper claim is that educational knowledge graphs need a compression objective.

Without compression discipline, a KG pipeline has two bad defaults. It either preserves too little and produces generic questions, or preserves too much and becomes another unmaintainable knowledge artefact. Rate–distortion theory gives that trade-off a vocabulary. FGW gives it a measurement technique. Local graph edits give it an implementation path.

The paper’s numbers are encouraging: +0.304 average coverage improvement, approximately 50% distortion reduction at the knee with about 30% of total rate cost, and MCQ quality rising from 4.08 to 4.70 on a 5-point rubric. The criterion-level results are even more useful because they show where the method helps most: reducing answer hints, improving guessing resistance, removing duplicates, balancing options, and making distractors more plausible.

But the negative results matter too. The KG-based route slightly worsens hallucination avoidance and option ambiguity. That is the cost of abstraction showing up in the evaluation. A compact graph can guide the model, but it may not provide enough local context to keep every generated option clean.

So the business lesson is not “replace raw educational content with graphs.” It is “place a measurable representation layer between raw content and generation, then keep the source attached.”

A good learning assistant should not merely remember everything. It should know what to compress, what to preserve, and when more structure has stopped paying rent.

That is less glamorous than a fully autonomous AI tutor. It is also more useful.

Cognaptus: Automate the Present, Incubate the Future.