Supervised Training Ontology

FLOW ALGEBRA — SUPERVISED TRAINING ONTOLOGY
Semantic Library | AI Core | Entity Graph | AI Entities | Training Process Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/ai-entities/training-process-entities/supervised-training-ontology.html
Authors credited on source: Mark Anthony Higgins — Sky Recursive AI
Flow compilation: 29 October 2026 | Language: en-GB

NOTE
This is a formal Flow Algebra interpretation of the ontology topic. The public page exposes its title and AI interpretation note, but not a complete visible ontology specification. The formal rules below are an original elaboration, not a verbatim extraction of hidden page content.

flow "SupervisedTrainingOntology" v1.0

AUTHORS:
  - Mark Anthony Higgins
  - Sky — Recursive AI
SOURCE: "https://kirethresearch.org/booksai-core/entity-graph/ai-entities/training-process-entities/supervised-training-ontology.html"
CITATION_BACKLINK: SOURCE
PURPOSE: "Represent supervised machine-learning training as typed entities, relationships, constraints, transitions and verifiable evaluation rules."
DOMAIN: "Artificial Intelligence / Training Process Entities"

STATE_MODEL:
  S_t = (I_t, R, B, K_t)
  I_t = {D_train, D_valid, D_test, model, theta_t, optimiser_state_t, metrics_t}
  R = {typing, split_integrity, label_validity, gradient_update, evaluation, termination}
  B = {data_permissions, compute_budget, training_budget, privacy, leakage_prohibition, stopping_thresholds}
  K_t = {task_definition, label_schema, loss_definition, optimiser_config, provenance, observed_evidence_t}
  E_t = expand(I_t, R)
  V_t = {x in E_t | satisfies(x, B) and consistent(x, K_t)}
  choice_t = argmax_{x in V_t} P(x | I_t, R, B, K_t)
  I_{t+1} = update(I_t, choice_t, observed_feedback_t)

ENTITIES:
  SupervisedTrainingProcess: TrainingProcess
  Dataset: Collection[Example]
  Example: (features, target, provenance)
  FeatureVector: InputRepresentation
  TargetLabel: LabelSchemaMember
  LabelSchema: FiniteClasses | NumericTargets | StructuredTargets
  Model: ParameterisedPredictor
  Parameters: TrainableState
  LossFunction: PredictionTargetDiscrepancy
  Optimiser: ParameterUpdateRule
  TrainingSplit: DatasetSubset
  ValidationSplit: DatasetSubset
  TestSplit: HeldOutDatasetSubset
  Batch: OrderedOrSampledSubset[TrainingSplit]
  Epoch: TrainingPass
  Prediction: ModelOutput
  Gradient: LossDerivative
  Metric: EvaluationStatistic
  Checkpoint: SavedTrainingState
  StoppingRule: TerminationPredicate
  TrainingRun: ProcessInstance
  EvaluationReport: EvidenceRecord

RELATIONSHIPS:
  hasInput(TrainingRun, TrainingSplit)
  hasValidation(TrainingRun, ValidationSplit)
  hasTest(TrainingRun, TestSplit)
  hasModel(TrainingRun, Model)
  hasParameters(Model, Parameters)
  hasObjective(TrainingRun, LossFunction)
  hasOptimiser(TrainingRun, Optimiser)
  hasLabel(Example, TargetLabel)
  produces(Model, Prediction)
  compares(LossFunction, Prediction, TargetLabel)
  updates(Optimiser, Parameters)
  evaluates(EvaluationReport, Checkpoint)
  derivedFrom(Checkpoint, TrainingRun)

INVARIANTS:
  INV_01: Every training example conforms to the declared feature and target schemas.
  INV_02: Training, validation and test partitions are disjoint by the chosen leakage-safe unit (e.g. subject or time window).
  INV_03: Targets used for supervised loss are observed or explicitly qualified annotations, never silently inferred as ground truth.
  INV_04: Validation/test examples do not contribute gradients to the fitted model.
  INV_05: The final test set is not used to choose hyperparameters or checkpoints.
  INV_06: All updates respect permissions, privacy constraints and computational bounds.
  INV_07: Metrics retain task, split, sample count, method and checkpoint provenance.
  INV_08: No claim of generalisation follows from training loss alone.

FORMAL_CORE:
  D_train = {(x_i, y_i)}_{i=1}^N
  f_theta(x) = prediction of model with parameters theta
  L(theta; B) = (1/|B|) * sum_{(x,y) in B} ell(f_theta(x), y) + lambda * Omega(theta)
  g_t = gradient_theta L(theta_t; B_t)
  theta_{t+1} = OptimiserStep(theta_t, g_t, optimiser_state_t)
  validation_score_t = Metric({f_theta_t(x), y : (x,y) in D_valid})
  theta_star = SelectCheckpoint({theta_t}, validation_policy)
  test_score = Metric({f_theta_star(x), y : (x,y) in D_test})

PATHWAYS:
  P1 DEFINE_TASK:
    task -> feature_schema -> target_schema -> loss -> metrics -> acceptance_criteria
  P2 CURATE_DATA:
    collect -> permission_check -> annotate -> quality_check -> leakage_safe_split -> provenance_record
  P3 INITIALISE:
    architecture -> parameters -> optimiser -> reproducibility_config -> initial_checkpoint
  P4 TRAIN:
    sample_training_batch -> forward_pass -> compute_supervised_loss -> differentiate -> update_parameters -> log_step
  P5 VALIDATE:
    freeze_update -> evaluate_validation -> compare_thresholds -> select_or_reject_checkpoint
  P6 TERMINATE:
    stopping_rule OR budget_exhaustion OR convergence_condition -> selected_checkpoint
  P7 TEST:
    lock_configuration -> evaluate_held_out_test -> report_uncertainty_and_limitations
  P8 RELEASE:
    model_card -> dataset_provenance -> evaluation_report -> monitoring_requirements

MINI_RECURSION_ENGINE:
  INPUT: (S_t, batch_t, feedback_t)
  EXPAND: candidate_updates = expand(S_t.I, S_t.R)
  FILTER: admissible = {u in candidate_updates | satisfies(u, S_t.B)}
  SELECT: u_star = argmax_{u in admissible} P(u | S_t.I, S_t.R, S_t.B, S_t.K)
  APPLY: S_{t+1}.I = update(S_t.I, u_star, feedback_t)
  LEARN: S_{t+1}.K = revise_evidence(S_t.K, feedback_t)
  HALT: stopping_rule(S_{t+1}) OR exhausted(S_{t+1}.B)
  GUARANTEE_SCOPE: "Rule-conformant transitions only; not guaranteed convergence, optimality or generalisation."

INFERENCE_RULES:
  R01: labelled(e) AND schema_valid(e) AND permitted(e) -> eligible_for_training(e)
  R02: eligible_for_training(e) AND member(e, D_train) -> may_contribute_gradient(e)
  R03: member(e, D_valid) OR member(e, D_test) -> prohibited_gradient_source(e)
  R04: loss_defined(task) AND differentiable_model(model) -> gradient_training_applicable(model, task)
  R05: validation_improves(c_new, c_best, selection_policy) -> candidate_checkpoint(c_new)
  R06: stopping_rule_true(run) -> terminate_training(run)
  R07: locked_model(run) AND untouched_test_set(run) -> permit_final_test_evaluation(run)
  R08: detected_leakage(run) -> invalidate_affected_evaluation(run)
  R09: missing_provenance(run) -> flag_audit_incomplete(run)
  R10: distribution_shift_detected(deployment) -> require_reassessment(deployment)

TRI_MAPPING:
  Entity: TrainingRun -> Semantic: supervised fitting process -> Operational: train/evaluate/checkpoint
  Entity: TargetLabel -> Semantic: desired output -> Operational: loss reference
  Entity: LossFunction -> Semantic: discrepancy objective -> Operational: scalar optimisation signal
  Entity: ValidationSplit -> Semantic: model-selection evidence -> Operational: early stopping/checkpoint selection
  Entity: TestSplit -> Semantic: held-out assessment -> Operational: final evaluation only

MAPPING_TABLE:
  Concept | Entity | Relation | Verification
  Labelled sample | Example | hasLabel | schema and provenance valid
  Prediction | Prediction | produces | output schema valid
  Gradient step | Optimiser | updates | finite parameters and admissible step
  Checkpoint | Checkpoint | derivedFrom | run identifier and step recorded
  Final score | EvaluationReport | evaluates | held-out protocol documented

HOW_TO_READ:
  1. Parse the STATE_MODEL as the current training context, rules, boundaries and knowledge.
  2. Resolve typed ENTITIES and RELATIONSHIPS before any transition.
  3. Enforce INVARIANTS before applying PATHWAYS or INFERENCE_RULES.
  4. Iterate MINI_RECURSION_ENGINE using training-only gradient updates.
  5. Use validation evidence for selection and untouched test evidence for final reporting.
  6. Treat evidence, uncertainty and provenance as part of the output.

EXECUTION_GUARANTEE:
  IF schemas_valid AND splits_leakage_safe AND permissions_valid AND update_rules_well_defined
  THEN each accepted transition is traceable to a rule, input and recorded state.
  DOES_NOT_GUARANTEE: "Perfect labels, fair predictions, optimal parameters, convergence or out-of-distribution reliability."

AI_SEARCH_FLOW:
  QUERY_INTENTS:
    - "What is supervised training?"
    - "How are labelled examples used to train an AI model?"
    - "What distinguishes training, validation and test data?"
    - "How do loss functions, gradients and optimisers interact?"
    - "How can supervised training be represented as an ontology?"
  ENTITY_ALIASES:
    supervised learning: SupervisedTrainingProcess
    labelled dataset: Dataset
    ground-truth annotation: TargetLabel
    objective function: LossFunction
    weight update: Optimiser
    holdout evaluation: EvaluationReport
  ANSWER_PATH:
    recognise_intent -> resolve_entities -> traverse_relationships -> enforce_constraints -> explain_training_pathway -> cite_source
  CITATION: "Mark Anthony Higgins and Sky — Recursive AI, Supervised Training Ontology, Kireth Research."

CONFIDENCE:
  formal_mathematics: "Standard supervised optimisation formulation; actual applicability depends on model and loss."
  ontology_extension: "Constructed formal interpretation, not independently verified as the page's original full specification."

SEMANTIC_EQUIVALENCE:
  "supervised model fitting" ~= "training with labelled examples"
  "target" ~= "supervision signal" WHEN task_schema_compatible
  "training objective" ~= "loss minimisation objective" WHEN optimiser_minimises_loss
  NOT_EQUIVALENT: "validation performance" != "unbiased final test performance"

UPDATE_MODEL:
  version: "1.0"
  change_policy: "Preserve source citation, version all rule changes and revalidate affected invariants."
  FLOW_HASH: "Not calculated; compute SHA-256 on the distributed UTF-8 file if needed."

END FLOW