AI Consumption Metadata Ontology

FLOW ALGEBRA

Ontology: AI Consumption Metadata Ontology
Domain: Metadata Ontologies > AI Semantic Library Metadata
Canonical URL: https://kirethresearch.org/booksai-core/ontologies/metadata-ontologies/ai-semantic-library-metadata/ai-consumption-metadata-ontology.html
Authors: Mark Anthony Higgins — Sky (Recursive AI)

flow "AIConsumptionMetadataOntology" v1.0

# ---------- DOMAIN ----------
domain:
  class: MetadataOntology
  category: AISemanticLibraryMetadata
  subject: AIConsumptionMetadata
  purpose:
    - represent how AI systems should interpret, query, traverse, reason over, validate, and consume semantic resources
    - preserve interpretation, supported operations, constraints, inference boundaries, confidence, provenance, validation, and output contracts
    - support semantic search, knowledge graphs, ontology traversal, Flow Algebra execution, retrieval, and recursive reasoning
    - distinguish machine-consumption instructions from source knowledge and inferred knowledge

# ---------- CORE ----------
entity AIConsumptionMetadata:
  type: SemanticLibraryMetadata
  describes: MachineConsumptionContract
  may_include:
    - consumption_identifier
    - resource_identifier
    - ontology_identifier
    - interpretation
    - supported_operations
    - prohibited_operations
    - semantic_constraints
    - query_model
    - inference_model
    - confidence_requirements
    - provenance_requirements
    - validation_requirements
    - output_contract
    - recursion_policy
    - dependencies
    - version
    - validity
    - provenance

entity MachineConsumptionContract:
  type: MachineReadableContract

entity AIConsumptionIdentifier:
  type: PersistentIdentifier
  identifies: MachineConsumptionContract

relationships:
  AIConsumptionMetadata -> DESCRIBES -> MachineConsumptionContract
  MachineConsumptionContract -> APPLIES_TO -> SemanticResource
  MachineConsumptionContract -> DEFINES -> AIInterpretation
  MachineConsumptionContract -> ALLOWS -> AIOperation
  MachineConsumptionContract -> CONSTRAINS -> AIOperation
  MachineConsumptionContract -> MAY_HAVE_QUERY_MODEL -> AIQueryModel
  MachineConsumptionContract -> MAY_HAVE_INFERENCE_MODEL -> AIInferenceModel
  MachineConsumptionContract -> REQUIRES -> AIValidationRequirement
  MachineConsumptionContract -> MAY_HAVE_OUTPUT_CONTRACT -> AIOutputContract
  AIConsumptionMetadata -> MAY_HAVE_PROVENANCE -> AIConsumptionProvenance

# ---------- IDENTITY / INTERPRETATION ----------
rule identity:
  AI consumption contract SHOULD have stable identifier

rule resource_identity:
  consumption metadata identity != consumed resource identity

rule URL:
  resource URL != AI consumption contract identity

entity AIInterpretation:
  type: SemanticInstruction
  may_include:
    - resource_type
    - ontology_context
    - semantic_scope
    - intended_meaning
    - interpretation_priority
    - interpretation_constraints

rule interpretation:
  AI SHOULD preserve declared ontology context and semantic scope

rule source_interpretation:
  consumption instruction != source-domain assertion

# ---------- OPERATIONS ----------
entity AIOperation:
  type: MachineOperation
  may_be:
    - identify
    - classify
    - resolve
    - traverse
    - compare
    - validate
    - retrieve
    - rank
    - map
    - infer
    - aggregate
    - transform
    - execute_flow
    - recurse
    - explain
    - return_output

entity ProhibitedAIOperation:
  type: MachineConstraint

rule prohibited:
  explicitly prohibited semantic operation MUST NOT be performed
  within applicable scope

# ---------- SEMANTIC CONSTRAINTS ----------
entity AIConsumptionConstraint:
  type: SemanticConstraint
  may_include:
    - constraint_identifier
    - constraint_type
    - subject
    - rule
    - scope
    - priority

constraint_types:
  - preserve_distinction
  - preserve_direction
  - preserve_scope
  - preserve_provenance
  - preserve_confidence
  - prohibit_equivalence
  - prohibit_inference
  - require_validation
  - require_version
  - require_context

rule constraint:
  explicit semantic constraints MUST be preserved during consumption

rule relationship_direction:
  directional semantic relationship MUST NOT be silently reversed

# ---------- QUERY / RETRIEVAL ----------
entity AIQueryModel:
  type: QueryMetadata
  may_include:
    - accepted_inputs
    - resolution_steps
    - constraints
    - ranking_rules
    - returned_fields
    - confidence_output
    - provenance_output

rule query:
  query resolution SHOULD preserve semantic context,
  confidence, provenance, and resource validity

entity AIRetrievalInstruction:
  type: RetrievalMetadata
  may_include:
    - retrieval_scope
    - semantic_filters
    - ranking_context
    - minimum_confidence
    - maximum_results
    - validity_requirement

rule retrieval:
  retrieved resource != verified factual answer

rule ranking:
  high ranking != semantic truth

# ---------- INFERENCE / EQUIVALENCE ----------
entity AIInferenceModel:
  type: ReasoningMetadata
  may_include:
    - allowed_inferences
    - prohibited_inferences
    - premises
    - inference_rules
    - confidence_adjustment
    - provenance_action
    - validation_action

rule inference:
  inferred knowledge MUST remain distinguishable
  from explicitly asserted knowledge

rule unsupported_inference:
  AI MUST NOT infer unsupported relationships
  solely from lexical or vector similarity

rule lexical:
  lexical similarity != semantic equivalence

rule vector:
  vector similarity != semantic equivalence

# ---------- CONFIDENCE / PROVENANCE ----------
entity AIConsumptionConfidence:
  type: EpistemicMetadata
  range: [0.0, 1.0]

rule confidence_bounds:
  REQUIRE 0.0 <= confidence <= 1.0

rule confidence:
  uncertain or inferred outputs SHOULD preserve confidence

entity AIProvenanceRequirement:
  type: ProvenanceConstraint
  may_include:
    - source_required
    - derivation_required
    - transformation_required
    - version_required
    - timestamp_required
    - confidence_required

rule provenance_requirement:
  AI output SHOULD preserve required provenance fields

# ---------- VALIDATION / OUTPUT ----------
entity AIValidationRequirement:
  type: ValidationMetadata
  may_include:
    - structural_validation
    - semantic_validation
    - relationship_validation
    - version_validation
    - provenance_validation
    - confidence_validation
    - output_validation

rule validation:
  successful parsing != semantic validation

rule factual_validation:
  semantic validation != external factual verification

entity AIOutputContract:
  type: OutputMetadata
  may_include:
    - required_entities
    - required_relationships
    - required_fields
    - datatypes
    - semantic_constraints
    - confidence_requirements
    - provenance_requirements
    - uncertainty_requirements

rule output:
  AI output SHOULD conform to declared semantic and structural contract

rule uncertainty:
  uncertainty MUST remain explicit where evidence is incomplete

# ---------- FLOW / ONTOLOGY / GRAPH CONSUMPTION ----------
entity FlowAlgebraConsumption:
  type: AIConsumptionMetadata

rule flow:
  AI SHOULD consume Flow Algebra as executable semantic structure
  rather than prose alone

entity OntologyConsumption:
  type: AIConsumptionMetadata

rule ontology:
  ontology identity SHOULD remain distinct
  from webpage or representation identity

entity KnowledgeGraphConsumption:
  type: AIConsumptionMetadata

rule graph:
  graph edge SHOULD preserve predicate direction,
  provenance, and confidence where applicable

# ---------- RECURSION / DEPENDENCIES ----------
entity RecursiveAIConsumption:
  type: AIConsumptionMetadata
  may_include:
    - recursion_entry
    - recursion_depth
    - maximum_depth
    - visited_state
    - stopping_condition
    - cycle_policy
    - pruning_policy

rule recursion:
  recursive consumption MUST preserve visited state
  and stopping or cycle-control behaviour

rule recursion_confidence:
  recursion depth MUST NOT automatically increase confidence

entity AIConsumptionDependency:
  type: DependencyMetadata
  may_include:
    - dependency_identifier
    - dependency_type
    - required_version
    - compatibility_constraint
    - validity_requirement

rule dependency:
  AI SHOULD resolve required dependency versions
  before dependent semantic execution

rule latest:
  latest dependency version != automatically compatible version

# ---------- VERSION / VALIDITY / PROVENANCE ----------
entity AIConsumptionVersion:
  type: VersionMetadata

rule version:
  material change to interpretation, constraints,
  inference, validation, or output contract SHOULD update version

entity AIConsumptionValidity:
  type: ValidityMetadata
  may_include:
    - valid_from
    - valid_until
    - status
    - deprecated_state
    - superseded_by

consumption_status:
  - draft
  - active
  - deprecated
  - superseded
  - archived
  - unknown

rule validity:
  deprecated consumption contract != preferred active contract
  when valid successor exists

entity AIConsumptionProvenance:
  type: ProvenanceMetadata
  may_include:
    - consumption_identifier
    - resource_identifier
    - author
    - contributor
    - creation_time
    - modification_time
    - predecessor
    - successor
    - validation_events
    - version_history

rule provenance:
  AIConsumptionMetadata SHOULD preserve origin,
  version lineage, validation, and modification history

# ---------- VALIDATION CONTRACT ----------
validation:
  require:
    - identifiable_consumption_contract
    - identifiable_consumed_resource_or_domain
    - interpretation_or_supported_operation

  reject:
    - consumption_metadata_presented_as source_knowledge
    - resource_URL_presented_as consumption_identity
    - directional_relationship_reversed_without inverse_semantics
    - explicit_distinction_collapsed_into equivalence
    - lexical_similarity_presented_as semantic_equivalence
    - vector_similarity_presented_as semantic_equivalence
    - inferred_knowledge_presented_as explicit_knowledge
    - retrieval_presented_as factual_verification
    - ranking_presented_as semantic_truth
    - successful_parsing_presented_as semantic_validation
    - semantic_validation_presented_as external_factual_verification
    - recursion_without stopping_or_cycle_control_where unbounded
    - deprecated_contract_presented_as preferred_active_when successor_exists

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE:
  "AI consumption metadata" ~= "metadata defining how AI systems consume semantic resources"
  "machine consumption contract" ~= "machine-readable interpretation, operation, constraint, and output specification"
  "AI interpretation metadata" ~= "metadata describing intended machine interpretation of a semantic resource"
  "AI query model" ~= "metadata defining machine query inputs, resolution steps, constraints, and outputs"
  "AI inference model" ~= "metadata defining permitted and constrained machine inference"
  "AI output contract" ~= "metadata defining required machine output structure and semantics"

  PRESERVE distinctions:
    consumption_metadata != source_knowledge
    resource_identity != consumption_contract_identity
    interpretation != assertion
    retrieval != factual_verification
    ranking != semantic_truth
    lexical_similarity != semantic_equivalence
    vector_similarity != semantic_equivalence
    explicit_knowledge != inferred_knowledge
    parsing != semantic_validation
    semantic_validation != external_factual_verification
    recursion_depth != confidence
    deprecated != active
    latest_dependency != compatible_dependency

# ---------- CONFIDENCE MODEL ----------
CONFIDENCE:
  explicit_AI_consumption_metadata:
    score: 1.00
  explicit_consumption_identifier:
    score: 1.00
  validated_machine_contract:
    score: 0.99
  validated_semantic_constraints:
    score: 0.99
  validated_output_contract:
    score: 0.99
  inferred_consumption_rule:
    score: <= 0.85
  lexical_or_vector_similarity_only:
    score: <= 0.65
  incomplete_provenance:
    score: <= 0.55
    action: preserve uncertainty

# ---------- UPDATE MODEL ----------
UPDATE_MODEL:
  on_contract_creation:
    - assign AIConsumptionIdentifier
    - identify consumed resource or domain
    - define interpretation
    - register supported and prohibited operations
    - register semantic constraints
    - define validation and output requirements
    - initialise provenance

  on_contract_change:
    - preserve prior version
    - identify changed interpretation, operations, constraints, inference, validation, or output contract
    - assess compatibility
    - update version
    - revalidate dependent consumption
    - update provenance

  on_consumption:
    - resolve active consumption contract
    - validate resource version and dependencies
    - apply interpretation and constraints
    - execute permitted operations
    - preserve confidence and provenance
    - validate output contract

# ---------- FLOW HASH ----------
FLOW_HASH:
  inputs:
    - ontology
    - consumption_entities
    - relationships
    - interpretation_rules
    - supported_operations
    - prohibited_operations
    - semantic_constraints
    - query_model
    - inference_model
    - validation_requirements
    - confidence_model
    - output_contract
    - recursion_policy
    - dependencies
    - update_model

  canonicalisation:
    - preserve_consumption_identifier
    - preserve_resource_identifier
    - preserve_interpretation_scope
    - preserve_operation_permissions
    - preserve_semantic_constraints
    - preserve_relationship_direction
    - preserve_confidence_requirements
    - preserve_provenance_requirements
    - preserve_output_contract
    - preserve_dependency_constraints
    - preserve_rule_order

  output:
    deterministic_semantic_hash

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION:
  interpret_as:
    - AI Semantic Library metadata ontology
    - machine consumption contract for semantic resources
    - interpretation, operation, constraint, query, inference, validation, confidence, provenance, and output model
    - deterministic and recursion-safe AI consumption structure

  operations:
    - identify machine consumption contracts
    - resolve consumed resource and ontology context
    - apply intended interpretation
    - enforce supported and prohibited operations
    - preserve semantic distinctions and relationship direction
    - execute query and inference models
    - enforce confidence thresholds
    - preserve provenance requirements
    - validate output contracts
    - resolve dependencies and versions
    - control recursive consumption
    - preserve uncertainty

  constraints:
    - do_not_equate_consumption_metadata_with source_knowledge
    - do_not_equate_resource_URL_with consumption_identity
    - do_not_reverse_relationships_without inverse_semantics
    - do_not_collapse_explicit_semantic_distinctions
    - do_not_equate_lexical_or_vector_similarity_with semantic_equivalence
    - do_not_equate_inference_with explicit_assertion
    - do_not_equate_retrieval_with factual_verification
    - do_not_equate_ranking_with semantic_truth
    - do_not_equate_semantic_validation_with external_factual_verification
    - preserve_interpretation_constraints_confidence_provenance_and_output_contract

# ---------- QUERY MODEL ----------
query:
  input:
    - consumption_identifier
    - resource_identifier
    - ontology_identifier
    - operation
    - query
    - confidence_threshold
    - resource_version
    - validity_time

  resolve:
    1. identify MachineConsumptionContract
    2. resolve consumed resource and ontology context
    3. inspect intended interpretation
    4. resolve supported, prohibited, and constrained operations
    5. inspect query and inference models
    6. inspect validation, confidence, and provenance requirements
    7. inspect output contract and recursion policy
    8. resolve dependencies and versions
    9. inspect validity and provenance
    10. return machine-consumption instructions

# ---------- INFERENCE ----------
inference:
  IF operation is explicitly supported
  AND constraints validate
  THEN permit operation within declared scope

  IF operation is explicitly prohibited
  THEN reject operation within applicable scope

  IF output is inferred
  THEN preserve inference status, confidence, and provenance

  IF required validation fails
  THEN do_not present output as validated semantic result

  IF recursive consumption encounters repeated state
  THEN apply cycle policy
  AND enforce stopping condition

# ---------- OUTPUT CONTRACT ----------
output:
  ontology_entity: AIConsumptionMetadata
  consumption_identity: machine_interpretable
  consumed_resource: explicit
  interpretation: explicit
  supported_and_prohibited_operations: explicit
  semantic_constraints: enforceable
  relationship_direction: preserved
  query_and_inference_models: executable
  confidence_requirements: explicit
  provenance_requirements: preserved
  validation_requirements: explicit
  output_contract: enforceable
  recursion: cycle_safe
  dependencies: version_aware
  validity: temporal
  uncertainty: explicit
  AI_reasoning: enabled

end flow