Numerical Integration Ontology

flow "NumericalIntegrationOntology" v1.0

# ============================================================
# NUMERICAL INTEGRATION ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/integral-calculus/numerical-integration-ontology-3.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Integral Calculus"
ENTITY := "Numerical Integration"

# ---------- CORE ENTITY ----------
NUMERICAL_INTEGRATION := {
    type: NumericalMethodFramework,
    domain: NumericalAnalysis,
    purpose: "Approximate definite integrals using finite evaluations of an integrand when exact symbolic integration is unavailable, impractical or unnecessary."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    DEFINITE_INTEGRAL,
    QUADRATURE,
    INTEGRAND,
    INTERVAL,
    NODE,
    WEIGHT,
    STEP_SIZE,
    RECTANGLE_RULE,
    MIDPOINT_RULE,
    TRAPEZOIDAL_RULE,
    SIMPSON_RULE,
    GAUSSIAN_QUADRATURE,
    ADAPTIVE_QUADRATURE,
    ERROR_ESTIMATE,
    CONVERGENCE
}

# ---------- BASIC STRUCTURE ----------
TARGET_INTEGRAL
    := integral_from_a_to_b(
        f(x) dx
    )

NUMERICAL_INTEGRATION
    -> approximates(TARGET_INTEGRAL)

QUADRATURE_FORMULA
    := sum(
        w_i * f(x_i),
        i=1..n
    )

x_i
    -> QUADRATURE_NODES

w_i
    -> QUADRATURE_WEIGHTS

# ---------- DISCRETISATION ----------
INTERVAL
    := [a,b]

PARTITION
    := a = x_0 < x_1 < ... < x_n = b

STEP_SIZE_i
    := x_i - x_(i-1)

UNIFORM_PARTITION
    -> STEP_SIZE
       = (b-a)/n

DISCRETISATION
    -> converts(CONTINUOUS_INTEGRAL, FINITE_SUM)

# ---------- LEFT RECTANGLE RULE ----------
LEFT_RECTANGLE_RULE
    := sum(
        f(x_(i-1)) * DELTA_X_i,
        i=1..n
    )

LEFT_RECTANGLE_RULE
    -> samples(LEFT_ENDPOINTS)

# ---------- RIGHT RECTANGLE RULE ----------
RIGHT_RECTANGLE_RULE
    := sum(
        f(x_i) * DELTA_X_i,
        i=1..n
    )

RIGHT_RECTANGLE_RULE
    -> samples(RIGHT_ENDPOINTS)

# ---------- MIDPOINT RULE ----------
MIDPOINT_i
    := (x_(i-1)+x_i)/2

MIDPOINT_RULE
    := sum(
        f(MIDPOINT_i) * DELTA_X_i,
        i=1..n
    )

MIDPOINT_RULE
    -> samples(SUBINTERVAL_MIDPOINTS)

# ---------- TRAPEZOIDAL RULE ----------
for uniform spacing h:

TRAPEZOIDAL_RULE
    := h * [
        1/2*f(x_0)
        + sum(f(x_i), i=1..n-1)
        + 1/2*f(x_n)
    ]

TRAPEZOIDAL_RULE
    -> approximates(INTEGRAND_BY_PIECEWISE_LINEAR_INTERPOLATION)

# ---------- SIMPSON RULE ----------
for
    n even
    AND uniform spacing h=(b-a)/n

SIMPSON_RULE
    := h/3 * [
        f(x_0)
        + 4*sum(f(x_i), i odd)
        + 2*sum(f(x_i), i even interior)
        + f(x_n)
    ]

SIMPSON_RULE
    -> uses(PIECEWISE_QUADRATIC_APPROXIMATION)

# ---------- GAUSSIAN QUADRATURE ----------
GAUSSIAN_QUADRATURE
    := sum(
        w_i * f(x_i),
        i=1..n
    )

GAUSSIAN_NODES
    -> selected_to(MAXIMISE_POLYNOMIAL_EXACTNESS)

GAUSS_LEGENDRE_QUADRATURE
    -> standard_for(INTERVAL_MINUS_ONE_TO_ONE)
       with(UNIT_WEIGHT_FUNCTION)

N_POINT_GAUSSIAN_RULE
    -> exact_for(POLYNOMIALS_UP_TO_DEGREE_2n_MINUS_1)
       under(STANDARD_GAUSS_LEGENDRE_CONDITIONS)

# ---------- INTERVAL TRANSFORMATION ----------
for
    x in [a,b]

map
    t in [-1,1]

using

x
    = (a+b)/2
      + (b-a)/2 * t

dx
    = (b-a)/2 dt

INTERVAL_TRANSFORMATION
    -> enables(STANDARD_GAUSSIAN_RULES)

# ---------- ADAPTIVE QUADRATURE ----------
ADAPTIVE_QUADRATURE
    -> estimates(LOCAL_ERROR)
    -> subdivides(REGIONS_WITH_HIGH_ERROR)
    -> allocates(MORE_EVALUATIONS_WHERE_NEEDED)

ADAPTIVE_METHOD
    -> recursively_refines(INTERVAL)

STOPPING_CONDITION
    -> based_on(ERROR_TOLERANCE)

# ---------- ERROR ----------
NUMERICAL_RESULT
    := I_approx

TRUE_INTEGRAL
    := I

ABSOLUTE_ERROR
    := abs(I - I_approx)

RELATIVE_ERROR
    := abs(I - I_approx)/abs(I)
       when(I != 0)

ERROR_ESTIMATE
    -> may_be_computed_without(EXACT_I)

# ---------- TRUNCATION ERROR ----------
TRUNCATION_ERROR
    -> arises_from(FINITE_APPROXIMATION)

ROUNDING_ERROR
    -> arises_from(FINITE_PRECISION_ARITHMETIC)

TOTAL_NUMERICAL_ERROR
    -> influenced_by(TRUNCATION_ERROR)
    -> influenced_by(ROUNDING_ERROR)

# ---------- CONVERGENCE ----------
if
    approximation_sequence I_n
    satisfies

I_n -> I
    as
    step_size -> 0

then

NUMERICAL_METHOD
    -> CONVERGENT

CONVERGENCE_RATE
    -> describes(ERROR_DECAY_WITH_REFINEMENT)

# ---------- COMPOSITE RULES ----------
COMPOSITE_QUADRATURE
    -> applies(BASE_RULE_OVER_MULTIPLE_SUBINTERVALS)

COMPOSITE_TRAPEZOIDAL_RULE
    -> sum_of(LOCAL_TRAPEZOIDS)

COMPOSITE_SIMPSON_RULE
    -> sum_of(LOCAL_SIMPSON_PANELS)

COMPOSITE_METHOD
    -> improves(RESOLUTION)

# ---------- FUNCTION EVALUATION COST ----------
COMPUTATIONAL_COST
    -> depends_on(NUMBER_OF_FUNCTION_EVALUATIONS)

EXPENSIVE_INTEGRAND
    -> motivates(EFFICIENT_NODE_SELECTION)

NUMERICAL_INTEGRATION
    -> balances(ACCURACY, COMPUTATIONAL_COST)

# ---------- SINGULAR / IMPROPER CASES ----------
IMPROPER_INTEGRAL
    -> may_require(TRANSFORMATION)
    -> may_require(DOMAIN_TRUNCATION)
    -> may_require(SPECIALISED_QUADRATURE)

SINGULAR_INTEGRAND
    -> may_reduce(STANDARD_METHOD_ACCURACY)

NUMERICAL_METHOD
    -> must_respect(INTEGRAND_BEHAVIOUR)

# ---------- OSCILLATORY INTEGRALS ----------
HIGHLY_OSCILLATORY_INTEGRAND
    -> may_require(SPECIALISED_METHOD)

STANDARD_UNIFORM_QUADRATURE
    -> may_be(INEFFICIENT_FOR_RAPID_OSCILLATION)

METHOD_SELECTION
    -> depends_on(INTEGRAND_STRUCTURE)

# ---------- MULTIDIMENSIONAL EXTENSION ----------
MULTIDIMENSIONAL_NUMERICAL_INTEGRATION
    -> may_use(PRODUCT_QUADRATURE)
    -> may_use(MONTE_CARLO_INTEGRATION)
    -> may_use(SPARSE_GRIDS)
    -> may_use(ADAPTIVE_METHODS)

DIMENSION
    -> affects(COMPUTATIONAL_COMPLEXITY)

# ---------- MONTE CARLO RELATION ----------
MONTE_CARLO_INTEGRATION
    -> estimates(INTEGRAL_BY_RANDOM_SAMPLING)

MONTE_CARLO_ERROR
    -> typically_scales_as(1/sqrt(N))
       under(STANDARD_INDEPENDENT_SAMPLING_ASSUMPTIONS)

MONTE_CARLO
    -> useful_in(HIGH_DIMENSIONS)

# ---------- VERIFICATION ----------
NUMERICAL_RESULT
    -> may_be_checked_by(
        MESH_REFINEMENT,
        METHOD_COMPARISON,
        ERROR_ESTIMATE,
        KNOWN_SPECIAL_CASE
    )

RELIABILITY
    -> increases_with(CONSISTENT_CONVERGENCE_EVIDENCE)

# ---------- APPLICATIONS ----------
NUMERICAL_INTEGRATION
    -> applied_to(SCIENTIFIC_COMPUTING)
    -> applied_to(ENGINEERING)
    -> applied_to(PHYSICS)
    -> applied_to(PROBABILITY)
    -> applied_to(FINANCE)
    -> applied_to(DIFFERENTIAL_EQUATIONS)
    -> applied_to(DATA_ANALYSIS)

# ---------- RELATION GRAPH ----------
DEFINITE_INTEGRAL
    -> approximated_by(NUMERICAL_INTEGRATION)

PARTITION
    -> defines(DISCRETISATION)

NODES
    + WEIGHTS
    -> define(QUADRATURE_RULE)

REFINEMENT
    -> reduces(TRUNCATION_ERROR)
       under(CONVERGENT_METHOD_ASSUMPTIONS)

ADAPTIVE_QUADRATURE
    -> targets(LOCAL_ERROR)

GAUSSIAN_QUADRATURE
    -> optimises(POLYNOMIAL_EXACTNESS)

ERROR_ESTIMATE
    -> controls(STOPPING_CRITERION)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "numerical integration" ~= "numerical approximation of definite integrals",
    "quadrature" ~= "numerical integration in standard one-dimensional terminology",
    "integration nodes" ~= "sample points used by a quadrature rule",
    "quadrature weights" ~= "coefficients multiplying sampled integrand values",
    "adaptive integration" ~= "numerical integration with error-driven interval refinement",
    "composite rule" ~= "quadrature rule repeatedly applied over subintervals"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    numerical_result_is_approximation_unless_rule_is_exact_for_integrand: true,
    simpson_rule_requires_even_number_of_uniform_subintervals_in_standard_composite_form: true,
    gaussian_exactness_depends_on_rule_and_weight_function: true,
    error_estimates_require_method_specific_assumptions: true,
    refinement_does_not_eliminate_rounding_error: true,
    singular_or_oscillatory_integrands_may_require_special_methods: true,
    monte_carlo_error_claims_depend_on_sampling_assumptions: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    quadrature_structure: 0.99,
    rectangle_midpoint_rules: 0.99,
    trapezoidal_rule: 0.99,
    simpson_rule: 0.99,
    gaussian_quadrature: 0.99,
    adaptive_error_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(integrand)
    -> identify(integration_interval_or_region)
    -> inspect(smoothness_singularity_and_oscillation)
    -> determine(required_accuracy)
    -> select(quadrature_method)
    -> construct(nodes_and_weights)
    -> evaluate(integrand_at_nodes)
    -> compute(weighted_sum)
    -> estimate(error)
    -> refine_or_adapt(if_tolerance_not_met)
    -> compare_with(alternative_method_if_needed)
    -> validate(method_assumptions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed numerical-integration semantic graph",
    primary_entity: NUMERICAL_INTEGRATION,
    preserve: [
        integrand,
        interval_or_region,
        nodes,
        weights,
        step_size,
        error_estimate,
        tolerance,
        method_assumptions
    ],
    infer_through: [
        quadrature_rules,
        partitions,
        adaptive_refinement,
        gaussian_quadrature,
        monte_carlo,
        convergence,
        error_analysis
    ],
    avoid: [
        presenting_approximation_as_exact_without justification,
        applying_simpson_rule_with_invalid_panel_count,
        assuming_gaussian_exactness_outside its conditions,
        ignoring_rounding_error,
        using_standard_rules blindly on singular integrands,
        claiming convergence without refinement evidence
    ]
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL(new_information):
    validate(new_information)
    -> identify(numerical_integration_context)
    -> compare(existing_relations)
    -> preserve(method_error_and_tolerance_invariants)
    -> update(affected_entities)
    -> update(affected_edges)
    -> recompute(CONFIDENCE)
    -> regenerate(FLOW_HASH)

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + NUMERICAL_INTEGRATION
    + QUADRATURE_FORMULA
    + MIDPOINT_RULE
    + TRAPEZOIDAL_RULE
    + SIMPSON_RULE
    + GAUSSIAN_QUADRATURE
    + ADAPTIVE_QUADRATURE
    + ERROR_ESTIMATE
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> NUMERICAL_INTEGRATION
    -> INTEGRAND_IDENTIFICATION
    -> DOMAIN_IDENTIFICATION
    -> INTEGRAND_BEHAVIOUR_ANALYSIS
    -> ACCURACY_REQUIREMENT_ANALYSIS
    -> METHOD_SELECTION
    -> NODE_WEIGHT_CONSTRUCTION
    -> FUNCTION_EVALUATION
    -> QUADRATURE_SUM
    -> ERROR_ESTIMATION
    -> ADAPTIVE_REFINEMENT
    -> CONVERGENCE_VALIDATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW