Computational Mathematics Domain Ontology

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

flow "ComputationalMathematicsDomainOntology" v1.0 {
  ontology:
    id: "computational-mathematics-domain-ontology"
    parent: "mathematical-domains"
    purpose: "Represent computational mathematical problems, algorithms, numerical approximations, symbolic methods, simulations and verifiable results."

  types:
    MathematicalProblem: {id: string, domain: string, formulation: string, assumptions: string[], constraints: string[]}
    Algorithm: {id: string, method: string, version: string, prerequisites: string[], complexity: string?}
    NumericalMethod: {id: string, family: enum[linear_algebra, optimisation, integration, differentiation, ode, pde, interpolation, root_finding, other], precision: string?}
    SymbolicExpression: {id: string, expression: string, variables: string[], assumptions: string[]}
    Dataset: {id: string, schema: string, provenance: string, version: string}
    Computation: {id: string, algorithm_id: string, input_ids: string[], environment: string, timestamp: datetime, provenance: string}
    Result: {id: string, value: string, unit: string?, error_bound: number?, status: enum[verified, approximate, unverified, failed], provenance: string}
    ErrorEstimate: {id: string, kind: enum[absolute, relative, truncation, rounding, discretisation, statistical], value: number, method: string}
    Relationship: {id: string, subject: string, predicate: string, object: string, confidence: number, evidence: string[]}

  predicates:
    solves(algorithm: Algorithm, problem: MathematicalProblem)
    implements(method: NumericalMethod, algorithm: Algorithm)
    consumes(computation: Computation, dataset: Dataset)
    produces(computation: Computation, result: Result)
    approximates(result: Result, expression: SymbolicExpression)
    depends_on(computation_a: Computation, computation_b: Computation)
    validates(result_a: Result, result_b: Result)
    estimates_error(estimate: ErrorEstimate, result: Result)

  constraints:
    - "All relationship endpoints must resolve to compatible typed entities."
    - "Confidence must be within [0, 1] and must not substitute for numerical error bounds."
    - "Numerical outputs must identify precision, units where relevant, and applicable error estimates."
    - "Algorithm applicability requires verification of mathematical assumptions and preconditions."
    - "Distinguish numerical approximation from exact symbolic equivalence."
    - "A reproducible computation must retain algorithm version, input versions and execution environment."
    - "Do not infer correctness solely from convergence or agreement between correlated methods."

  inference:
    rule computation_lineage:
      if produces(c,r) and consumes(c,d)
      then derived_from(r,d)
      confidence: "retain input provenance and algorithm version"
    rule dependency_reachability:
      if depends_on(a,b) and depends_on(b,c) and compatible_dependency_context(a,b,c)
      then indirectly_depends_on(a,c)
      confidence: "preserve source evidence; check cycles"
    rule verified_result:
      if produces(c,r) and valid_inputs(c) and verified_method(c) and satisfies_tolerance(r)
      then candidate_verified(r)
      confidence: "subject to independent validation and assumptions"

  SEMANTIC_EQUIVALENCE:
    - "Normalise mathematical notation without discarding domains, assumptions or units."
    - "Distinguish mathematically equivalent formulations from numerically similar outputs."
    - "Track algorithm aliases and method families separately from identity."

  CONFIDENCE:
    range: [0,1]
    factors: [input_quality, numerical_stability, error_bounds, method_validity, reproducibility, independent_validation]
    policy: "Propagate uncertainty conservatively; never manufacture certainty from chained computations."

  VALIDATION:
    - "Check input types, dimensional consistency, domains and mathematical assumptions."
    - "Assess numerical stability, convergence criteria, conditioning and precision."
    - "Check residuals, error bounds and independent reference solutions where available."
    - "Preserve failed computations and conflicting results with provenance."

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

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

  AI_CONSUMPTION:
    representation: "typed mathematical knowledge graph with reproducible computation lineage"
    outputs: [problem_method_links, algorithm_dependencies, result_records, error_annotations, provenance_records, validation_status]
    safeguards: [no_unsupported_exactness_claims, preserve_assumptions, preserve_units, flag_unverified_results]
}

END FLOW ALGEBRA