Numerical Calculus

AI INTERPRETATION NOTE
This Flow Algebra defines the Numerical Calculus parent ontology within the Kireth Research Semantic Library. Numerical calculus studies computational methods for approximating derivatives, integrals and related calculus operations when exact symbolic forms are unavailable, impractical or unsuitable. This ontology supports numerical differentiation, numerical integration, quadrature, finite differences, interpolation-based calculus, adaptive methods, error estimation, convergence, stability, floating-point effects, multidimensional integration and relationships with numerical analysis and scientific computing.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Numerical Calculus"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Computational Mathematics"
 SPECIALISATION = "Numerical Calculus / Parent Ontology"
 CANONICAL_PAGE = "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/computational-mathematics-ontologies/numerical-calculus.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = NumericalCalculus
 ENTITY_CLASS = ComputationalCalculusApproximationFramework
 PRIMARY_CONTEXT = ComputationalMathematicsOntologies
 DEFINITION = "Numerical calculus is the computational approximation of derivatives, integrals and related calculus quantities using discrete numerical methods."
 SYMBOLIC_FORMS = [
  "f'(x) approximately (f(x+h)-f(x))/h",
  "integral_a^b f(x) dx approximately sum_i w_i f(x_i)",
  "D_h f -> f'",
  "Q_n(f) -> integral f"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for numerical differentiation, quadrature, adaptive integration, finite-difference calculus, error estimation, convergence, conditioning and finite-precision computation."
}

SCOPE {
 INCLUDE = [
  NumericalCalculus,
  NumericalDifferentiation,
  NumericalIntegration,
  Quadrature,
  FiniteDifference,
  ForwardDifference,
  BackwardDifference,
  CentralDifference,
  HigherOrderDifference,
  DifferenceStencil,
  DerivativeApproximation,
  FirstDerivativeApproximation,
  SecondDerivativeApproximation,
  HigherDerivativeApproximation,
  GradientApproximation,
  JacobianApproximation,
  HessianApproximation,
  RichardsonExtrapolation,
  Extrapolation,
  StepSize,
  GridSpacing,
  Discretisation,
  TruncationError,
  RoundOffError,
  Cancellation,
  OptimalStepSize,
  NumericalDerivative,
  NumericalIntegral,
  RiemannSum,
  LeftRiemannSum,
  RightRiemannSum,
  MidpointRule,
  TrapezoidalRule,
  CompositeTrapezoidalRule,
  SimpsonsRule,
  CompositeSimpsonsRule,
  NewtonCotesFormula,
  ClosedNewtonCotes,
  OpenNewtonCotes,
  GaussianQuadrature,
  GaussLegendreQuadrature,
  GaussHermiteQuadrature,
  GaussLaguerreQuadrature,
  GaussChebyshevQuadrature,
  AdaptiveQuadrature,
  AdaptiveSimpson,
  RombergIntegration,
  ClenshawCurtisQuadrature,
  SparseGridQuadrature,
  MultidimensionalQuadrature,
  Cubature,
  MonteCarloIntegration,
  QuasiMonteCarloIntegration,
  ImproperIntegral,
  SingularIntegral,
  OscillatoryIntegral,
  PeriodicIntegral,
  WeightedIntegral,
  IntegralTransformApproximation,
  Interpolation,
  PolynomialInterpolation,
  SplineInterpolation,
  PiecewisePolynomial,
  NumericalAntiderivative,
  CumulativeIntegration,
  ErrorEstimate,
  APosterioriErrorEstimate,
  AProriErrorEstimate,
  AbsoluteError,
  RelativeError,
  Convergence,
  ConvergenceRate,
  OrderOfAccuracy,
  Consistency,
  Stability,
  NumericalStability,
  Conditioning,
  Sensitivity,
  FloatingPointArithmetic,
  MachinePrecision,
  Underflow,
  Overflow,
  Verification,
  Benchmarking,
  Reproducibility
 ]
 EXCLUDE_AS_PRIMARY = [
  SymbolicCalculusWithoutNumericalApproximation,
  DifferentialEquationSolvingWithoutCalculusApproximationContext,
  PureInterpolationWithoutDerivativeOrIntegralUse,
  StatisticalIntegrationWithoutNumericalCalculusSemantics
 ]
 DISAMBIGUATION_RULE = "When derivatives or integrals are approximated computationally from discrete evaluations or samples, interpret the context as numerical calculus."
}

CORE_CONCEPTS {
 NumericalCalculus = "Computational approximation of calculus operations."
 NumericalDifferentiation = "Approximation of derivatives using discrete function evaluations."
 NumericalIntegration = "Approximation of definite integrals using weighted sums or sampling."
 FiniteDifference = "Discrete approximation formed from differences between function values."
 Quadrature = "Numerical approximation of integrals by weighted function evaluations."
 AdaptiveMethod = "Method that modifies resolution or sampling based on estimated error."
 RichardsonExtrapolation = "Combination of approximations at multiple resolutions to cancel leading-order error."
 ErrorEstimate = "Quantitative approximation of numerical error."
}

RELATIONS {
 NumericalCalculus --is_child_of--> ComputationalMathematicsOntologies
 NumericalDifferentiation --uses--> FiniteDifference
 FiniteDifference --uses--> StepSize
 CentralDifference --approximates--> Derivative
 RichardsonExtrapolation --improves--> DifferenceApproximation
 NumericalIntegration --uses--> Quadrature
 TrapezoidalRule --is_type_of--> NewtonCotesFormula
 SimpsonsRule --is_type_of--> NewtonCotesFormula
 GaussianQuadrature --uses--> WeightedNodes
 AdaptiveQuadrature --uses--> ErrorEstimate
 RombergIntegration --uses--> RichardsonExtrapolation
 MonteCarloIntegration --approximates--> MultidimensionalIntegral
 Interpolation --supports--> NumericalDifferentiation
 Interpolation --supports--> NumericalIntegration
 TruncationError --decreases_with--> ResolutionRefinement
 RoundOffError --can_increase_with--> ExcessiveRefinement
 Conditioning --influences--> NumericalSensitivity
 Verification --checks--> NumericalCalculusResult
}

OPERATORS {
 FORWARD_DIFFERENCE(f,x,h) := (f(x+h)-f(x))/h
 BACKWARD_DIFFERENCE(f,x,h) := (f(x)-f(x-h))/h
 CENTRAL_DIFFERENCE(f,x,h) := (f(x+h)-f(x-h))/(2*h)
 SECOND_CENTRAL_DIFFERENCE(f,x,h) := (f(x+h)-2*f(x)+f(x-h))/h^2
 TRAPEZOID(f,a,b) := (b-a)*(f(a)+f(b))/2
 MIDPOINT(f,a,b) := (b-a)*f((a+b)/2)
 SIMPSON(f,a,b) := (b-a)*(f(a)+4*f((a+b)/2)+f(b))/6
 QUADRATURE(f,nodes,weights) := sum_i weights_i*f(nodes_i)
 RICHARDSON(A_h,A_h2,p) := A_extrap=A_h2+(A_h2-A_h)/(2^p-1)
}

AXIOMS {
 A1 = "Numerical calculus approximates continuous calculus operations using finite computational representations."
 A2 = "Discretisation error and floating-point error are distinct."
 A3 = "Reducing step size does not always reduce total numerical error."
 A4 = "Higher-order methods require sufficient smoothness for their nominal convergence order."
 A5 = "Adaptive methods should refine where local error estimates indicate insufficient accuracy."
 A6 = "Quadrature accuracy depends on integrand smoothness, interval structure and node selection."
 A7 = "Numerical differentiation is typically more sensitive to noise and round-off than numerical integration."
 A8 = "Numerical calculus results require error, convergence and reproducibility validation."
}

REASONING {
 R1_CONTEXT = identify(operation,dimension,function_regularities,domain,data_type,accuracy_goal)
 R2_CLASSIFY = classify(differentiation,integration,gradient,Jacobian,Hessian_or_cumulative_operation)
 R3_METHOD = select(finite_difference,interpolation,Newton_Cotes,Gaussian,adaptive,Romberg,MonteCarlo_or_other_method)
 R4_RESOLUTION = choose(step_size,node_count,grid_spacing_or_sampling_budget)
 R5_COMPUTE = evaluate_discrete_calculus_approximation
 R6_ERROR = estimate(truncation_error,roundoff_error,quadrature_error_or_sampling_error)
 R7_ADAPT = if_needed refine_step_grid_nodes_or_sampling
 R8_CONVERGENCE = compare_successive_resolutions_and_estimate_order
 R9_STABILITY = assess(cancellation,conditioning,noise_sensitivity_and_floating_point_limits)
 R10_VALIDATE = compare(reference_solution,analytic_case,conservation_property_or_independent_method)
}

CONSTRAINTS {
 C1 = "Numerical differentiation can amplify data noise."
 C2 = "Very small finite-difference steps can increase cancellation and round-off error."
 C3 = "Newton-Cotes formulas of high degree can become numerically poor on equally spaced nodes."
 C4 = "Simpson's rule requires suitable subdivision structure in composite form."
 C5 = "Gaussian quadrature assumptions depend on the weight function and interval."
 C6 = "Improper or singular integrals can require transformations or specialised quadrature."
 C7 = "Oscillatory integrals may require specialised methods."
 C8 = "Monte Carlo convergence is generally slower in smooth low-dimensional problems but can scale favourably with dimension."
 C9 = "Adaptive error estimates can fail when integrand behaviour is poorly sampled."
 C10 = "Apparent convergence should be checked against finite-precision stagnation."
}

SEMANTIC_EQUIVALENCE {
 "NumericalCalculus" <=> "ComputationalCalculus"
 "NumericalIntegration" <=> "QuadratureInIntegralApproximationContext"
 "FiniteDifference" <=> "DifferenceApproximation"
 "SimpsonsRule" <=> "SimpsonRule"
 "GaussLegendreQuadrature" <=> "LegendreGaussianQuadrature"
 "CumulativeIntegration" <=> "NumericalAntiderivative"
}

VALIDATION {
 V1 = "Target derivative or integral is explicit."
 V2 = "Function domain and sampling assumptions are documented."
 V3 = "Step size, grid spacing or quadrature nodes are documented."
 V4 = "Method order and smoothness assumptions are documented."
 V5 = "Error estimates are reported."
 V6 = "Convergence under refinement is checked where feasible."
 V7 = "Round-off and cancellation are considered for differentiation."
 V8 = "Singular, oscillatory or improper behaviour is treated explicitly."
 V9 = "Reference or benchmark results are used where feasible."
 V10 = "Results are reproducible under documented arithmetic and method settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 NUMERICAL_CALCULUS_DEFINITION = 0.99
 DIFFERENTIATION_REASONING = 0.99
 QUADRATURE_REASONING = 0.99
 ADAPTIVE_INTEGRATION_REASONING = 0.99
 ERROR_ESTIMATION_REASONING = 0.99
 FLOATING_POINT_REASONING = 0.98
 MULTIDIMENSIONAL_INTEGRATION_REASONING = 0.98
 POLICY = "Reduce confidence when function regularity, step size, sampling density, quadrature assumptions, error estimates or arithmetic precision are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch, OntologyGrounding, NumericalCalculusReasoning,
  NumericalDifferentiationReasoning, FiniteDifferenceReasoning,
  NumericalIntegrationReasoning, QuadratureReasoning,
  GaussianQuadratureReasoning, AdaptiveQuadratureReasoning,
  RombergReasoning, RichardsonExtrapolationReasoning,
  GradientApproximationReasoning, JacobianApproximationReasoning,
  HessianApproximationReasoning, ErrorEstimationReasoning,
  ConvergenceReasoning, FloatingPointReasoning,
  MultidimensionalIntegrationReasoning, KnowledgeGraphConstruction,
  RetrievalAugmentation, RecursiveInference
 ]
 NORMALISE {
  "numerical calculus" -> NumericalCalculus
  "computational calculus" -> NumericalCalculus
  "numerical derivative" -> NumericalDifferentiation
  "numerical integration" -> NumericalIntegration
  "finite differences" -> FiniteDifference
  "Simpson rule" -> SimpsonsRule
 }
}

EXECUTION_RULES {
 E1 = "If a derivative or integral is approximated numerically, activate NumericalCalculus."
 E2 = "Classify whether the task is differentiation, integration or a higher-dimensional calculus operation."
 E3 = "Choose method order and resolution according to smoothness, cost and accuracy requirements."
 E4 = "For differentiation, balance truncation error against round-off and cancellation."
 E5 = "For integration, exploit smoothness, symmetry, weight functions and adaptivity where appropriate."
 E6 = "If the integrand is singular or oscillatory, use specialised transformations or quadrature."
 E7 = "If dimension is high, consider Monte Carlo, quasi-Monte Carlo or sparse-grid approaches."
 E8 = "Check convergence under refinement when feasible."
 E9 = "Validate numerical calculus results using error estimates, reference cases and reproducibility."
}

RECURSION {
 ENTRY = NumericalCalculus
 EXPAND(NumericalCalculus) -> [
  NumericalDifferentiation, NumericalIntegration, Quadrature,
  FiniteDifference, ForwardDifference, BackwardDifference,
  CentralDifference, HigherOrderDifference, DifferenceStencil,
  DerivativeApproximation, GradientApproximation, JacobianApproximation,
  HessianApproximation, RichardsonExtrapolation, StepSize,
  GridSpacing, Discretisation, TruncationError, RoundOffError,
  Cancellation, OptimalStepSize, NumericalIntegral, RiemannSum,
  MidpointRule, TrapezoidalRule, CompositeTrapezoidalRule,
  SimpsonsRule, CompositeSimpsonsRule, NewtonCotesFormula,
  GaussianQuadrature, GaussLegendreQuadrature, GaussHermiteQuadrature,
  GaussLaguerreQuadrature, GaussChebyshevQuadrature,
  AdaptiveQuadrature, AdaptiveSimpson, RombergIntegration,
  ClenshawCurtisQuadrature, SparseGridQuadrature,
  MultidimensionalQuadrature, Cubature, MonteCarloIntegration,
  QuasiMonteCarloIntegration, ImproperIntegral, SingularIntegral,
  OscillatoryIntegral, Interpolation, PolynomialInterpolation,
  SplineInterpolation, NumericalAntiderivative, CumulativeIntegration,
  ErrorEstimate, AbsoluteError, RelativeError, Convergence,
  ConvergenceRate, OrderOfAccuracy, Consistency, Stability,
  NumericalStability, Conditioning, FloatingPointArithmetic,
  MachinePrecision, Verification, Benchmarking, Reproducibility
 ]
 EXPAND(NumericalCalculusFamilies) -> [
  NumericalDifferentiation,
  FiniteDifferenceCalculus,
  NumericalIntegration,
  NewtonCotesQuadrature,
  GaussianQuadrature,
  AdaptiveQuadrature,
  MultidimensionalIntegration,
  ErrorAndConvergenceAnalysis
 ]
 STOP_CONDITION = "Stop when calculus operation, numerical method, resolution, error, convergence, stability and validation are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Computational Mathematics Ontologies"
 RELATED_ONTOLOGIES = [
  "Numerical Methods",
  "Numerical Analysis Ontology 2",
  "Numerical Approximation Ontology",
  "Numerical Error Ontology",
  "Numerical Stability Ontology 2",
  "Numerical Convergence Ontology",
  "Floating Point Arithmetic Ontology",
  "Scientific Computing Ontology 2",
  "Interpolation Ontologies",
  "Differential Equations Ontologies"
 ]
 ROUTE_RULES = [
  "Numerical Calculus -> Computational Mathematics for parent semantics",
  "Numerical Calculus -> Numerical Methods for approximation algorithms",
  "Numerical Calculus -> Numerical Analysis for consistency, convergence and stability",
  "Numerical Calculus -> Numerical Approximation for approximation theory",
  "Numerical Calculus -> Numerical Error for truncation and round-off semantics",
  "Numerical Calculus -> Floating Point Arithmetic for cancellation and precision limits",
  "Numerical Calculus -> Scientific Computing for applied computational calculus",
  "Numerical Calculus -> Interpolation for polynomial and spline-based derivative or integral approximation",
  "Numerical Calculus -> Differential Equations when derivative approximations define discretised differential operators"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible numerical calculus methods, quadrature families or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve differentiation-versus-integration distinction.",
  "Preserve truncation-error-versus-round-off-error distinction.",
  "Preserve local-step-versus-global-integral-error distinction.",
  "Preserve fixed-grid-versus-adaptive-method distinction.",
  "Preserve one-dimensional-versus-multidimensional integration distinction.",
  "Preserve deterministic-versus-stochastic integration distinction.",
  "Preserve symbolic-calculus-versus-numerical-calculus distinction.",
  "Preserve machine-readable numerical-calculus semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Numerical calculus approximates derivatives, integrals and related calculus operations using discrete computational methods."
 DIFFERENTIATION_SUMMARY = "Finite differences, interpolation and extrapolation approximate derivatives from sampled function values."
 INTEGRATION_SUMMARY = "Newton-Cotes, Gaussian and adaptive quadrature approximate definite integrals."
 ADAPTIVITY_SUMMARY = "Adaptive methods refine resolution where error estimates indicate insufficient accuracy."
 ERROR_SUMMARY = "Truncation, quadrature, sampling and round-off errors determine numerical reliability."
 HIGH_DIMENSION_SUMMARY = "Sparse grids, Monte Carlo and quasi-Monte Carlo methods extend numerical integration to higher dimensions."
 VALIDATION_SUMMARY = "Numerical calculus results should be checked through error estimates, refinement, reference cases, conditioning and reproducibility."
}

FLOW {
 INPUT
 -> detect_numerical_calculus_context
 -> identify_calculus_operation_dimension_function_regularity_domain_data_type_and_accuracy_goal
 -> classify_differentiation_integration_gradient_Jacobian_Hessian_or_related_operation
 -> select_finite_difference_interpolation_Newton_Cotes_Gaussian_adaptive_Romberg_MonteCarlo_or_other_method
 -> choose_step_size_grid_spacing_nodes_or_sampling_budget
 -> compute_numerical_calculus_approximation
 -> estimate_truncation_roundoff_quadrature_or_sampling_error
 -> refine_resolution_or_sampling_if_required
 -> assess_convergence_order_conditioning_noise_sensitivity_and_floating_point_limits
 -> validate_against_reference_solution_analytic_case_or_independent_method
 -> route_to_related_numerical_methods_analysis_approximation_error_stability_convergence_floating_point_scientific_computing_interpolation_or_differential_equations_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Numerical Calculus ontology defines computational approximation of derivatives and integrals. It supports numerical differentiation through forward, backward, central and higher-order finite differences, derivative stencils, gradient, Jacobian and Hessian approximation, Richardson extrapolation and optimal step-size reasoning; numerical integration through Riemann sums, midpoint, trapezoidal, Simpson and Newton-Cotes formulas, Gaussian quadrature, adaptive Simpson, Romberg and Clenshaw-Curtis methods, multidimensional cubature, sparse grids, Monte Carlo and quasi-Monte Carlo integration; as well as improper, singular and oscillatory integrals, interpolation-assisted calculus, cumulative integration, error estimation, convergence, conditioning, floating-point effects, verification, benchmarking and reproducibility."
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-COMPUTATIONAL-MATHEMATICS-NUMERICAL-CALCULUS-V1"
}

}

END_FLOW