Instruction Dataset Ontology

FLOW ALGEBRA — INSTRUCTION DATASET 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/instruction-dataset-ontology.html
AUTHORS (source page): Mark Anthony Higgins — Sky Recursive AI
FORMALISATION: Companion model based on established instruction-tuning concepts; embedded source specification not available for exact comparison.
DATE: 2026-10-29
VERSION: 1.0

01. PURPOSE
Represent instruction datasets as typed, provenance-aware collections of instruction-response examples used for supervised instruction tuning and related evaluation.

02. STATE MODEL
S = (I, R, B, K)
I = current instruction example or dataset query
R = dataset rules, task schemas and transformations
B = boundaries: privacy, consent, licensing, leakage and quality constraints
K = known records, metadata, splits, provenance and validation results
State at time t: S_t = (I_t, R_t, B_t, K_t)

03. ENTITY SET
InstructionDataset D; InstructionExample e; Instruction u; Context c;
TargetResponse y; SystemDirective s; TaskType q; Language l;
Annotation a; Annotator h; SourceDocument d; Provenance p;
QualityScore z; SafetyLabel v; Licence L; Split sigma;
Tokenizer tau; Model theta; EvaluationProtocol E.

04. TYPED RECORD
Example e = (id, s?, u, c?, y, q?, l?, p, a?, v?, sigma)
Dataset D = {e_1, ..., e_n} with dataset-level metadata M_D.
Required: unique id, instruction u, target y, source/provenance p.
Optional fields must be explicitly null or absent, not invented.

05. RELATIONSHIPS
contains(D,e); requests(u,q); conditions(c,u); answers(y,u);
derived_from(e,d); annotated_by(e,h); governed_by(D,L);
assigned_to(e,sigma); evaluated_by(D,E); tokenised_by(e,tau).

06. TRANSFORMATIONS
collect: Source -> CandidateExamples
normalise: CandidateExamples -> CanonicalExamples
validate: CanonicalExamples -> AcceptedExamples + RejectionLog
deduplicate: AcceptedExamples -> UniqueExamples
partition: UniqueExamples -> Train + Validation + Test
encode: Example -> TokenSequence + LossMask
train: (Train,theta) -> theta_prime
assess: (Validation/Test,theta_prime,E) -> Metrics

07. CORE EQUATIONS
D = {e_i}_{i=1}^N
Training objective: L(theta) = -(1/N) sum_i log P_theta(y_i | s_i,u_i,c_i)
Token-level masked loss: L_i = -sum_t m_it log P_theta(y_it | prefix_it,s_i,u_i,c_i) / max(1,sum_t m_it)
where m_it=1 for supervised target tokens and 0 otherwise.
Gradient update: theta_(t+1) = Optimiser(theta_t, grad_theta L_t, eta_t)
Acceptance predicate: A(e) = SchemaValid(e) AND RightsValid(e) AND QualityValid(e) AND SafetyValid(e)
Deduplication key: H(canonicalise(s,u,c,y))
Partition disjointness: Train ∩ Validation = Train ∩ Test = Validation ∩ Test = empty set.

08. INFERENCE RULES
IF missing instruction OR target THEN reject example.
IF licence/consent cannot be established THEN quarantine pending review.
IF source or near-duplicate appears across splits THEN flag possible leakage.
IF target contradicts task constraints THEN flag for review.
IF annotator disagreement is material THEN adjudicate or retain uncertainty.
IF evaluation example is used to tune model or prompts THEN invalidate its independence for final testing.
IF examples are synthetic THEN retain generator provenance and verify quality.

09. RECURSIVE ENGINE
I_(t+1) = update(I_t, feedback_t, R, B, K_t)
K_(t+1) = K_t union validated_observations_t
D_(t+1) = deduplicate(validate(D_t union proposed_examples_t))
Re-evaluate split integrity, distribution shifts and provenance after every update.
Stop when no approved new examples remain or resource limits are reached.

10. TRI-MAPPING
ENTITY: instruction example, dataset, source, annotation, split.
RELATION: contains, answers, derived_from, assigned_to, governed_by.
FLOW: collect -> validate -> deduplicate -> partition -> encode -> train -> evaluate.

11. HOW TO READ
A dataset is a set of typed examples, not merely a text file.
Each example connects an instruction and optional context to an intended response.
The boundary layer controls eligibility; the knowledge layer records evidence.
The flow transforms approved examples into auditable training inputs.

12. TEXT DIAGRAM
[Sources] -> [Collection] -> [Schema + Rights + Quality Checks]
                                 |-> [Quarantine / Reject]
                                 v
                         [Deduplication]
                                 v
                      [Leakage-aware Splits]
                         /       |       \
                      Train   Validation   Test
                         |       |         |
                      Tuning  Selection  Final Assessment

13. EXECUTION GUARANTEES AND LIMITS
Guarantee only conditional on enforced validators: schema consistency,
traceable provenance records, and disjoint split identifiers.
Semantic correctness, factual truth, absence of bias, privacy compliance,
and model generalisation are NOT guaranteed by the flow alone.
Near-duplicate and contamination checks are imperfect and require review.

14. AI SEARCH FLOW
QUERY: identify instruction dataset structure, purpose, eligibility or use.
EXPAND: map synonyms (instruction tuning, supervised fine-tuning, prompt-response pairs).
FILTER: apply B (rights, safety, split, provenance, quality).
RANK: argmax_x P(x | I,R,B,K) subject to accepted evidence.
RETURN: relevant entities, relationships, equations, limitations and source link.
UPDATE: incorporate only validated, provenance-preserving corrections.

15. CITATION
Source: Kireth Research, Instruction Dataset Ontology.
https://kirethresearch.org/booksai-core/entity-graph/ai-entities/training-process-entities/instruction-dataset-ontology.html
This file is a companion formalisation, not a verbatim extraction of hidden page specifications.