AI Metadata Ontology

FLOW ALGEBRA

Ontology: AI Metadata Ontology
Domain: Metadata Ontologies > AI Metadata
Canonical URL: https://kirethresearch.org/booksai-core/ontologies/metadata-ontologies/ai-metadata/ai-metadata-ontology.html

Authors: Mark Anthony Higgins — Sky (Recursive AI)

flow "AIMetadataOntology" v1.0

# ---------- DOMAIN ----------
domain:
  class: MetadataOntology
  category: AIMetadata
  subject: AIMetadata
  purpose:
    - represent metadata describing artificial intelligence resources
    - preserve model, dataset, training, inference, evaluation, deployment, and provenance context
    - support AI discovery, validation, comparison, governance, reproducibility, and reasoning
    - distinguish model-generated, source-derived, inferred, and human-reviewed information
    - enable machine-readable interpretation of AI lifecycle states

# ---------- CORE ENTITY ----------
entity AIMetadata:
  type: MetadataEntity
  describes: AIResource
  may_include:
    - ai_resource_identifier
    - ai_resource_type
    - model_identifier
    - model_family
    - architecture
    - model_version
    - training_metadata
    - dataset_metadata
    - inference_metadata
    - prompt_metadata
    - output_metadata
    - evaluation_metadata
    - performance_metadata
    - deployment_metadata
    - confidence
    - uncertainty
    - provenance
    - governance_metadata
    - update_metadata

entity AIResource:
  type: ComputationalResource
  may_be:
    - AIModel
    - MachineLearningModel
    - NeuralNetwork
    - LanguageModel
    - VisionModel
    - MultimodalModel
    - Agent
    - AIService
    - AIOutput
    - TrainingDataset
    - EvaluationDataset

entity AIResourceIdentifier:
  type: Identifier
  identifies: AIResource

# ---------- RELATIONSHIPS ----------
relationships:
  AIMetadata -> DESCRIBES -> AIResource
  AIResource -> IDENTIFIED_BY -> AIResourceIdentifier
  AIModel -> HAS_ARCHITECTURE -> ModelArchitecture
  AIModel -> HAS_VERSION -> ModelVersion
  AIModel -> TRAINED_ON -> TrainingDataset
  AIModel -> MAY_BE_FINE_TUNED_ON -> Dataset
  AIModel -> EVALUATED_ON -> EvaluationDataset
  AIModel -> PRODUCES -> AIOutput
  AIOutput -> GENERATED_BY -> AIModel
  AIOutput -> MAY_BE_GENERATED_FROM -> Prompt
  AIModel -> MAY_BE_DEPLOYED_AS -> AIService
  AIModel -> MAY_HAVE -> EvaluationResult
  AIMetadata -> MAY_REFERENCE -> AIProvenance

# ---------- RESOURCE IDENTITY ----------
rule resource_identity:
  AIResource SHOULD have stable identifier
  where persistent reference or auditability is required

rule model_name:
  model name MUST NOT be assumed globally unique

rule provider_namespace:
  model identity SHOULD preserve provider or namespace
  where naming collisions are possible

# ---------- MODEL ----------
entity AIModel:
  type: ComputationalModel
  may_include:
    - model_identifier
    - model_name
    - model_family
    - architecture
    - parameter_metadata
    - capabilities
    - limitations
    - training_method
    - model_version
    - provenance

entity ModelArchitecture:
  type: AIModelStructure
  examples:
    - transformer
    - convolutional_network
    - recurrent_network
    - graph_neural_network
    - diffusion_model
    - ensemble_model
    - hybrid_model

rule architecture:
  ModelArchitecture SHOULD describe model structure
  at level required for intended metadata use

# ---------- VERSION ----------
entity ModelVersion:
  type: VersionMetadata
  may_include:
    - version_identifier
    - release_date
    - predecessor
    - successor
    - change_description
    - status

rule model_version:
  material model change SHOULD create distinguishable ModelVersion

rule family_version_distinction:
  ModelFamily != ModelVersion

rule historical_version:
  superseded model versions SHOULD remain traceable
  where historical outputs depend on them

# ---------- TRAINING ----------
entity TrainingMetadata:
  type: AIMetadata
  may_include:
    - training_method
    - training_dataset
    - objective
    - optimiser
    - hyperparameters
    - training_steps
    - compute_environment
    - training_time
    - checkpoint
    - random_seed
    - provenance

rule training_trace:
  TrainingMetadata SHOULD preserve sufficient information
  for reproducibility where system design and disclosure permit

rule training_dataset:
  TrainingDataset SHOULD be referenced by stable identifier
  where available

rule training_inference_distinction:
  TrainingProcess != InferenceProcess

# ---------- DATASET ROLES ----------
dataset_roles:
  - training
  - validation
  - evaluation
  - fine_tuning
  - retrieval
  - calibration

rule dataset_role:
  Dataset role MUST be interpreted relative_to AI lifecycle activity

rule role_distinction:
  training_dataset != evaluation_dataset
  unless same physical dataset is explicitly assigned multiple roles

# ---------- INFERENCE ----------
entity InferenceMetadata:
  type: AIMetadata
  may_include:
    - model_version
    - input
    - prompt
    - inference_parameters
    - context
    - retrieval_context
    - tool_context
    - timestamp
    - output
    - confidence
    - latency
    - provenance

rule inference_trace:
  AIOutput SHOULD preserve model and inference context
  where auditing or reproducibility requires

rule model_output_link:
  AIOutput SHOULD reference generating ModelVersion
  where attribution matters

# ---------- PROMPT ----------
entity PromptMetadata:
  type: AIMetadata
  may_include:
    - prompt_identifier
    - prompt_text_or_reference
    - system_instruction
    - user_instruction
    - context
    - template
    - prompt_version
    - provenance

rule prompt_context:
  prompt and context MAY materially affect AIOutput

rule prompt_version:
  material prompt-template change SHOULD create distinguishable version

# ---------- AI OUTPUT ----------
entity AIOutput:
  type: GeneratedResource
  may_be:
    - text
    - image
    - audio
    - video
    - prediction
    - classification
    - embedding
    - recommendation
    - action
    - structured_data

output_status:
  - raw
  - validated
  - reviewed
  - corrected
  - rejected
  - superseded

rule generated_content:
  AI-generated content SHOULD remain distinguishable
  from source content and human-authored content
  where provenance matters

rule output_not_truth:
  AIOutput != VerifiedFact

rule reviewed_output:
  reviewed AIOutput MUST remain traceable to raw AIOutput

# ---------- CONFIDENCE ----------
entity AIConfidence:
  type: EpistemicMetadata
  range: [0.0, 1.0]

rule confidence_bounds:
  REQUIRE 0.0 <= confidence <= 1.0

rule confidence_semantics:
  confidence MUST identify represented quantity
  and MUST NOT automatically be interpreted as calibrated probability

# ---------- UNCERTAINTY ----------
entity AIUncertainty:
  type: EpistemicMetadata
  may_apply_to:
    - prediction
    - classification
    - generation
    - retrieval
    - entity_resolution
    - reasoning

rule uncertainty_scope:
  uncertainty SHOULD identify the output component or inference it qualifies

# ---------- EVALUATION ----------
entity EvaluationMetadata:
  type: AIMetadata
  may_include:
    - evaluation_dataset
    - benchmark
    - metric
    - score
    - evaluation_method
    - evaluator
    - timestamp
    - model_version
    - provenance

entity EvaluationMetric:
  type: MeasurementDefinition
  examples:
    - accuracy
    - precision
    - recall
    - F1
    - AUROC
    - perplexity
    - exact_match
    - latency
    - human_rating

rule evaluation_context:
  EvaluationScore SHOULD preserve:
    - metric
    - dataset
    - ModelVersion
    - evaluation_method

rule evaluation_comparison:
  scores SHOULD be compared only under compatible evaluation conditions

# ---------- PERFORMANCE ----------
entity PerformanceMetadata:
  type: AIMetadata
  may_include:
    - latency
    - throughput
    - memory_usage
    - compute_usage
    - energy_usage
    - cost
    - reliability

rule performance_context:
  performance comparison SHOULD preserve:
    - hardware
    - software
    - workload
    - configuration
    - measurement_method

# ---------- DEPLOYMENT ----------
entity DeploymentMetadata:
  type: AIMetadata
  may_include:
    - deployment_identifier
    - model_version
    - environment
    - endpoint
    - deployment_time
    - configuration
    - hardware
    - software
    - region
    - status

deployment_status:
  - development
  - testing
  - staging
  - production
  - deprecated
  - retired

rule deployment:
  deployed ModelVersion SHOULD be explicit

# ---------- RETRIEVAL / TOOLS ----------
entity RetrievalMetadata:
  type: AIMetadata
  may_include:
    - retrieval_system
    - query
    - source_documents
    - ranking
    - retrieval_time
    - provenance

entity ToolMetadata:
  type: AIMetadata
  may_include:
    - tool_identifier
    - tool_type
    - version
    - permissions
    - input
    - output
    - provenance

rule retrieval_provenance:
  retrieval-augmented AIOutput SHOULD preserve source references
  where traceability is required

# ---------- HUMAN INTERACTION ----------
entity HumanInteractionMetadata:
  type: AIMetadata
  may_include:
    - reviewer
    - annotator
    - approver
    - correction
    - feedback
    - timestamp

rule human_review:
  human-reviewed output SHOULD remain distinguishable
  from unreviewed output

# ---------- PROVENANCE ----------
entity AIProvenance:
  type: ProvenanceMetadata
  may_include:
    - model
    - model_version
    - dataset
    - prompt
    - context
    - tools
    - retrieval_sources
    - processing_history
    - human_interactions
    - timestamp

rule provenance_chain:
  AIOutput SHOULD preserve relevant derivation chain
  from model, inputs, context, and transformations

rule source_generated_distinction:
  source data MUST remain distinguishable
  from generated or transformed content

# ---------- VALIDATION ----------
validation:
  require:
    - identifiable_ai_resource

  validate_if_present:
    - model_identifier
    - architecture
    - model_version
    - training_metadata
    - dataset_metadata
    - inference_metadata
    - prompt_metadata
    - evaluation_metadata
    - confidence
    - deployment_metadata
    - provenance

  reject:
    - confidence_outside_valid_range
    - output_without_model_identity where attribution is mandatory
    - evaluation_score_without_metric_context
    - contradictory_model_version_relationship
    - generated_content_presented_as source_content
    - unsupported_performance_comparison

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE:
  "AI metadata" ~= "artificial intelligence metadata"
  "model metadata" ~= "AI model metadata" WHEN model is AI system
  "inference metadata" ~= "AI inference metadata"
  "training metadata" ~= "AI training metadata"
  "AI provenance" ~= "model and output provenance"
  "generated content metadata" ~= "AI output metadata" WHEN output is AI-generated

  PRESERVE distinctions:
    AI_model != model_version
    model_family != model_version
    training != inference
    training_dataset != evaluation_dataset
    prompt != output
    AI_output != verified_fact
    confidence != calibrated_probability unless explicitly defined
    source_content != generated_content
    raw_output != human_reviewed_output
    model_metadata != dataset_metadata

# ---------- CONFIDENCE MODEL ----------
CONFIDENCE:
  explicit_ai_metadata:
    score: 1.00

  explicit_model_identifier:
    score: 1.00

  explicit_model_version:
    score: 1.00

  traceable_inference_record:
    score: 0.98

  traceable_evaluation_result:
    score: 0.98

  inferred_model_family:
    score: 0.85

  inferred_generation_source:
    score: <= 0.80

  ambiguous_ai_provenance:
    score: <= 0.60
    action: preserve uncertainty

# ---------- UPDATE MODEL ----------
UPDATE_MODEL:
  on_model_revision:
    - preserve previous ModelVersion
    - create new version
    - record architecture or behaviour changes
    - reassess evaluation results
    - update provenance

  on_training_update:
    - preserve previous training state
    - record new datasets and parameters
    - create new checkpoint or model version where applicable
    - update provenance

  on_deployment_update:
    - preserve previous deployment state
    - record deployed ModelVersion
    - update configuration and status
    - preserve provenance

  on_output_review:
    - preserve raw AIOutput
    - attach review or correction
    - distinguish reviewed output
    - record human interaction provenance

# ---------- FLOW HASH ----------
FLOW_HASH:
  inputs:
    - ontology
    - ai_metadata_entities
    - relationships
    - model_rules
    - training_rules
    - inference_rules
    - evaluation_rules
    - provenance_rules
    - validation
    - semantic_equivalence
    - confidence_model
    - update_model

  canonicalisation:
    - normalise_whitespace
    - preserve_case_sensitive_identifiers
    - sort_unordered_property_sets
    - preserve_rule_order

  output:
    deterministic_semantic_hash

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION:
  interpret_as:
    - metadata ontology
    - AI lifecycle model
    - model provenance structure
    - AI evaluation and governance model

  operations:
    - identify AI resources
    - resolve model identity and version
    - inspect architecture
    - trace training datasets and methods
    - resolve inference context
    - inspect prompts and retrieval context
    - identify AI-generated outputs
    - evaluate confidence and uncertainty
    - compare compatible evaluation results
    - inspect deployment state
    - trace AI provenance
    - distinguish source and generated content

  constraints:
    - do_not_present_AI_output_as_verified_fact
    - do_not_equate_confidence_with_probability_without_calibration
    - do_not_detach_output_from_model_version_where_attribution_matters
    - do_not_merge_training_and_evaluation_roles
    - do_not_discard_raw_output_after_human_review
    - preserve_model_dataset_prompt_context_and_provenance

# ---------- QUERY MODEL ----------
query:
  input:
    - ai_resource
    - model_identifier
    - model_family
    - model_version
    - dataset
    - training_method
    - inference_context
    - evaluation_metric
    - deployment_status
    - provenance

  resolve:
    1. identify AIResource
    2. resolve model identity and version
    3. inspect ModelArchitecture
    4. retrieve TrainingMetadata
    5. resolve datasets and roles
    6. inspect InferenceMetadata
    7. inspect PromptMetadata and retrieval context
    8. evaluate AIOutput status
    9. inspect EvaluationMetadata
    10. trace deployment and provenance

  output:
    - ai_resource
    - model
    - model_version
    - architecture
    - training_metadata
    - datasets
    - inference_metadata
    - evaluation_metadata
    - deployment_metadata
    - provenance
    - confidence

# ---------- INFERENCE ----------
inference:
  IF AIOutput explicitly references AIModel and ModelVersion
  THEN associate output with model state
  WITH confidence = 1.00

  IF Dataset is used during optimisation of model parameters
  THEN classify dataset_role = training_or_fine_tuning
  according_to process context

  IF Dataset is used only for held-out performance assessment
  THEN classify dataset_role = evaluation

  IF AIOutput has retrieval source references
  THEN construct retrieval provenance chain

  IF model or output provenance remains ambiguous
  THEN preserve candidate interpretations
  AND reduce confidence

# ---------- OUTPUT CONTRACT ----------
output:
  ontology_entity: AIMetadata
  ai_resource_structure: machine_interpretable
  model_identity: explicit
  model_versions: traceable
  training_context: preserved
  dataset_roles: explicit
  inference_context: traceable
  generated_output_status: explicit
  evaluation_context: preserved
  deployment_state: resolvable
  provenance: preserved
  uncertainty: explicit
  semantic_retrieval: enabled

end flow