Calculus Domain Ontology

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

flow "CalculusDomainOntology" v1.0 {
  ontology:
    id: "calculus-domain-ontology"
    parent: "mathematical-domains"
    purpose: "Represent calculus concepts, differentiability, integration, limits, differential equations and justified mathematical inference."

  types:
    Domain: {id: string, space: string, constraints: string[]}
    Variable: {id: string, domain: string, unit: string?}
    Function: {id: string, domain: string, codomain: string, expression: string?, assumptions: string[]}
    Limit: {id: string, function: string, approach: string, value: string?, mode: enum[finite, infinite, one_sided, multivariable], proof: string?}
    Derivative: {id: string, function: string, variable: string, order: integer, domain: string, expression: string?, proof: string?}
    Integral: {id: string, integrand: string, variable: string, bounds: string[]?, kind: enum[definite, indefinite, improper, multiple, line, surface], measure: string?, result: string?, proof: string?}
    DifferentialEquation: {id: string, equation: string, order: integer, initial_conditions: string[], boundary_conditions: string[]}
    Theorem: {id: string, statement: string, hypotheses: string[], conclusion: string, proof_reference: string?}
    Evidence: {id: string, kind: enum[formal_proof, symbolic_derivation, numerical_estimate, empirical_observation], source: string, uncertainty: number?}
    Relationship: {id: string, subject: string, predicate: string, object: string, context: string?, confidence: number, evidence: string[]}

  predicates:
    has_domain(function: Function, domain: Domain)
    converges_to(limit: Limit, value: string)
    differentiates_to(function: Function, derivative: Derivative)
    integrates_to(integrand: Function, integral: Integral)
    satisfies_equation(function: Function, equation: DifferentialEquation)
    depends_on(function: Function, variable: Variable)
    justified_by(relationship: Relationship, evidence: Evidence)
    derived_from(result: string, source: string)

  constraints:
    - "All references must resolve to typed entities."
    - "Confidence values must lie within [0, 1]."
    - "Derivatives require a specified variable and a differentiability domain."
    - "Definite integrals require bounds; indefinite integrals require an arbitrary integration constant where appropriate."
    - "Improper integrals require convergence checks."
    - "Symbolic transformations must retain hypotheses and valid domains."
    - "Physical quantities require dimensionally consistent units."
    - "Numerical approximation must not be represented as exact proof."
    - "Differential-equation solutions must satisfy stated initial or boundary conditions where applicable."

  inference:
    rule differentiability_implies_continuity:
      if differentiable(f, x, domain) and x in domain
      then continuous_at(f, x)
      confidence: "mathematical certainty only when assumptions are formally verified"
    rule linearity_of_derivative:
      if differentiable(f, x, D) and differentiable(g, x, D) and constants(a, b)
      then derivative(a*f + b*g, x, D) = a*derivative(f,x,D) + b*derivative(g,x,D)
      confidence: "subject to common domain and assumptions"
    rule fundamental_theorem_of_calculus:
      if continuous(f, [a,b]) and F_is_antiderivative_of_f(F, f, [a,b])
      then definite_integral(f, a, b) = F(b) - F(a)
      confidence: "requires theorem hypotheses"
    rule chain_rule:
      if differentiable(g, x, D) and differentiable(f, g(x), g(D))
      then derivative(compose(f,g),x) = derivative(f,g(x))*derivative(g,x)
      confidence: "requires composition and differentiability conditions"

  SEMANTIC_EQUIVALENCE:
    - "Normalise accepted notation for derivatives, limits and integrals without erasing domains."
    - "Distinguish mathematical equality from numerical approximation."
    - "Treat equivalent expressions as context- and assumption-dependent."
    - "Preserve variable binding, integration constants, units and coordinate systems."

  CONFIDENCE:
    range: [0,1]
    factors: [proof_validity, assumption_coverage, numerical_error, source_reliability, model_adequacy]
    policy: "Separate theorem-level certainty from empirical or numerical uncertainty; do not inflate confidence by inference chaining."

  VALIDATION:
    - "Verify domain and codomain compatibility, variable scope and type references."
    - "Check differentiation and integration assumptions, convergence and singularities."
    - "Check unit consistency and initial/boundary conditions."
    - "Record counterexamples and unresolved proof obligations."
    - "Retain source and derivation provenance for every inferred relationship."

  FLOW_HASH:
    algorithm: "SHA-256"
    input: "canonicalised ontology version, definitions, typed assertions, 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 proof obligations and evidence-backed edges"
    outputs: [concept_links, relation_triples, symbolic_derivations, proof_obligations, uncertainty_annotations, provenance_records]
    safeguards: [preserve_assumptions, distinguish_exact_from_approximate, no_unverified_theorems, retain_domains_and_units]
}

END FLOW ALGEBRA