Curriculum-Intelligence Use Case

• Curriculum-Intelligence is an approach that represents and analyzes course structures through computational techniques to enable adaptive curriculum design.
• It utilizes structured data extraction, rule-based entity linking, and knowledge graph construction for visualizing course prerequisites and dependencies.
• The system supports dynamic query interfaces and graph analytics to identify bottlenecks and optimize strategic educational planning.

A Curriculum-Intelligence use case is an integrated socio-technical application in which formal curriculum structures—such as course catalogs, syllabi, and learning objectives—are represented, analyzed, and operationalized through advanced computational techniques (notably, knowledge graphs and AI-based analytics) to enable visualization, querying, optimization, and strategic planning of course pathways, prerequisites, and dependencies. The objective is to facilitate actionable understanding, adaptive curriculum design, and data-driven decision-making for educators, planners, and learners by transforming traditionally opaque curriculum documents into interactive, analyzable, and explainable knowledge resources (Yu et al., 2020).

1. Pipeline and System Architecture

The canonical Curriculum-Intelligence pipeline is segmented into four principal phases: data acquisition, preprocessing/entity extraction, knowledge graph construction, and visualization/query interface.

• Data Acquisition incorporates heterogeneous sources such as Word-format syllabi (with tabular course attributes including "Prerequisite" fields) and Excel training plan spreadsheets.
• Extraction routines employ lightweight DOCX/XLSX parsers to pull structured fields (Course Title, Credits, Prerequisites).
• Preprocessing and Entity Extraction precisely identifies entities of interest—type Course—extracts discrete attributes (code, title, credits, skills, instructor, enrollment capacity), and applies a rule-based extractor on the Prerequisite columns using delimiter-splitting and fuzzy name normalization.
• Knowledge Graph Construction models each course as a distinct node with requisite properties and directed edges for explicit prerequisite relations; these are then bulk-loaded into a graph database (e.g., Neo4j) using either Cypher-based bulk operations or the Neo4j ETL toolkit.
• Visualization and Query Interface is served via the Neo4j Browser or a custom web front—enabling dynamic graph exploration (prerequisite trees, path queries, cluster visualization).

This architectural stack permits structured, programmatic access to course interrelations at scale (Yu et al., 2020).

2. Formal Graph Schema and Modeling

The knowledge graph $G = (V,E)$ is defined as follows:

• $V$ (Vertices): Courses, each with properties:
  • $c.\text{code} \in \mathbb{S}$ (unique)
  • $c.\text{title} \in \mathbb{S}$
  • $c.\text{credits} \in \mathbb{N}$
  • $c.\text{skills}$: $\text{List}[\mathbb{S}]$
  • $$c.\text{capacity},\ c.\text{enrolled} \in \mathbb{N}$$
  • $c.\text{instructor} \in \mathbb{S}$
• $E$ (Edges): Each edge $(u \rightarrow v)$ encodes "$u$ is a prerequisite of $v$".
• Neo4j representation:
  • Nodes: (:Course {code, title, credits, ...})
  • Edges: (:Course)-[:HAS_PREREQUISITE]->(:Course)

Constraints such as uniqueness (c.code IS UNIQUE) and indexes (e.g., on title) are enforced to enable rapid lookups and integrity.

3. Entity and Relationship Extraction

The extraction methodology is deterministic, rule-based, and robust to common tabular encodings:

• Parse each row, locate the "Prerequisite" cell.
• Tokenize on [" & ", ",", " and "], remove extraneous whitespace.
• Each token is normalized and then mapped to course titles via fuzzy matching using the Levenshtein-based similarity metric:

$$\operatorname{sim}(a,b) = 1 - \frac{\text{Levenshtein}(a,b)}{\max(|a|, |b|)}$$

• When $\operatorname{sim} \geq 0.8$, the token is assigned to the existing course node; otherwise, flagged for human validation.
• No general-purpose NLP (e.g., TF–IDF) or advanced sequence modeling is required due to the high structure of the input tables.

4. Database Ingestion and Querying

Load Table Example:

LOAD CSV WITH HEADERS FROM 'file:///courses.csv' AS row MERGE (c:Course {code: row.code}) SET c.title = row.title, c.credits = toInteger(row.credits), c.skills = split(row.skills,';'), c.capacity = toInteger(row.capacity), c.enrolled = toInteger(row.enrolled), c.instructor = row.instructor;

Prerequisite Edges:

LOAD CSV WITH HEADERS FROM 'file:///prereqs.csv' AS row MATCH (p:Course {code: row.prereq}), (c:Course {code: row.course}) MERGE (p)-[:HAS_PREREQUISITE]->(c);

Sample Queries:

• Retrieve all direct prerequisites of a course:

  MATCH (p:Course)-[:HAS_PREREQUISITE]->(c:Course {title:'Algorithms I'}) RETURN p.code, p.title;

• Retrieve all ancestors (full prerequisite chain):

  MATCH path = (ancestor:Course)-[:HAS_PREREQUISITE*1..]->(c:Course {code:'CSE201'}) RETURN nodes(path), relationships(path);

• Identify bottleneck courses (high in-degree):

  MATCH (p:Course)-[:HAS_PREREQUISITE]->() WITH p, count(*) AS inDeg WHERE inDeg > 5 RETURN p.code, inDeg ORDER BY inDeg DESC;

5. Graph Analytics and Intelligence Functions

Extended analytical applications leverage Neo4j's Graph Data Science library:

• Shortest Path: For minimal-chain analysis between any two courses.

  MATCH path = shortestPath((c1:Course {code:'CSE100'})-[:HAS_PREREQUISITE*]-(c2:Course {code:'CSE350'})) RETURN path;

• Betweenness Centrality: To locate critical courses in the global prerequisite structure:

$$C_B(v) = \sum_{s \neq v \neq t} \frac{\sigma_{st}(v)}{\sigma_{st}}$$

CALL gds.betweenness.stream('curriculumGraph') YIELD nodeId, score RETURN gds.util.asNode(nodeId).code AS course, score ORDER BY score DESC LIMIT 10;

• Community Detection: To surface natural curriculum clusters for modularization or re-sequencing (e.g., via Louvain clustering).

  CALL gds.louvain.stream('curriculumGraph') YIELD nodeId, communityId RETURN gds.util.asNode(nodeId).title AS course, communityId;

These analytics underpin use cases such as identifying choke points, streamlining prerequisite structures, and revealing misalignments in course groupings.

6. User Interface and Operational Use Cases

Via the Neo4j Browser or web front-ends, academic staff can:

• Visualize prerequisite trees for any course.
• Query dependency chains between arbitrary pairs (supporting what-if analyses).
• Identify gateway courses (courses with no prerequisites).
• Visually inspect course communities to identify topical gaps or redundancies.

Such affordances give planners tools to overhaul, balance, and document program structures systematically.

7. Lessons Learned, Limitations, and Prospects

Key findings and forward-looking directions include:

• Limitations: The demonstration is restricted to prerequisite relations within a 31-course CSE data set. Only structured syllabus fields are considered.
• Error Correction: Human-in-the-loop review for name typos/missing prerequisites is necessary, with possible automation through improved normalization or data validation.
• Extensions: Next steps include incorporating transcript data for personalized pathways, assigning weights to edges (difficulty, credit hours) for advanced path-finding, and integrating NLP over course descriptions to extract more granular content/topic/learning objective links.
• Adaptive Recommendation: Potential exists for probabilistic readiness scoring (e.g., if a student has completed courses $A$ and $B$, quantify preparedness for $C$).

By synthesizing tabular course data, deterministic entity linking, a Neu4j-backed graph schema, and standard network analytics, this Curriculum-Intelligence use case demonstrates the practical transformation of otherwise unwieldy university curricula into operational tools for planning, visualization, and programmatic inquiry (Yu et al., 2020).