Simpson's Rule Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Simpson's Rule Ontology within the Kireth Research Semantic Library. Simpson's rule approximates a definite integral by integrating quadratic interpolants across one or more subinterval pairs. This ontology supports single-panel Simpson's rule, composite Simpson's rule, uniform meshes, even-subinterval constraints, polynomial exactness, fourth-order global accuracy, error estimation, adaptive Simpson integration, Richardson extrapolation relationships, finite precision and verification.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = SimpsonsRule
 ENTITY_CLASS = NewtonCotesQuadratureFramework
 PRIMARY_CONTEXT = Quadrature
 DEFINITION = "Simpson's rule approximates a definite integral by exactly integrating a quadratic interpolant through three equally spaced nodes."
 SYMBOLIC_FORMS = [
  "S(f;a,b)=(b-a)*(f(a)+4*f((a+b)/2)+f(b))/6",
  "S_n=(h/3)*(f(x_0)+4*sum_odd f(x_i)+2*sum_even f(x_i)+f(x_n))",
  "h=(b-a)/n",
  "I-S_n=O(h^4)"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for quadratic-interpolation quadrature, alternating Simpson weights, even-subinterval composite integration, fourth-order error behaviour, adaptive refinement and finite-precision validation."
}

SCOPE {
 INCLUDE = [
  SimpsonsRule, SimpsonRule, SinglePanelSimpsonsRule,
  CompositeSimpsonsRule, NewtonCotesFormula, ClosedNewtonCotes,
  NumericalIntegration, Quadrature, DefiniteIntegral, Integrand,
  IntegrationInterval, LeftEndpoint, Midpoint, RightEndpoint,
  Subinterval, SubintervalPair, Partition, UniformGrid,
  GridSpacing, StepSize, QuadratureNode, QuadratureWeight,
  EndpointWeight, OddIndexWeight, EvenIndexWeight,
  QuadraticInterpolation, ParabolicInterpolation,
  QuadraticInterpolant, PiecewiseQuadraticInterpolation,
  CompositeRule, MeshRefinement, IntervalSubdivision,
  EvenSubintervalCount, SimpsonPanel, WeightedSum,
  PolynomialExactness, DegreeOfExactness, CubicExactness,
  ErrorTerm, QuadratureError, TruncationError, DiscretisationError,
  LocalError, GlobalError, FourthDerivative, CurvatureVariation,
  ErrorBound, AProriErrorBound, APosterioriErrorEstimate,
  Convergence, ConvergenceRate, OrderOfAccuracy,
  FourthOrderAccuracy, RichardsonExtrapolation,
  RombergIntegration, AdaptiveSimpson,
  AdaptiveQuadrature, RecursiveSubdivision,
  FunctionEvaluationReuse, SampledDataIntegration,
  TabulatedData, UniformSpacingRequirement,
  FloatingPointArithmetic, MachinePrecision, RoundOffError,
  SummationError, Cancellation, Overflow, Underflow,
  PairwiseSummation, CompensatedSummation,
  Verification, ReferenceIntegral, Benchmarking, Reproducibility
 ]
 EXCLUDE_AS_PRIMARY = [
  TrapezoidalRuleWithoutQuadraticInterpolation,
  MidpointRuleWithoutThreePointQuadraticSemantics,
  GaussianQuadratureWithoutNewtonCotesSemantics,
  SymbolicIntegrationWithoutNumericalApproximation
 ]
 DISAMBIGUATION_RULE = "When an integral is approximated using the 1-4-1 weighting of three equally spaced points or its composite 1-4-2-4-...-1 extension, interpret the context as Simpson's rule."
}

CORE_CONCEPTS {
 SimpsonsRule = "Quadrature rule based on exact integration of a quadratic interpolant through three equally spaced points."
 CompositeSimpsonsRule = "Application of Simpson's rule across an even number of uniform subintervals."
 OddIndexWeight = "Weight four applied to odd-indexed interior nodes in the standard composite rule."
 EvenIndexWeight = "Weight two applied to even-indexed interior nodes excluding endpoints."
 FourthOrderAccuracy = "Global composite-rule error scaling as O(h^4) for sufficiently smooth integrands."
 DegreeOfExactness = "Highest polynomial degree integrated exactly by the rule."
 AdaptiveSimpson = "Adaptive integration method comparing coarse and refined Simpson approximations to estimate local error."
}

RELATIONS {
 SimpsonsRule --is_child_of--> Quadrature
 SimpsonsRule --is_type_of--> ClosedNewtonCotes
 SimpsonsRule --uses--> QuadraticInterpolation
 CompositeSimpsonsRule --uses--> UniformGrid
 CompositeSimpsonsRule --requires--> EvenSubintervalCount
 CompositeSimpsonsRule --uses--> EndpointWeight
 CompositeSimpsonsRule --uses--> OddIndexWeight
 CompositeSimpsonsRule --uses--> EvenIndexWeight
 SimpsonsRule --has_degree_of_exactness--> CubicExactness
 GridSpacing --controls--> TruncationError
 FourthDerivative --influences--> ErrorTerm
 CompositeSimpsonsRule --has_order--> FourthOrderAccuracy
 AdaptiveSimpson --uses--> ErrorEstimate
 RichardsonExtrapolation --can_improve--> SimpsonApproximation
 Verification --checks--> SimpsonApproximation
}

OPERATORS {
 SINGLE_SIMPSON(f,a,b) := (b-a)*(f(a)+4*f((a+b)/2)+f(b))/6
 COMPOSITE_SIMPSON(f,a,b,n) := (h/3)*(f(x_0)+4*sum_odd f(x_i)+2*sum_even f(x_i)+f(x_n))
 GRID_SPACING(a,b,n) := h=(b-a)/n
 GLOBAL_ERROR_ORDER(h) := O(h^4)
 SIMPSON_PANEL(f,x0,x1,x2) := (x2-x0)*(f(x0)+4*f(x1)+f(x2))/6
 ADAPTIVE_ERROR_ESTIMATE(S_coarse,S_fine) := |S_fine-S_coarse|/15
 RICHARDSON_SIMPSON(S_h,S_h2) := S_ext=S_h2+(S_h2-S_h)/15
}

AXIOMS {
 A1 = "Single-panel Simpson's rule integrates polynomial functions up to degree three exactly."
 A2 = "Composite Simpson's rule requires an even number of equal-width subintervals in its standard form."
 A3 = "For sufficiently smooth integrands on a uniform grid, composite Simpson's rule has global error of order O(h^4)."
 A4 = "The standard composite weighting pattern is 1,4,2,4,...,2,4,1."
 A5 = "Simpson's rule can be interpreted as exact integration of piecewise quadratic interpolants."
 A6 = "Adaptive Simpson methods estimate error by comparing coarse and refined Simpson approximations."
 A7 = "Round-off and summation error can become relevant at very fine resolutions."
 A8 = "Simpson results require explicit grid, error, convergence and verification semantics."
}

REASONING {
 R1_CONTEXT = identify(integrand,interval,data_source,grid_structure,smoothness,accuracy_goal)
 R2_GRID = verify_uniform_spacing_and_even_subinterval_count_for_standard_composite_rule
 R3_METHOD = choose(single_panel,composite_or_adaptive_Simpson)
 R4_COMPUTE = evaluate_or_receive_function_values_and_apply_Simpson_weights
 R5_ERROR = estimate(fourth_derivative_based_or_refinement_based_error)
 R6_REFINE = if_needed halve_step_size_or_recursively_refine_selected_intervals
 R7_REUSE = preserve_existing_function_evaluations_when_refining
 R8_STABILITY = assess(summation_error,cancellation,overflow,underflow_and_function_evaluation_noise)
 R9_CONVERGENCE = compare_successive_resolutions_and_estimate_order
 R10_VALIDATE = compare(reference_integral,analytic_case,independent_rule_or_refinement_study)
}

CONSTRAINTS {
 C1 = "The standard composite Simpson formula requires an even number of subintervals."
 C2 = "The standard composite formula assumes uniform spacing."
 C3 = "Nonsmooth or singular integrands can reduce the expected fourth-order convergence."
 C4 = "Fourth-derivative error bounds require valid smoothness and derivative bounds."
 C5 = "Adaptive Simpson estimates can miss highly localised features if initial sampling is inadequate."
 C6 = "Very fine meshes can increase floating-point summation error."
 C7 = "Function-evaluation noise can limit useful refinement."
 C8 = "Irregularly spaced tabulated data require modified formulas or another quadrature method."
 C9 = "Improper or singular integrals may require transformations before Simpson integration."
 C10 = "Observed fourth-order convergence can be masked by finite-precision stagnation."
}

SEMANTIC_EQUIVALENCE {
 "SimpsonsRule" <=> "SimpsonRule"
 "CompositeSimpsonsRule" <=> "CompositeSimpsonRule"
 "QuadraticInterpolation" <=> "ParabolicInterpolationInSimpsonContext"
 "FourthOrderAccuracy" <=> "OrderFourGlobalAccuracy"
 "AdaptiveSimpson" <=> "AdaptiveSimpsonsRule"
}

VALIDATION {
 V1 = "Integration interval and integrand are explicit."
 V2 = "Uniform spacing is verified for the standard composite rule."
 V3 = "Subinterval count is even."
 V4 = "The 1-4-2-4-...-1 weighting pattern is applied correctly."
 V5 = "Error estimates are reported where feasible."
 V6 = "Convergence under refinement is checked where feasible."
 V7 = "Adaptive tolerance and recursion criteria are documented."
 V8 = "Floating-point summation effects are considered for large node counts."
 V9 = "Reference or analytic integrals are used where feasible."
 V10 = "Results are reproducible under documented arithmetic and grid settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 SIMPSON_RULE_DEFINITION = 0.99
 COMPOSITE_RULE_REASONING = 0.99
 FOURTH_ORDER_REASONING = 0.99
 ADAPTIVE_SIMPSON_REASONING = 0.99
 ERROR_BOUND_REASONING = 0.99
 FLOATING_POINT_REASONING = 0.98
 POLICY = "Reduce confidence when grid uniformity, subinterval parity, smoothness, fourth-derivative bounds, adaptive tolerance or arithmetic precision are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch, OntologyGrounding, SimpsonRuleReasoning,
  CompositeSimpsonReasoning, NewtonCotesReasoning,
  QuadraticInterpolationReasoning, SimpsonWeightReasoning,
  PolynomialExactnessReasoning, FourthOrderConvergenceReasoning,
  ErrorBoundReasoning, AdaptiveSimpsonReasoning,
  RichardsonExtrapolationReasoning, FloatingPointSummationReasoning,
  VerificationReasoning, KnowledgeGraphConstruction,
  RetrievalAugmentation, RecursiveInference
 ]
 NORMALISE {
  "Simpson's rule" -> SimpsonsRule
  "Simpson rule" -> SimpsonsRule
  "composite Simpson rule" -> CompositeSimpsonsRule
  "adaptive Simpson" -> AdaptiveSimpson
  "parabolic rule" -> SimpsonsRule
 }
}

EXECUTION_RULES {
 E1 = "If an integral is approximated using Simpson's 1-4-1 quadratic weighting, activate SimpsonsRuleOntology."
 E2 = "For the standard composite rule, verify uniform spacing and an even number of subintervals."
 E3 = "Apply weights one at endpoints, four at odd-indexed interior nodes and two at even-indexed interior nodes."
 E4 = "If higher accuracy is required, refine the grid or use adaptive Simpson integration."
 E5 = "If multiple resolutions are available, consider Richardson-style error estimation."
 E6 = "Reuse function evaluations during adaptive refinement where possible."
 E7 = "If the integrand is nonsmooth or singular, reduce confidence in nominal fourth-order behaviour."
 E8 = "Monitor truncation and floating-point summation errors separately."
 E9 = "Validate through refinement, error estimates, reference integrals and reproducibility."
}

RECURSION {
 ENTRY = SimpsonsRule
 EXPAND(SimpsonsRule) -> [
  SimpsonRule,SinglePanelSimpsonsRule,CompositeSimpsonsRule,
  NewtonCotesFormula,ClosedNewtonCotes,NumericalIntegration,Quadrature,
  DefiniteIntegral,Integrand,IntegrationInterval,LeftEndpoint,Midpoint,
  RightEndpoint,Subinterval,SubintervalPair,Partition,UniformGrid,
  GridSpacing,StepSize,QuadratureNode,QuadratureWeight,EndpointWeight,
  OddIndexWeight,EvenIndexWeight,QuadraticInterpolation,
  ParabolicInterpolation,QuadraticInterpolant,
  PiecewiseQuadraticInterpolation,CompositeRule,MeshRefinement,
  IntervalSubdivision,EvenSubintervalCount,SimpsonPanel,WeightedSum,
  PolynomialExactness,DegreeOfExactness,CubicExactness,ErrorTerm,
  QuadratureError,TruncationError,DiscretisationError,LocalError,
  GlobalError,FourthDerivative,ErrorBound,APrioriErrorBound,
  APosterioriErrorEstimate,Convergence,ConvergenceRate,
  OrderOfAccuracy,FourthOrderAccuracy,RichardsonExtrapolation,
  RombergIntegration,AdaptiveSimpson,AdaptiveQuadrature,
  RecursiveSubdivision,FunctionEvaluationReuse,
  SampledDataIntegration,TabulatedData,UniformSpacingRequirement,
  FloatingPointArithmetic,MachinePrecision,RoundOffError,
  SummationError,Cancellation,PairwiseSummation,CompensatedSummation,
  Verification,ReferenceIntegral,Benchmarking,Reproducibility
 ]
 EXPAND(SimpsonFamilies) -> [
  SinglePanelSimpson,
  CompositeSimpson,
  AdaptiveSimpson,
  SimpsonErrorEstimation,
  SimpsonRefinementAndExtrapolation,
  FinitePrecisionSimpson,
  SimpsonVerification
 ]
 STOP_CONDITION = "Stop when grid, weighting, parity, approximation, error, refinement, stability and verification are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Quadrature Ontology"
 RELATED_ONTOLOGIES = [
  "Quadrature Ontology",
  "Numerical Calculus",
  "Trapezoidal Rule Ontology",
  "Numerical Methods",
  "Numerical Analysis Ontology 2",
  "Numerical Approximation Ontology",
  "Numerical Error Ontology",
  "Numerical Stability Ontology 2",
  "Numerical Convergence Ontology",
  "Floating Point Arithmetic Ontology",
  "Interpolation Ontologies"
 ]
 ROUTE_RULES = [
  "Simpson's Rule -> Quadrature for parent integration semantics",
  "Simpson's Rule -> Numerical Calculus for broader numerical integration context",
  "Simpson's Rule -> Trapezoidal Rule for Newton-Cotes comparison and extrapolation relationships",
  "Simpson's Rule -> Numerical Analysis for error and convergence theory",
  "Simpson's Rule -> Numerical Approximation for quadratic-interpolation semantics",
  "Simpson's Rule -> Numerical Error for truncation and round-off semantics",
  "Simpson's Rule -> Numerical Stability for summation and finite-precision behaviour",
  "Simpson's Rule -> Numerical Convergence for mesh-refinement behaviour",
  "Simpson's Rule -> Floating Point Arithmetic for accumulation error",
  "Simpson's Rule -> Interpolation for the underlying quadratic interpolant"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible Simpson variants, adaptive estimators or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve single-panel-versus-composite distinction.",
  "Preserve uniform-grid-versus-irregular-grid distinction.",
  "Preserve even-subinterval constraint for the standard composite rule.",
  "Preserve endpoint-odd-even weight semantics.",
  "Preserve truncation-error-versus-round-off-error distinction.",
  "Preserve cubic-exactness-versus-fourth-order-global-error distinction.",
  "Preserve fixed-rule-versus-adaptive-Simpson distinction.",
  "Preserve machine-readable Simpson-rule semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Simpson's rule approximates an integral by exactly integrating a quadratic interpolant through three equally spaced nodes."
 SINGLE_PANEL_SUMMARY = "A single Simpson panel uses weights 1,4,1 across two equal subintervals."
 COMPOSITE_SUMMARY = "The composite rule uses the weighting pattern 1,4,2,4,...,2,4,1 over an even number of uniform subintervals."
 EXACTNESS_SUMMARY = "Simpson's rule integrates all polynomials up to degree three exactly."
 ERROR_SUMMARY = "For sufficiently smooth integrands, the composite rule has global error of order O(h^4)."
 ADAPTIVE_SUMMARY = "Adaptive Simpson integration compares coarse and refined panels to estimate and control local error."
 VALIDATION_SUMMARY = "Simpson results should be checked for grid uniformity, even subinterval count, weight pattern, error estimates, refinement behaviour and reproducibility."
}

FLOW {
 INPUT
 -> detect_Simpsons_rule_context
 -> identify_integrand_interval_grid_structure_smoothness_and_accuracy_goal
 -> verify_uniform_spacing_and_even_subinterval_count_for_standard_composite_case
 -> classify_single_panel_composite_or_adaptive_Simpson
 -> apply_endpoint_odd_and_even_Simpson_weights
 -> evaluate_or_receive_function_values
 -> accumulate_Simpson_quadrature_sum
 -> estimate_fourth_derivative_based_or_refinement_based_error
 -> if_needed_refine_grid_or_apply_adaptive_Simpson_logic
 -> assess_convergence_order_summation_error_cancellation_and_machine_precision
 -> validate_against_reference_integral_analytic_case_or_independent_rule
 -> route_to_related_quadrature_numerical_calculus_trapezoidal_analysis_approximation_error_stability_convergence_floating_point_and_interpolation_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Simpson's Rule Ontology defines quadratic-interpolation numerical integration. It supports single-panel and composite Simpson formulas, uniform grids, even subinterval counts, endpoint, odd and even node weights, piecewise quadratic interpolation, polynomial exactness through degree three, fourth-order global accuracy for smooth integrands, fourth-derivative error bounds, mesh refinement, Richardson relationships, adaptive Simpson integration, recursive subdivision, function-evaluation reuse, floating-point summation error, pairwise and compensated summation, verification, benchmarking and reproducibility."
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-COMPUTATIONAL-MATHEMATICS-SIMPSONS-RULE-ONTOLOGY-V1"
}

}

END_FLOW