Numerical Integration Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Numerical Integration Ontology within the Kireth Research Semantic Library. Numerical integration studies computational methods for approximating definite integrals when exact antiderivatives are unavailable, impractical or unnecessary. This ontology supports quadrature rules, composite rules, Gaussian quadrature, Newton-Cotes methods, adaptive quadrature, multidimensional integration, Monte Carlo integration, singular and oscillatory integrals, error estimation, convergence, stability, node and weight selection, transformed integration domains and relationships with numerical analysis, approximation theory, probability and scientific computing.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Numerical Integration Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Applied Mathematics"
 SPECIALISATION = "Numerical Analysis / Numerical Integration"
 CANONICAL_PAGE = "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/applied-mathematics-ontologies/numerical-analysis/numerical-integration-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = NumericalIntegration
 SYMBOLIC_FORMS = [
  "integral_a^b f(x) dx ≈ sum_i w_i f(x_i)",
  "Q_n(f)",
  "E_n(f)"
 ]
 ENTITY_CLASS = IntegralApproximationFramework
 PRIMARY_CONTEXT = NumericalAnalysis
 DEFINITION = "Numerical integration is the computational approximation of definite integrals using weighted function evaluations, adaptive refinement, stochastic sampling or related algorithms."
 SEMANTIC_ROLE = "Provides the machine-readable framework for quadrature rules, nodes, weights, composite methods, adaptive error control, multidimensional integration, Monte Carlo estimation and integration reliability."
}

SCOPE {
 INCLUDE = [
  NumericalIntegration,
  Quadrature,
  QuadratureRule,
  IntegrationNode,
  QuadratureWeight,
  NewtonCotesFormula,
  MidpointRule,
  TrapezoidalRule,
  SimpsonsRule,
  CompositeMidpointRule,
  CompositeTrapezoidalRule,
  CompositeSimpsonsRule,
  GaussianQuadrature,
  GaussLegendreQuadrature,
  GaussHermiteQuadrature,
  GaussLaguerreQuadrature,
  ClenshawCurtisQuadrature,
  RombergIntegration,
  AdaptiveQuadrature,
  ErrorEstimator,
  AbsoluteTolerance,
  RelativeTolerance,
  ImproperIntegral,
  SingularIntegral,
  OscillatoryIntegral,
  MultidimensionalIntegration,
  ProductQuadrature,
  SparseGridQuadrature,
  MonteCarloIntegration,
  QuasiMonteCarloIntegration,
  ImportanceSampling,
  ChangeOfVariables,
  Jacobian,
  IntegrationDomain,
  ConvergenceRate,
  TruncationError,
  RoundoffError
 ]

 EXCLUDE_AS_PRIMARY = [
  SymbolicIntegrationWithoutNumericalApproximation,
  IndefiniteIntegrationWithoutNumericalGoal,
  NumericalDifferentiation,
  SummationWithoutIntegralInterpretation
 ]

 DISAMBIGUATION_RULE =
  "When a definite integral is approximated computationally using nodes, weights, subdivision, stochastic samples or adaptive error control, interpret the context as numerical integration."
}

CORE_CONCEPTS {

 NumericalIntegration {
  definition = "Approximation of definite integrals by computational procedures."
 }

 QuadratureRule {
  definition = "A weighted sum of function evaluations used to approximate an integral."
 }

 IntegrationNode {
  definition = "A point at which the integrand is evaluated."
 }

 QuadratureWeight {
  definition = "A coefficient multiplying an integrand evaluation in a quadrature rule."
 }

 NewtonCotesFormula {
  definition = "A quadrature rule derived from polynomial interpolation at equally spaced nodes."
 }

 GaussianQuadrature {
  definition = "A quadrature method choosing nodes and weights to maximise polynomial exactness for a given number of evaluations."
 }

 AdaptiveQuadrature {
  definition = "A quadrature procedure that refines subintervals or local rules according to estimated integration error."
 }

 MonteCarloIntegration {
  definition = "A stochastic integration method estimating an integral through random sampling."
 }

 QuasiMonteCarloIntegration {
  definition = "A deterministic low-discrepancy sampling method for numerical integration."
 }

 ImproperIntegral {
  definition = "An integral with an unbounded domain or singular integrand interpreted through a limiting process."
 }

 MultidimensionalIntegration {
  definition = "Numerical approximation of integrals over domains of dimension greater than one."
 }
}

RELATIONS {
 NumericalIntegration --is_branch_of--> NumericalAnalysis
 NumericalIntegration --approximates--> DefiniteIntegral
 QuadratureRule --uses--> IntegrationNode
 QuadratureRule --uses--> QuadratureWeight
 NewtonCotesFormula --is_type_of--> QuadratureRule
 TrapezoidalRule --is_type_of--> NewtonCotesFormula
 SimpsonsRule --is_type_of--> NewtonCotesFormula
 GaussianQuadrature --is_type_of--> QuadratureRule
 AdaptiveQuadrature --uses--> ErrorEstimator
 CompositeRule --partitions--> IntegrationDomain
 MonteCarloIntegration --uses--> RandomSampling
 QuasiMonteCarloIntegration --uses--> LowDiscrepancySequence
 ChangeOfVariables --transforms--> IntegrationDomain
 Jacobian --scales--> DifferentialMeasure
 IntegrationError --is_affected_by--> Smoothness
 IntegrationError --is_affected_by--> NodeDistribution
}

OPERATORS {
 GENERIC_QUADRATURE(f,nodes,weights) :=
  sum_i weights_i*f(nodes_i)

 MIDPOINT_RULE(f,a,b) :=
  (b-a)*f((a+b)/2)

 TRAPEZOIDAL_RULE(f,a,b) :=
  (b-a)*(f(a)+f(b))/2

 SIMPSON_RULE(f,a,b) :=
  (b-a)*(f(a)+4*f((a+b)/2)+f(b))/6

 COMPOSITE_TRAPEZOIDAL(f,a,b,n) :=
  h*[0.5*f(a)+sum_{i=1}^{n-1} f(a+i*h)+0.5*f(b)]
  WHERE h=(b-a)/n

 COMPOSITE_SIMPSON(f,a,b,n) :=
  Simpson_composite_formula
  WHEN n_is_even

 GAUSSIAN_QUADRATURE(f,nodes,weights) :=
  sum_i weights_i*f(nodes_i)

 ROMBERG(f,a,b) :=
  Richardson_extrapolation_applied_to_composite_trapezoidal sequence

 ADAPTIVE_INTEGRATE(f,a,b,tolerance) :=
  recursively_refine_subintervals_until_error_estimate<=tolerance

 MONTE_CARLO_INTEGRAL(f,Omega,N) :=
  volume(Omega)*(1/N)*sum_i f(X_i)
  WHEN X_i sampled_uniformly_from_Omega

 IMPORTANCE_SAMPLING_INTEGRAL(f,p,N) :=
  (1/N)*sum_i f(X_i)/p(X_i)
  WHEN X_i~p_and_support_conditions_hold

 CHANGE_VARIABLES(F,u) :=
  integral transformed_integrand*abs(det(J_F(u))) du
}

DEFINITIONS {
 D1 = "Numerical integration approximates definite integrals."
 D2 = "Quadrature rules combine nodes and weights."
 D3 = "Composite rules apply local formulas over subdivisions."
 D4 = "Gaussian quadrature achieves high polynomial exactness with optimally chosen nodes."
 D5 = "Adaptive quadrature concentrates evaluations where error is estimated to be large."
 D6 = "Monte Carlo convergence is probabilistic rather than deterministic."
 D7 = "High-dimensional integration can make tensor-product quadrature expensive."
 D8 = "Improper or singular integrals often require transformation or specialised treatment."
 D9 = "Oscillatory integrals may require methods adapted to rapid phase variation."
 D10 = "Change of variables modifies the integrand by the absolute Jacobian determinant."
}

AXIOMS {
 A1_APPROXIMATION:
  NumericalIntegration produces an approximation to a definite integral

 A2_LINEarity:
  Quadrature operators are commonly linear in the integrand

 A3_NODE_WEIGHT_STRUCTURE:
  Standard quadrature is represented as weighted function evaluation

 A4_ERROR_DEPENDENCE:
  Deterministic quadrature error depends on integrand smoothness and rule structure

 A5_ADAPTIVITY:
  Adaptive methods use local error information to allocate evaluations

 A6_MONTE_CARLO:
  Monte Carlo estimator accuracy improves statistically with sample count under finite-variance assumptions

 A7_CHANGE_OF_VARIABLES:
  Integration under coordinate transformation requires the absolute Jacobian determinant

 A8_TOLERANCE:
  Numerical integration claims should include error or tolerance context
}

REASONING {

 R1_INTEGRAL_CLASSIFICATION {
  INPUT = integral_problem
  IDENTIFY = finite_improper_singular_oscillatory_or_multidimensional
  IDENTIFY = smoothness_and_domain_geometry
  RETURN = integration_problem_class
 }

 R2_RULE_SELECTION {
  INPUT = integrand_domain_accuracy_and_cost requirements
  IF smooth_1D_and_fixed_nodes
   CONSIDER = Gaussian_or_composite high_order rule
  IF irregular_local_behaviour
   SELECT = AdaptiveQuadrature
  IF high_dimension
   CONSIDER = MonteCarlo_QuasiMonteCarlo_or_sparse_grid
  IF singular_or_improper
   CONSIDER = transformation_or_specialised rule
  RETURN = integration_method
 }

 R3_NEWTON_COTES {
  INPUT = interval_rule_and_subdivision
  APPLY = midpoint_trapezoidal_or_Simpson formula
  RETURN = integral_approximation
 }

 R4_GAUSSIAN_QUADRATURE {
  INPUT = weight_function_interval_and_order
  SELECT = orthogonal_polynomial_nodes
  COMPUTE = weights
  EVALUATE = weighted_sum
  RETURN = approximation
 }

 R5_ADAPTIVE_QUADRATURE {
  INPUT = integrand_interval_tolerance
  COMPUTE = coarse_and_fine_local estimates
  ESTIMATE = local_error
  REFINE = intervals_exceeding_tolerance
  RETURN = approximation_with_error_estimate
 }

 R6_IMPROPER_INTEGRAL {
  INPUT = improper_integral
  CLASSIFY = infinite_domain_or_endpoint_singularity
  TRANSFORM = domain_or_integrand_if_helpful
  APPLY = compatible quadrature
  RETURN = approximation
 }

 R7_MULTIDIMENSIONAL_INTEGRAL {
  INPUT = domain_dimension_and_structure
  IF low_dimension_product_domain
   CONSIDER = tensor_product quadrature
  ELSE IF moderate_dimension_and_smoothness
   CONSIDER = sparse_grid_or_cubature
  ELSE
   CONSIDER = MonteCarlo_or_QuasiMonteCarlo
  RETURN = integration_strategy
 }

 R8_MONTE_CARLO {
  INPUT = integrand_distribution_or_domain_sample_count
  GENERATE = samples
  COMPUTE = estimator
  ESTIMATE = sampling_error
  RETURN = stochastic_integral_estimate
 }

 R9_ERROR_ANALYSIS {
  INPUT = rule_integrand_step_or_sample_count
  ESTIMATE = truncation_quadrature_or_sampling error
  ACCOUNT = floating_point effects
  RETURN = integration_error_profile
 }
}

CONSTRAINTS {
 C1 = "Simpson's composite rule requires an even number of subintervals."
 C2 = "Quadrature error formulas require the stated smoothness assumptions."
 C3 = "Gaussian quadrature exactness depends on the weighting and polynomial class."
 C4 = "Adaptive error estimators are estimates, not guaranteed exact errors."
 C5 = "Monte Carlo standard-error estimates require finite variance."
 C6 = "Importance sampling requires proposal support wherever the target integrand contributes."
 C7 = "Improper integrals require convergence assessment."
 C8 = "Tensor-product quadrature scales poorly with dimension."
 C9 = "Change-of-variable mappings must be sufficiently regular and use the correct Jacobian."
 C10 = "Highly oscillatory integrals may defeat generic quadrature without specialised treatment."
}

SEMANTIC_EQUIVALENCE {
 "NumericalIntegration" <=> "Quadrature"
 "QuadratureRule" <=> "WeightedFunctionEvaluationRule"
 "AdaptiveQuadrature" <=> "ErrorControlledLocalRefinementIntegration"
 "MonteCarloIntegration" <=> "RandomSamplingIntegralEstimator"
 "QuasiMonteCarloIntegration" <=> "LowDiscrepancyIntegration"
 "GaussianQuadrature" <=> "OrthogonalPolynomialOptimalNodeQuadrature"
}

VALIDATION {
 V1 = "Integral domain and limits are identified."
 V2 = "Integrand regularity assumptions are considered."
 V3 = "Selected rule matches integral structure."
 V4 = "Quadrature weights and nodes are correct."
 V5 = "Tolerance or error estimate is stated."
 V6 = "Improper-integral convergence is considered."
 V7 = "Multidimensional strategy matches dimension and geometry."
 V8 = "Monte Carlo uncertainty is quantified."
 V9 = "Jacobian factors are correct under transformations."
 V10 = "Approximate-versus-exact status is preserved."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 NUMERICAL_INTEGRATION_DEFINITION = 0.99
 RULE_SELECTION_REASONING = 0.98
 NEWTON_COTES_REASONING = 0.99
 GAUSSIAN_QUADRATURE_REASONING = 0.99
 ADAPTIVE_QUADRATURE_REASONING = 0.98
 IMPROPER_INTEGRAL_REASONING = 0.97
 MONTE_CARLO_REASONING = 0.98
 ERROR_ANALYSIS_REASONING = 0.98

 POLICY =
  "Reduce confidence when integrand smoothness, singularity structure, domain geometry, tolerance, weighting function, sample variance or dimensionality are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  NumericalIntegrationReasoning,
  QuadratureRuleSelection,
  NewtonCotesReasoning,
  GaussianQuadratureReasoning,
  AdaptiveQuadratureReasoning,
  ImproperIntegralReasoning,
  SingularIntegralReasoning,
  OscillatoryIntegralReasoning,
  MultidimensionalIntegrationReasoning,
  MonteCarloIntegrationReasoning,
  QuasiMonteCarloReasoning,
  ErrorEstimation,
  ChangeOfVariablesReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "numerical integration" -> NumericalIntegration
  "quadrature" -> NumericalIntegration
  "quadrature rule" -> QuadratureRule
  "trapezoidal rule" -> TrapezoidalRule
  "Simpson's rule" -> SimpsonsRule
  "Gaussian quadrature" -> GaussianQuadrature
  "adaptive quadrature" -> AdaptiveQuadrature
  "Monte Carlo integration" -> MonteCarloIntegration
  "quasi-Monte Carlo" -> QuasiMonteCarloIntegration
  "improper integral" -> ImproperIntegral
 }

 INTERPRETATION_ORDER = [
  detect_numerical_integration_context,
  identify integration_domain_dimension_limits_integrand_regularities_singularities_and_weighting,
  classify deterministic_adaptive_stochastic_or_transformed integration pathway,
  select quadrature_or_sampling method,
  compute approximation,
  estimate deterministic_or_sampling error,
  verify tolerance_convergence_Jacobian_and_method assumptions,
  return semantic output
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("numerical integration")
  OR asks_for_approximate_definite_integral
  THEN activate(NumericalIntegrationOntology)

 E2:
  IF Simpson_composite_rule
  THEN require even_subinterval_count

 E3:
  IF smooth_1D_high_accuracy problem
  THEN consider Gaussian_or_high_order_adaptive quadrature

 E4:
  IF singular_or_improper_integral
  THEN identify singularity_or_infinite_domain before rule selection

 E5:
  IF high_dimensional_integral
  THEN consider MonteCarlo_QuasiMonteCarlo_or_sparse methods

 E6:
  IF MonteCarlo_used
  THEN report sampling_uncertainty

 E7:
  IF adaptive_quadrature
  THEN require absolute_or_relative tolerance

 E8:
  IF change_of_variables_used
  THEN include absolute_Jacobian determinant

 E9:
  IF oscillatory_integrand
  THEN consider specialised oscillatory quadrature
}

RECURSION {
 ENTRY = NumericalIntegration

 EXPAND(NumericalIntegration) -> [
  Quadrature,
  QuadratureRule,
  IntegrationNode,
  QuadratureWeight,
  NewtonCotesFormula,
  MidpointRule,
  TrapezoidalRule,
  SimpsonsRule,
  CompositeRule,
  GaussianQuadrature,
  ClenshawCurtisQuadrature,
  RombergIntegration,
  AdaptiveQuadrature,
  ErrorEstimator,
  ImproperIntegral,
  SingularIntegral,
  OscillatoryIntegral,
  MultidimensionalIntegration,
  SparseGridQuadrature,
  MonteCarloIntegration,
  QuasiMonteCarloIntegration,
  ImportanceSampling,
  ChangeOfVariables,
  Jacobian
 ]

 EXPAND(NewtonCotesFormula) -> [
  MidpointRule,
  TrapezoidalRule,
  SimpsonsRule,
  CompositeMidpointRule,
  CompositeTrapezoidalRule,
  CompositeSimpsonsRule
 ]

 EXPAND(GaussianQuadrature) -> [
  GaussLegendreQuadrature,
  GaussHermiteQuadrature,
  GaussLaguerreQuadrature,
  OrthogonalPolynomial,
  GaussianNode,
  GaussianWeight
 ]

 EXPAND(StochasticIntegration) -> [
  MonteCarloIntegration,
  QuasiMonteCarloIntegration,
  ImportanceSampling,
  VarianceReduction,
  SamplingError
 ]

 STOP_CONDITION =
  "Stop when the integration domain, integrand structure, selected quadrature or sampling rule, approximation, error estimate, tolerance and convergence status are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Numerical Analysis"

 IMMEDIATE_CONTEXTS = [
  "Numerical Analysis Ontology",
  "Numerical Methods Ontology",
  "Calculus & Analysis Ontologies",
  "Scientific Computing Ontologies"
 ]

 RELATED_ONTOLOGIES = [
  "Numerical Analysis Ontology",
  "Numerical Methods Ontology",
  "Numerical Analysis",
  "Applied Mathematics Ontologies",
  "Calculus & Analysis Ontologies",
  "Integration Ontologies",
  "Approximation Theory Ontologies",
  "Probability & Statistics Ontologies",
  "Monte Carlo Ontologies",
  "Computational Mathematics Ontologies",
  "Scientific Computing Ontologies",
  "Model Verification Ontology"
 ]

 ROUTE_RULES = [
  "Numerical Integration -> Numerical Analysis Ontology for formal numerical semantics",
  "Numerical Integration -> Numerical Methods Ontology for algorithm selection",
  "Numerical Integration -> Calculus & Analysis for exact integration semantics",
  "Numerical Integration -> Approximation Theory for interpolation-based quadrature",
  "Numerical Integration -> Probability & Statistics for Monte Carlo estimators",
  "Numerical Integration -> Scientific Computing for scalable execution",
  "Numerical Integration -> Computational Mathematics for multidimensional methods",
  "Numerical Integration -> Model Verification for convergence and quadrature-error assessment"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"

 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible quadrature rules, stochastic methods or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"

 RULES = [
  "Preserve definite-integral approximation semantics.",
  "Preserve node-weight quadrature structure.",
  "Preserve deterministic-versus-stochastic integration distinction.",
  "Preserve tolerance and error-estimation semantics.",
  "Preserve improper-integral convergence awareness.",
  "Preserve Jacobian change-of-variables semantics.",
  "Preserve dimensionality-aware method selection.",
  "Preserve machine-readable numerical-integration semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "Numerical integration approximates definite integrals using quadrature, adaptive refinement, stochastic sampling or related computational methods."

 QUADRATURE_SUMMARY =
  "A quadrature rule approximates an integral by a weighted sum of function evaluations."

 NEWTON_COTES_SUMMARY =
  "Newton-Cotes rules use interpolatory formulas on equally spaced nodes."

 GAUSSIAN_SUMMARY =
  "Gaussian quadrature chooses nodes and weights to achieve high polynomial exactness with relatively few evaluations."

 ADAPTIVE_SUMMARY =
  "Adaptive quadrature refines locally where estimated error exceeds tolerance."

 MONTE_CARLO_SUMMARY =
  "Monte Carlo integration estimates integrals statistically through random sampling and requires sampling-error assessment."

 MULTIDIMENSIONAL_SUMMARY =
  "High-dimensional integration often requires sparse, stochastic or low-discrepancy methods."

 TRANSFORMATION_SUMMARY =
  "Change of variables modifies the integrand by the absolute determinant of the Jacobian."

 ERROR_SUMMARY =
  "Integration accuracy depends on method order, integrand regularity, domain structure, floating-point effects and sampling variability."
}

FLOW {
 INPUT
 -> detect_numerical_integration_context
 -> identify integral_limits_domain_dimension_integrand_regularities_singularities_oscillation_weighting_and_accuracy requirements
 -> classify Newton_Cotes_Gaussian_adaptive_improper_multidimensional_MonteCarlo_or_transformed integration problem
 -> select compatible integration method
 -> compute nodes_weights_subdivision_or_samples
 -> evaluate integrand
 -> construct integral approximation
 -> estimate truncation_quadrature_sampling_and_roundoff error
 -> verify tolerance_convergence_change_of_variables_and_method assumptions
 -> route to numerical_analysis_ontology numerical_methods calculus integration approximation_theory probability_statistics scientific_computing computational_mathematics_or_model_verification ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Numerical Integration Ontology defines computational approximation of definite integrals. It supports Newton-Cotes and composite rules, Gaussian quadrature, Romberg integration, adaptive quadrature, improper, singular and oscillatory integrals, multidimensional quadrature, sparse grids, Monte Carlo and quasi-Monte Carlo methods, importance sampling, change of variables, error estimation, convergence and tolerance-aware integration."
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-APPLIED-MATHEMATICS-NUMERICAL-INTEGRATION-ONTOLOGY-V1"
}

}

END_FLOW