AI Reasoning Metadata Ontology

FLOW ALGEBRA

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

Authors: Mark Anthony Higgins — Sky (Recursive AI)

flow "AIReasoningMetadataOntology" v1.0

# ---------- DOMAIN ----------
domain:
  class: MetadataOntology
  category: AIMetadata
  subject: AIReasoningMetadata
  purpose:
    - represent metadata describing AI reasoning processes and derived conclusions
    - preserve reasoning identity, method, inputs, rules, assumptions, evidence, outputs, and provenance
    - support reasoning traceability, validation, comparison, reproducibility, and governance
    - distinguish source assertions from inferred, derived, hypothetical, and uncertain conclusions
    - enable machine-readable reasoning over AI reasoning states without requiring hidden internal computation traces

# ---------- CORE ENTITY ----------
entity AIReasoningMetadata:
  type: AIMetadata
  describes: ReasoningProcess
  may_include:
    - reasoning_identifier
    - model_identifier
    - model_version
    - reasoning_type
    - reasoning_method
    - input_assertions
    - evidence
    - assumptions
    - rules
    - constraints
    - intermediate_result_metadata
    - conclusion
    - confidence
    - uncertainty
    - validation
    - timestamp
    - provenance
    - status

entity ReasoningProcess:
  type: AIProcess
  consumes:
    - KnowledgeAssertion
    - Evidence
    - Context
  produces:
    - Inference
    - Conclusion
    - DecisionCandidate

entity ReasoningIdentifier:
  type: Identifier
  identifies: ReasoningProcess

# ---------- REASONING TYPES ----------
reasoning_types:
  - deductive
  - inductive
  - abductive
  - probabilistic
  - statistical
  - causal
  - analogical
  - rule_based
  - semantic
  - temporal
  - spatial
  - constraint_based
  - planning
  - decision_reasoning
  - hybrid

# ---------- RELATIONSHIPS ----------
relationships:
  AIReasoningMetadata -> DESCRIBES -> ReasoningProcess
  ReasoningProcess -> IDENTIFIED_BY -> ReasoningIdentifier
  ReasoningProcess -> PERFORMED_BY -> AIModel
  ReasoningProcess -> USES_MODEL_VERSION -> ModelVersion
  ReasoningProcess -> HAS_TYPE -> ReasoningType
  ReasoningProcess -> USES_METHOD -> ReasoningMethod
  ReasoningProcess -> CONSUMES -> KnowledgeAssertion
  ReasoningProcess -> MAY_USE -> Evidence
  ReasoningProcess -> MAY_HAVE_ASSUMPTION -> Assumption
  ReasoningProcess -> MAY_APPLY -> ReasoningRule
  ReasoningProcess -> MAY_HAVE_CONSTRAINT -> ReasoningConstraint
  ReasoningProcess -> PRODUCES -> Conclusion
  Conclusion -> DERIVED_FROM -> ReasoningInput
  AIReasoningMetadata -> MAY_REFERENCE -> ReasoningProvenance

# ---------- REASONING IDENTITY ----------
rule reasoning_identity:
  ReasoningProcess SHOULD have stable ReasoningIdentifier
  where auditing, comparison, or reproducibility is required

rule reasoning_run:
  repeated reasoning executions SHOULD remain distinguishable
  even when inputs and model are identical

rule reasoning_not_model:
  ReasoningProcess != AIModel

# ---------- REASONING METHOD ----------
entity ReasoningMethod:
  type: AIMethod
  examples:
    - logical_inference
    - theorem_proving
    - rule_evaluation
    - probabilistic_inference
    - Bayesian_inference
    - graph_reasoning
    - constraint_solving
    - causal_inference
    - search
    - optimisation
    - planning

rule method:
  ReasoningMethod SHOULD identify externally meaningful reasoning approach
  where available

rule method_not_hidden_trace:
  ReasoningMetadata SHOULD describe reasoning structure and provenance
  without requiring disclosure of hidden internal chain-of-thought

# ---------- INPUT ASSERTIONS ----------
entity ReasoningInput:
  type: KnowledgeResource
  may_be:
    - Fact
    - Claim
    - Observation
    - Measurement
    - Rule
    - Constraint
    - RetrievedResource
    - ToolResult

rule input_provenance:
  ReasoningInput SHOULD preserve source provenance
  where conclusion traceability is required

rule input_status:
  asserted, verified, inferred, and disputed inputs
  SHOULD remain distinguishable

# ---------- ASSUMPTIONS ----------
entity Assumption:
  type: ReasoningPremise
  may_include:
    - assumption_identifier
    - statement
    - scope
    - source
    - confidence
    - validity

rule assumption:
  assumptions affecting Conclusion SHOULD be explicit in metadata
  where available

rule assumption_not_fact:
  Assumption != VerifiedFact

# ---------- EVIDENCE ----------
entity ReasoningEvidence:
  type: Evidence
  may_include:
    - source
    - evidence_type
    - relevance
    - strength
    - validity
    - provenance

rule evidence:
  evidence SHOULD remain linked to supported or challenged conclusion

rule evidence_not_truth:
  Evidence != Truth

# ---------- RULES ----------
entity ReasoningRule:
  type: KnowledgeRule
  may_include:
    - rule_identifier
    - antecedent
    - consequent
    - conditions
    - priority
    - provenance

rule rule_application:
  IF ReasoningRule is applied
  THEN record rule identity or stable reference
  where auditability requires

rule rule_version:
  rule version SHOULD be preserved
  where rule changes alter inference

# ---------- CONSTRAINTS ----------
entity ReasoningConstraint:
  type: AIConstraint
  may_include:
    - logical_constraint
    - domain_constraint
    - temporal_constraint
    - spatial_constraint
    - policy_constraint
    - resource_constraint

rule constraint:
  ReasoningProcess SHOULD respect applicable constraints

# ---------- DEDUCTIVE REASONING ----------
rule deduction:
  IF premises logically entail Conclusion under applied rules
  THEN Conclusion MAY be classified deductive

rule deductive_validity:
  deductive conclusion validity depends on:
    - valid inference form
    - applicable rules
    - premise status

# ---------- INDUCTIVE REASONING ----------
rule induction:
  inductive Conclusion generalises from observations or examples

rule induction_uncertainty:
  inductive conclusion SHOULD preserve uncertainty
  and MUST NOT be represented as deductively guaranteed

# ---------- ABDUCTIVE REASONING ----------
rule abduction:
  abductive reasoning proposes explanatory hypotheses
  compatible with available evidence

rule abductive_status:
  abductive hypothesis != established fact

# ---------- PROBABILISTIC REASONING ----------
rule probabilistic:
  probabilistic reasoning SHOULD preserve:
    - probability_model
    - inputs
    - assumptions
    - output_distribution_or_score
    - calibration_context_optional

rule probability_confidence:
  probability != generic confidence
  unless metadata explicitly defines equivalence

# ---------- CAUSAL REASONING ----------
rule causal:
  causal conclusion SHOULD preserve causal model or evidence basis
  where available

rule correlation:
  correlation != causation

# ---------- SEMANTIC REASONING ----------
rule semantic_reasoning:
  semantic inference SHOULD preserve:
    - ontology
    - ontology_version
    - rules
    - source_assertions
    - inferred_assertions

rule ontology_context:
  ontology-derived Conclusion SHOULD reference applicable ontology version

# ---------- TEMPORAL / SPATIAL REASONING ----------
rule temporal_reasoning:
  temporal inference SHOULD preserve reference times and temporal relations

rule spatial_reasoning:
  spatial inference SHOULD preserve spatial reference and relation semantics

# ---------- CONCLUSION ----------
entity Conclusion:
  type: DerivedKnowledge
  may_be:
    - Inference
    - Hypothesis
    - Prediction
    - Classification
    - DecisionCandidate
    - Recommendation

conclusion_status:
  - derived
  - supported
  - uncertain
  - disputed
  - rejected
  - superseded

rule conclusion:
  Conclusion MUST remain distinguishable
  from source assertion

rule conclusion_trace:
  Conclusion SHOULD link to relevant inputs, method, assumptions, and evidence

# ---------- INTERMEDIATE METADATA ----------
entity IntermediateResultMetadata:
  type: ProcessMetadata
  may_include:
    - stage_identifier
    - stage_type
    - input_reference
    - output_reference
    - validation_state

rule intermediate_metadata:
  systems MAY preserve externally meaningful intermediate states
  without exposing hidden internal reasoning tokens or private chain-of-thought

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

rule confidence_bounds:
  REQUIRE 0.0 <= confidence <= 1.0

rule confidence_scope:
  confidence SHOULD identify whether it applies to:
    - input
    - evidence
    - inference
    - conclusion
    - entity_resolution

rule uncertainty:
  uncertainty SHOULD remain explicit
  where reasoning does not produce deterministic conclusion

# ---------- VALIDATION ----------
entity ReasoningValidation:
  type: ValidationMetadata
  may_include:
    - validation_method
    - rule_check
    - consistency_check
    - external_evidence_check
    - human_review
    - status

rule validation:
  ReasoningValidation SHOULD preserve method and scope

rule validation_not_truth:
  successful structural validation != guaranteed factual truth

# ---------- STATUS ----------
reasoning_status:
  - pending
  - running
  - completed
  - failed
  - partial
  - superseded

rule status:
  ReasoningProcess status SHOULD remain explicit

# ---------- PROVENANCE ----------
entity ReasoningProvenance:
  type: ProvenanceMetadata
  may_include:
    - model
    - model_version
    - inputs
    - evidence
    - rules
    - assumptions
    - context
    - tools
    - retrieval_sources
    - conclusion
    - timestamp

rule provenance:
  AIReasoningMetadata SHOULD preserve externally meaningful derivation provenance
  at granularity available and permitted

rule hidden_reasoning:
  absence of private internal chain-of-thought
  MUST NOT be treated as absence of reasoning provenance
  when inputs, methods, outputs, and validation metadata are available

# ---------- VALIDATION RULES ----------
validation:
  require:
    - identifiable_reasoning_process
    - model_identity
    - reasoning_input
    - conclusion_or_status

  validate_if_present:
    - reasoning_type
    - reasoning_method
    - assumptions
    - evidence
    - rules
    - constraints
    - confidence
    - validation
    - provenance

  reject:
    - confidence_outside_valid_range
    - conclusion_presented_as source_assertion
    - assumption_presented_as verified_fact
    - probabilistic_output_presented_as certainty_without support
    - causal_claim_without declared causal basis where causal metadata is required
    - contradictory_reasoning_status

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE:
  "AI reasoning metadata" ~= "metadata about AI reasoning"
  "reasoning process" ~= "AI reasoning process"
  "inference metadata" ~= "reasoning metadata" WHEN describing derived reasoning result
  "reasoning provenance" ~= "inference provenance"
  "reasoning rule" ~= "inference rule" WHEN used to derive conclusion
  "reasoning conclusion" ~= "derived conclusion"

  PRESERVE distinctions:
    reasoning != training
    reasoning_process != model
    assumption != fact
    evidence != truth
    conclusion != source_assertion
    induction != deduction
    abduction != deduction
    probability != generic_confidence
    correlation != causation
    structural_validation != factual_truth
    reasoning_metadata != hidden_chain_of_thought

# ---------- CONFIDENCE ----------
CONFIDENCE:
  explicit_reasoning_metadata:
    score: 1.00

  explicit_reasoning_identifier:
    score: 1.00

  traceable_rule_based_inference:
    score: 0.98

  validated_deductive_inference:
    score: 0.98

  evidence_supported_conclusion:
    score: 0.90

  probabilistic_or_inductive_conclusion:
    score: dependent_on_model_and_evidence

  inferred_reasoning_type:
    score: <= 0.80

  incomplete_reasoning_provenance:
    score: <= 0.60
    action: preserve unknowns

# ---------- UPDATE MODEL ----------
UPDATE_MODEL:
  on_reasoning_start:
    - assign ReasoningIdentifier
    - record model and ModelVersion
    - record inputs
    - record context
    - initialise provenance
    - set status = running

  on_rule_application:
    - record applied rule reference
    - preserve input references
    - record externally meaningful result metadata
    - update provenance

  on_conclusion:
    - create Conclusion
    - link relevant inputs
    - attach confidence and uncertainty
    - record validation state
    - update provenance

  on_reasoning_revision:
    - preserve previous Conclusion
    - record new evidence or assumptions
    - rerun applicable validation
    - create revised conclusion state
    - preserve provenance

# ---------- FLOW HASH ----------
FLOW_HASH:
  inputs:
    - ontology
    - reasoning_entities
    - reasoning_types
    - relationships
    - method_rules
    - assumption_rules
    - evidence_rules
    - conclusion_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:
    - AI metadata ontology
    - reasoning provenance model
    - inference validation structure
    - conclusion and uncertainty model

  operations:
    - identify reasoning processes
    - resolve reasoning types and methods
    - inspect source assertions
    - inspect assumptions and evidence
    - resolve applied rules
    - evaluate constraints
    - distinguish deductive, inductive, abductive, and probabilistic reasoning
    - trace conclusions to inputs
    - evaluate confidence and uncertainty
    - inspect validation state
    - preserve reasoning provenance

  constraints:
    - do_not_present_assumption_as_fact
    - do_not_present_conclusion_as source_assertion
    - do_not_equate_evidence_with_truth
    - do_not_equate_probability_with generic_confidence
    - do_not_equate_correlation_with causation
    - do_not_require_or_expose_hidden_chain_of_thought
    - preserve_inputs_methods_assumptions_evidence_outputs_and_provenance

# ---------- QUERY MODEL ----------
query:
  input:
    - reasoning_identifier
    - model_identifier
    - model_version
    - reasoning_type
    - reasoning_method
    - input_assertion
    - evidence
    - assumption
    - conclusion
    - status

  resolve:
    1. identify ReasoningProcess
    2. resolve AIModel and ModelVersion
    3. retrieve ReasoningInputs
    4. inspect ReasoningType and Method
    5. inspect assumptions, evidence, rules, and constraints
    6. retrieve Conclusion
    7. inspect confidence and uncertainty
    8. inspect validation state
    9. trace provenance
    10. return reasoning metadata

  output:
    - reasoning_process
    - model
    - model_version
    - reasoning_type
    - method
    - inputs
    - assumptions
    - evidence
    - rules
    - conclusion
    - validation
    - provenance
    - confidence

# ---------- INFERENCE ----------
inference:
  IF Conclusion is generated from explicit inputs and ReasoningRule
  THEN link Conclusion DERIVED_FROM inputs
  AND preserve rule reference

  IF ReasoningType = deductive
  AND inference form validates
  THEN classify structural_reasoning_state = valid
  subject_to premise status

  IF ReasoningType = inductive OR abductive
  THEN preserve non-deductive uncertainty

  IF causal conclusion lacks causal model or evidence basis
  THEN reduce confidence
  AND flag causal_support_missing

  IF reasoning provenance remains incomplete
  THEN preserve unknown components
  AND do_not invent hidden reasoning steps

# ---------- OUTPUT CONTRACT ----------
output:
  ontology_entity: AIReasoningMetadata
  reasoning_structure: machine_interpretable
  reasoning_identity: explicit
  reasoning_types: classified
  methods: traceable
  inputs: source_linked
  assumptions: explicit
  evidence: preserved
  rules: referenceable
  conclusions: derived_and_distinguished
  validation: reportable
  provenance: preserved
  hidden_chain_of_thought: not_required
  uncertainty: explicit
  semantic_retrieval: enabled

end flow