Mathematical Logic Domain Ontology

FLOW ALGEBRA
TITLE: Mathematical Logic Domain Ontology
DOMAIN: Domain Ontologies / Mathematical Domains / Mathematical Logic
SOURCE: https://kirethresearch.org/booksai-core/ontologies/domain-ontologies/mathematical-domains/mathematical-logic-domain-ontology.html
VERSION: 1.0
AUTHORS: Mark Anthony Higgins — Sky (Recursive AI)
STATUS: Companion formalisation; source-page specification not independently verified.

flow "MathematicalLogicDomainOntology" v1.0 {
  ontology:
    id: "mathematical-logic-domain-ontology"
    parent: "mathematical-domains"
    purpose: "Represent formal languages, logical structures, proofs, models, computability and sound inference with explicit semantics and provenance."

  types:
    Signature: {id: string, sorts: string[], symbols: string[], arities: map?}
    FormalLanguage: {id: string, signature: string, syntax_rules: string[], logic_family: string}
    Formula: {id: string, language: string, expression: string, free_variables: string[]}
    Proposition: {id: string, formula: string, context: string?}
    Interpretation: {id: string, language: string, domain: string, symbol_assignments: map}
    Theory: {id: string, language: string, axioms: string[], inference_system: string}
    Proof: {id: string, theory: string, conclusion: string, steps: string[], provenance: string}
    InferenceStep: {id: string, premises: string[], conclusion: string, rule: string, substitutions: map?}
    Model: {id: string, theory: string, interpretation: string}
    Algorithm: {id: string, input_domain: string, output_domain: string, termination_claim: string?}
    Assertion: {id: string, subject: string, predicate: string, object: string, confidence: number, evidence: string[]}

  predicates:
    well_formed(formula: Formula, language: FormalLanguage)
    axiom_of(formula: Formula, theory: Theory)
    premise_of(formula: Formula, step: InferenceStep)
    derives(step: InferenceStep, formula: Formula)
    proves(proof: Proof, formula: Formula)
    satisfies(interpretation: Interpretation, formula: Formula)
    model_of(model: Model, theory: Theory)
    entails(theory: Theory, formula: Formula)
    equivalent_under(a: Formula, b: Formula, semantics: string)
    contradicts_under(a: Formula, b: Formula, assumptions: string)
    reduces_to(problem_a: string, problem_b: string, reduction: Algorithm)

  constraints:
    - "Every formula must be well formed under a declared language and signature."
    - "Distinguish syntactic provability from semantic entailment."
    - "Inference steps must identify an applicable rule and discharge any side conditions."
    - "Free and bound variables, quantifier scopes and substitutions must be explicit."
    - "Claims of consistency, completeness or decidability require a specified theory and logic."
    - "Do not equate logical equivalence with syntactic identity."
    - "Do not infer an arbitrary conclusion from inconsistency unless the chosen logic licenses explosion."
    - "Confidence metadata measures evidential assurance, not a replacement for proof validity."

  inference:
    rule modus_ponens:
      if proved(P) and proved(implies(P,Q)) and same_theory_and_context(P,Q)
      then proved(Q)
      confidence: "deductive validity conditional on verified premises and rules"
    rule universal_instantiation:
      if proved(forall(x,P(x))) and substitutable(term,x,P)
      then proved(P(term))
      confidence: "deductive validity conditional on capture-free substitution"
    rule entailment_via_model:
      if every_model_of(T)_satisfies(P)
      then entails(T,P)
      confidence: "requires exhaustive semantic justification, not finite sampling alone"
    rule equivalence_substitution:
      if equivalent_under(P,Q,S) and context_preserves_equivalence(C,S)
      then equivalent_under(C(P),C(Q),S)
      confidence: "conditional on compatible semantics and substitution context"

  SEMANTIC_EQUIVALENCE:
    - "Normalise notation only after identifying logic family, signature and binding structure."
    - "Distinguish alpha-equivalence, logical equivalence, equisatisfiability and isomorphism."
    - "Preserve assumptions, model class, interpretation and theory version."

  CONFIDENCE:
    range: [0,1]
    factors: [proof_checker_status, axiom_provenance, rule_soundness, formalisation_quality, independent_verification]
    policy: "A verified proof establishes a theorem relative to its assumptions; do not manufacture numerical certainty by chaining."

  VALIDATION:
    - "Parse and type-check formulae, signatures, proof steps and substitutions."
    - "Check rule applicability, scope, discharged assumptions and model constraints."
    - "Flag contradictory assertions and record whether the logic tolerates inconsistency."
    - "Separate proved, refuted, satisfiable, undecided and unknown outcomes."
    - "Retain provenance for axioms, proof certificates, solvers and formalisation revisions."

  FLOW_HASH:
    algorithm: "SHA-256"
    input: "canonicalised ontology version, formal syntax, axioms, rules, assertions and provenance"
    note: "Compute hash at execution; no hash value is claimed here."

  UPDATE_MODEL:
    strategy: "versioned, provenance-preserving incremental update"
    steps: [ingest, parse, normalise, type_check, validate, compare, recompute_affected_proofs, publish]
    rollback: true

  AI_CONSUMPTION:
    representation: "typed formal-logic knowledge graph with proof and model annotations"
    outputs: [formula_links, theorem_dependencies, proof_traces, model_relations, uncertainty_annotations, provenance_records]
    safeguards: [preserve_assumptions, distinguish_proof_from_prediction, avoid_unsupported_entailment, verify_variable_scope]
}

END FLOW ALGEBRA