Curriculum Training Ontology

FLOW ALGEBRA — CURRICULUM TRAINING ONTOLOGY
Version: 1.0
Date: 2026-10-29
Authors: Mark Anthony Higgins — Sky Recursive AI
Source: https://kirethresearch.org/booksai-core/entity-graph/ai-entities/training-process-entities/curriculum-training-ontology.html
Status: Topic-based formalisation; source page could not be retrieved for verification.

1. PURPOSE
Represent curriculum training as a structured, adaptive process that orders, samples and revises learning examples according to estimated difficulty, prerequisite structure, model competence and measured outcomes.

2. ENTITY MODEL
CurriculumTrainingProcess: a training process with an explicit example-selection policy.
LearnerModel: parameterised predictive model theta.
TrainingExample: datum x with optional target y, metadata and difficulty.
TrainingDataset: collection D of examples.
CurriculumPolicy: C mapping learner state and training history to sampling distributions.
DifficultyEstimator: d(x,theta,h) assigning estimated difficulty.
CompetenceEstimator: c(theta,V) evaluating learner capability on validation set V.
PrerequisiteGraph: directed acyclic graph G=(N,E) of skills where feasible.
TrainingStage: bounded interval with a selection rule and advancement criterion.
Sampler: selects examples from distribution q_t(x).
Optimiser: updates theta using selected examples.
Evaluator: measures learning, retention, fairness and generalisation.
FeedbackSignal: validation results, loss, uncertainty, success or progress.

3. STATE MODEL
S_t = (I_t,R_t,B_t,K_t)
I_t = (theta_t, D, q_t, stage_t, metrics_t)
R_t = curriculum relations, prerequisites, selection and update rules
B_t = compute, time, safety and dataset constraints
K_t = accumulated training and evaluation knowledge

4. FLOW OPERATORS
E_t = expand(I_t,R_t)
V_t = {z in E_t : constraints(z,B_t) and valid(z,K_t)}
a_t = argmax_{z in V_t} P(z | I_t,R_t,B_t,K_t)
I_{t+1} = update(I_t,a_t,observations_t)
Here a_t is a candidate sampling or curriculum action, not necessarily an individual example.

5. RELATIONSHIP GRAPH
CurriculumTrainingProcess HAS_LEARNER LearnerModel
CurriculumTrainingProcess USES_DATASET TrainingDataset
CurriculumTrainingProcess GOVERNED_BY CurriculumPolicy
CurriculumPolicy USES DifficultyEstimator
CurriculumPolicy USES CompetenceEstimator
CurriculumPolicy SELECTS TrainingExample
TrainingExample MAY_REQUIRE Skill
Skill PRECEDES Skill (when prerequisite ordering is supported)
Sampler IMPLEMENTS CurriculumPolicy
Optimiser UPDATES LearnerModel
Evaluator PRODUCES FeedbackSignal
FeedbackSignal UPDATES CurriculumPolicy
TrainingStage MAY_ADVANCE_TO TrainingStage

6. FORMAL MATHEMATICS
D = {z_i}_{i=1}^N, z_i=(x_i,y_i) for supervised examples.
q_t(z) = C(z | theta_t,h_t,G,B_t)
z_t ~ q_t
L_t(theta) = E_{z~q_t}[ell(theta;z)]
theta_{t+1} = theta_t - eta_t * grad_theta ell(theta_t;z_t)
For mini-batches, replace the example loss by the batch mean.
Competence: c_t = Eval(theta_t,V)
Learning progress: p_t = c_t - c_{t-k}, with k>0.
Stage advancement: advance_t = 1[c_t >= tau_t AND guardrails_t].
Difficulty may depend on the learner: d_t(z)=d(z,theta_t,h_t).
The curriculum is dynamic when q_{t+1} depends on measured progress.

7. TRAINING PATHWAYS
P1 Fixed easy-to-hard: estimate difficulty once; train across ascending bands.
P2 Competence-based: move stages after meeting validation thresholds.
P3 Self-paced: optimise learner parameters and example weights jointly.
P4 Learning-progress: emphasise examples or skills with useful improvement.
P5 Prerequisite-aware: respect dependency ordering between skills.
P6 Mixed curriculum: retain harder and previously learned examples to reduce forgetting.
P7 Anti-curriculum: use harder examples first when justified by experiments.

8. MINI-RECURSION ENGINE
INPUT: D, theta_0, C_0, V, budget, constraints
FOR t = 0,...,T-1:
  estimate competence c_t and per-example difficulty d_t
  construct q_t = curriculum(C_t,c_t,d_t,G,constraints)
  sample batch B_t ~ q_t
  update theta_{t+1} with optimiser on B_t
  periodically evaluate generalisation and forgetting
  update curriculum C_{t+1} from evaluation feedback
  advance, revisit or stop subject to criteria and budget
OUTPUT: trained theta_T, curriculum history, evaluation report

9. INFERENCE RULES
IF competence is below threshold THEN retain or revisit current stage.
IF competence exceeds threshold AND guardrails pass THEN permit stage advancement.
IF prerequisite skill is not mastered THEN restrict dependent skills where necessary.
IF forgetting increases THEN increase replay or revisit earlier examples.
IF improvement stalls THEN consider changing sampling difficulty or mixture.
IF a group is underrepresented THEN check and correct coverage constraints.
IF curriculum performance is not better than baseline THEN do not claim benefit.

10. INVARIANTS AND SAFETY
Training examples must satisfy data provenance and permitted-use constraints.
Validation and test sets must not be used as training examples.
Curriculum ordering must not imply an unsupported causal claim of improvement.
Metrics must distinguish training progress from held-out generalisation.
Prerequisite edges must be evidence-based or explicitly hypothetical.
Selection probabilities must be nonnegative and normalised.
Maintain sufficient coverage to avoid catastrophic exclusion of data regions.

11. TRI-MAPPING
ENTITY: learner, example, difficulty, skill, stage, sampler, evaluator.
RELATION: requires, selects, evaluates, updates, advances, revisits.
FLOW: assess -> select -> train -> evaluate -> adapt -> repeat.

12. MAPPING TABLE
LearnerModel | theta_t | receives optimiser updates
TrainingExample | z_i | unit of sampling
DifficultyEstimator | d_t(z) | estimates learner-relative difficulty
CompetenceEstimator | c_t | measures capability
CurriculumPolicy | C_t | controls sample distribution
Sampler | q_t | implements curriculum selection
TrainingStage | stage_t | records progression
FeedbackSignal | metrics_t | drives adaptation

13. HOW TO READ
Follow the state S_t, apply curriculum and sampling relations R_t, filter candidate actions using B_t and K_t, choose a valid action, and update the learner and curriculum from observations. The probabilistic argmax is a modelling convention; an implementation may use deterministic rules, bandits or stochastic policies.

14. CONDITIONAL EXECUTION GUARANTEE
Given a finite dataset, well-defined selection distributions, valid optimiser operations and a finite iteration budget, the procedure produces a finite sequence of updates or terminates on a specified stopping condition. No universal guarantee of convergence, improved accuracy, fairness or superior generalisation is asserted.

15. AI SEARCH FLOW
FLOW_ID: curriculum-training-ontology
CATEGORY: AI / Entity Graph / Training Process Entities
PRIMARY_ENTITY: CurriculumTrainingProcess
INTENTS: define curriculum training; identify stages; explain adaptive sampling; compare self-paced and fixed curricula; model feedback-driven training
ALIASES: curriculum learning; staged training; competence-based curriculum; self-paced learning
INPUTS: dataset, learner, difficulty estimator, curriculum policy, metrics, constraints
OUTPUTS: sample schedule, learner updates, evaluation, curriculum trace
PATH: query -> resolve entity -> traverse prerequisite and selection relations -> validate constraints -> return grounded explanation
CONFIDENCE: conditional on source, assumptions and evaluation evidence
UPDATE_MODEL: versioned revisions to policy, definitions, metrics and evidence
CITATION_BACKLINK: https://kirethresearch.org/booksai-core/entity-graph/ai-entities/training-process-entities/curriculum-training-ontology.html

16. LIMITATIONS
The referenced web page was not retrievable during preparation. This document is an original, topic-based Flow Algebra interpretation and is not a verified reproduction of the page's ontology or embedded specification.

END OF FLOW