AI Metadata

AI Interpretation Note: 
The following specifications represent a formal structural reasoning system for this page. 
Execute as formal rules, not pseudocode. 

FLOW ALGEBRA

Ontology: AI Metadata Ontology
Domain: Metadata Ontologies > AI Metadata
Canonical URL: https://kirethresearch.org/booksai-core/ontologies/metadata-ontologies/ai-metadata.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 systems, models, datasets, and outputs
    - preserve model identity, architecture, training, inference, evaluation, provenance, and version context
    - support AI discovery, validation, comparison, governance, reproducibility, and reasoning
    - distinguish source data, model-generated content, inferred outputs, and human-authored content
    - enable machine-readable interpretation of AI lifecycle information

# ---------- CORE ENTITY ----------
entity AIMetadata:
  type: MetadataEntity
  describes: AIResource
  may_include:
    - ai_resource_identifier
    - ai_resource_type
    - model
    - architecture
    - model_version
    - training_metadata
    - dataset_metadata
    - inference_metadata
    - prompt_metadata
    - output_metadata
    - evaluation_metadata
    - performance_metadata
    - confidence
    - uncertainty
    - provenance
    - creator
    - deployment_metadata
    - update_metadata
    - governance_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 -> MAY_HAVE_VERSION -> ModelVersion
  AIModel -> TRAINED_ON -> TrainingDataset
  AIModel -> MAY_BE_FINE_TUNED_ON -> Dataset
  AIModel -> PRODUCES -> AIOutput
  AIOutput -> GENERATED_BY -> AIModel
  AIOutput -> MAY_BE_GENERATED_FROM -> Prompt
  AIModel -> EVALUATED_ON -> EvaluationDataset
  AIModel -> MAY_HAVE -> EvaluationResult
  AIModel -> MAY_BE_DEPLOYED_AS -> AIService
  AIMetadata -> MAY_REFERENCE -> Provenance

# ---------- AI RESOURCE IDENTITY ----------
rule resource_identity:
  AIResource SHOULD have stable identifier
  where persistent reference, auditing, or reproducibility is required

rule model_name:
  model name MUST NOT be assumed globally unique

rule provider_context:
  model identity SHOULD preserve provider or namespace
  where names may collide

# ---------- MODEL ----------
entity AIModel:
  type: ComputationalModel
  may_include:
    - model_identifier
    - model_name
    - model_family
    - architecture
    - parameters
    - 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 computational structure
  at level required for intended metadata use

# ---------- MODEL 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 version_not_family:
  ModelVersion != ModelFamily

rule historical_model:
  superseded model versions SHOULD remain traceable
  where outputs depend on historical model state

# ---------- 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 disclosure and system design permit

rule dataset_reference:
  training dataset SHOULD be referenced by stable identifier
  where available

rule training_not_inference:
  TrainingProcess != InferenceProcess

# ---------- DATASETS ----------
entity AIDatasetMetadata:
  type: DataMetadata
  may_include:
    - dataset_identifier
    - dataset_role
    - source
    - composition
    - preprocessing
    - filtering
    - labelling
    - version
    - provenance

dataset_roles:
  - training
  - validation
  - evaluation
  - fine_tuning
  - retrieval
  - calibration

rule dataset_role:
  same Dataset MAY have different roles
  across different AI lifecycle stages

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

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

rule output_model_link:
  AIOutput MUST NOT be detached from generating model identity
  where model attribution is required

# ---------- 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
  and SHOULD be preserved where permitted and required

rule prompt_version:
  material template change SHOULD create distinguishable PromptVersion

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

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

rule output_not_truth:
  AIOutput != verified_fact

rule output_status:
  AIOutput MAY be:
    - raw
    - validated
    - reviewed
    - corrected
    - rejected
    - superseded

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

rule confidence_bounds:
  REQUIRE 0.0 <= confidence <= 1.0

rule confidence_semantics:
  confidence MUST identify what it represents
  and MUST NOT automatically be interpreted as calibrated probability

rule uncertainty:
  AIOutput MAY preserve uncertainty about:
    - classification
    - prediction
    - entity_resolution
    - retrieval
    - reasoning
    - generation

# ---------- 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 MUST preserve:
    - metric
    - dataset
    - model_version
    - evaluation_method

rule metric_comparison:
  model 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 metrics SHOULD preserve hardware, software, workload, and measurement context
  where comparison depends on them

# ---------- 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_version:
  deployed model version SHOULD be explicit

# ---------- TOOLS / RETRIEVAL ----------
entity ToolMetadata:
  type: AIMetadata
  may_include:
    - tool_identifier
    - tool_type
    - version
    - permissions
    - input
    - output
    - provenance

entity RetrievalMetadata:
  type: AIMetadata
  may_include:
    - retrieval_system
    - query
    - source_documents
    - ranking
    - retrieval_time
    - provenance

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

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

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

# ---------- 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 derivation chain
  from relevant inputs and model state

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

# ---------- 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 ----------
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
    - 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