docs/algorithms.md

Core Algorithms

1. Learner Profile Vector

FUNCTION build_learner_profile_vector(registration, diagnostic, history):
  prior_learning_embedding = embed(registration.prior_learning)
  goal_embedding = embed(registration.goals)
  education_features = encode_categorical(registration.educational_level)
  readiness_features = normalize(diagnostic.scores)
  preference_features = encode_optional(registration.preferences)
  behavior_features = aggregate(history)

  profile_vector = concatenate(
    prior_learning_embedding,
    goal_embedding,
    education_features,
    readiness_features,
    preference_features,
    behavior_features
  )

  mastery_map = initialize_mastery(diagnostic)
  RETURN { profile_vector, mastery_map }

2. Module Vectorization

FUNCTION build_module_vector(module):
  objective_embedding = embed(module.objectives)
  topic_embedding = embed(module.topics)
  bloom_features = encode_bloom_levels(module.objectives)
  workload_features = normalize(module.estimated_minutes, module.ects)
  activity_features = encode_multilabel(module.activity_types)
  prerequisite_features = encode_graph_position(module.prerequisites)

  RETURN concatenate(
    objective_embedding,
    topic_embedding,
    bloom_features,
    workload_features,
    activity_features,
    prerequisite_features
  )

3. Hybrid Recommendation

FUNCTION recommend_modules(learner, candidates):
  FOR module IN candidates:
    content_score = cosine_similarity(learner.profile_vector, module.vector)
    collaborative_score = collaborative_model.predict(learner.id, module.id)
    readiness_score = readiness_alignment(learner.mastery_map, module.required_competencies)
    pacing_score = pace_alignment(learner, module)
    diversity_penalty = novelty_penalty(learner.recent_topics, module.topic_cluster)

    final_score =
      0.35 * content_score +
      0.30 * collaborative_score +
      0.20 * readiness_score +
      0.15 * pacing_score -
      diversity_penalty

    IF not prerequisites_satisfied(learner, module):
      final_score = -INF

  RETURN top_k_by_score(candidates)

4. Dynamic Assessment Generation

FUNCTION generate_unique_assessment(blueprint, learner):
  selected_items = []

  FOR objective IN blueprint.objectives:
    pool = filter_question_pool(
      objective=objective,
      difficulty=target_difficulty(learner, objective)
    )

    item = choose_unique_variant(pool, learner.previous_items)

    IF item.parameterized:
      item = inject_unique_parameters(item, learner.id, now())

    IF item.ai_generatable:
      item = ai_generate_variant(item.template, blueprint.rubric)

    selected_items.append(item)

  RETURN shuffle(selected_items)

5. Open-Ended AI Evaluation

FUNCTION evaluate_open_response(response, rubric):
  deterministic_checks = run_basic_checks(response, rubric)
  ai_result = ai_score_with_rubric(response.text, rubric)
  final_score = weighted_merge(deterministic_checks, ai_result.score)

  save_audit_trace(response.id, rubric, ai_result.rationale, ai_result.confidence)

  IF ai_result.confidence < 0.60:
    queue_human_review(response.id)

  RETURN final_score

6. Integrity Detection

FUNCTION integrity_check(attempt):
  plagiarism = compare_to_corpus(attempt.responses)
  peer_similarity = compare_to_peer_attempts(attempt)
  timing_anomaly = detect_impossible_timing(attempt.event_stream)
  session_anomaly = detect_session_irregularity(attempt.session_metadata)

  risk = weighted_sum(plagiarism, peer_similarity, timing_anomaly, session_anomaly)

  IF risk >= 0.85:
    RETURN "block"
  IF risk >= 0.60:
    RETURN "review"
  RETURN "pass"

7. Dropout Risk Prediction

FUNCTION predict_dropout_risk(learner_features):
  risk_probability = dropout_model.predict([
    learner_features.time_on_task_7d,
    learner_features.inactivity_days,
    learner_features.quiz_failure_rate,
    learner_features.pace_slippage,
    learner_features.unfinished_activity_ratio
  ])

  IF risk_probability > 0.75:
    trigger_high_priority_intervention()
  ELSE IF risk_probability > 0.45:
    trigger_nudge()

  RETURN risk_probability