Mathematics Domain Ontology

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

flow "MathematicsDomainOntology" v1.0 {
  ontology:
    id: "mathematics-domain-ontology"
    parent: "mathematical-domains"
    purpose: "Represent mathematical objects, structures, propositions, proofs and transformations with typed, verifiable relationships."

  types:
    MathematicalObject: {id: string, kind: enum[number, set, function, relation, vector, matrix, space, structure, other], definition: string, domain: string?}
    MathematicalStructure: {id: string, carrier: string, operations: string[], axioms: string[], assumptions: string[]}
    Proposition: {id: string, statement: string, assumptions: string[], status: enum[unproved, proved, disproved, conjectured, independent, unknown]}
    Proof: {id: string, proposition: string, steps: string[], method: string, provenance: string}
    Transformation: {id: string, input: string, output: string, operation: string, conditions: string[]}
    Quantity: {value: number, unit: string?, uncertainty: number?}
    Relationship: {id: string, subject: string, predicate: string, object: string, context: string?, confidence: number, evidence: string[]}

  predicates:
    element_of(object: MathematicalObject, set: MathematicalObject)
    subset_of(a: MathematicalObject, b: MathematicalObject)
    maps_to(function: MathematicalObject, input: MathematicalObject, output: MathematicalObject)
    satisfies(object: MathematicalObject, proposition: Proposition)
    proves(proof: Proof, proposition: Proposition)
    depends_on(proposition: Proposition, assumption: Proposition)
    isomorphic_to(a: MathematicalStructure, b: MathematicalStructure)
    equivalent_under(a: Proposition, b: Proposition, assumptions: string[])
    transforms_into(a: MathematicalObject, b: MathematicalObject, transformation: Transformation)

  constraints:
    - "All identifiers and relationship endpoints must resolve to declared typed entities."
    - "Confidence values must lie within [0,1]; confidence is not mathematical truth."
    - "Proof validity requires sound inference steps under explicit axioms and assumptions."
    - "Distinguish syntactic equality, semantic equivalence, isomorphism and approximation."
    - "Function evaluation requires compatible domain and codomain types."
    - "Do not infer equivalence across different mathematical structures without a valid mapping."
    - "Numerical approximations must preserve precision, tolerance and uncertainty where relevant."
    - "Conjectures must never be labelled proved without an independently checkable proof."

  inference:
    rule subset_transitivity:
      if subset_of(a,b) and subset_of(b,c)
      then subset_of(a,c)
      condition: "set interpretations and universes are compatible"
    rule membership_propagation:
      if element_of(x,a) and subset_of(a,b)
      then element_of(x,b)
      condition: "all sets share a compatible interpretation"
    rule equivalence_transitivity:
      if equivalent_under(p,q,A) and equivalent_under(q,r,A)
      then equivalent_under(p,r,A)
      condition: "the same assumptions and interpretation apply"
    rule proof_acceptance:
      if proves(proof,p) and valid_proof(proof) and assumptions_satisfied(proof)
      then verified(p)
      confidence: "logical verification, not a probabilistic confidence upgrade"

  SEMANTIC_EQUIVALENCE:
    - "Normalise mathematical symbols and terminology without losing domain assumptions."
    - "Distinguish equality, logical equivalence, structural isomorphism and numerical closeness."
    - "Record mappings between notation systems and ontology versions."

  CONFIDENCE:
    range: [0,1]
    factors: [source_reliability, formal_verification, proof_completeness, model_assumptions, numerical_error]
    policy: "Keep epistemic confidence separate from deductive validity; never manufacture certainty through inference chaining."

  VALIDATION:
    - "Check type compatibility, axioms, assumptions, domains and codomains."
    - "Verify proof steps and transformation preconditions."
    - "Detect contradictory claims only within compatible formal contexts."
    - "Preserve provenance for definitions, theorems, proofs and computed results."

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

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

  AI_CONSUMPTION:
    representation: "typed mathematical knowledge graph with explicit assumptions and proof provenance"
    outputs: [entity_links, formal_relations, theorem_dependencies, proof_traces, validation_results, provenance_records]
    safeguards: [no_unverified_proofs_as_facts, preserve_assumptions, distinguish_approximation_from_equality, avoid_invalid_type_coercion]
}

END FLOW ALGEBRA