Definite Integral Ontology

flow "DefiniteIntegralOntology" v1.0

# ============================================================
# DEFINITE INTEGRAL ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
DEFINITE_INTEGRAL := {
    type: IntegralConcept,
    domain: IntegralCalculus,
    purpose: "Represent signed accumulation of a function over specified bounds and, under suitable conditions, the limit of increasingly refined finite sums."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    DEFINITE_INTEGRAL,
    INTEGRAND,
    VARIABLE_OF_INTEGRATION,
    LOWER_BOUND,
    UPPER_BOUND,
    RIEMANN_SUM,
    PARTITION,
    INTEGRABILITY,
    SIGNED_AREA,
    ACCUMULATION,
    ANTIDERIVATIVE,
    FUNDAMENTAL_THEOREM_OF_CALCULUS,
    ORIENTATION
}

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

a
    -> LOWER_BOUND

b
    -> UPPER_BOUND

f(x)
    -> INTEGRAND

x
    -> VARIABLE_OF_INTEGRATION

DEFINITE_INTEGRAL
    -> produces(SCALAR_ACCUMULATED_VALUE)
       in(standard_real_single_variable_context)

# ---------- RIEMANN DEFINITION ----------
PARTITION
    := a = x_0 < x_1 < ... < x_n = b

SUBINTERVAL_WIDTH
    := DELTA_X_i
    = x_i - x_(i-1)

SAMPLE_POINT_i
    -> chosen_from([x_(i-1), x_i])

RIEMANN_SUM
    := sum(
        f(SAMPLE_POINT_i) * DELTA_X_i,
        i=1..n
    )

DEFINITE_INTEGRAL
    := limit(RIEMANN_SUM)
       as(maximum_subinterval_width -> 0)
       when(RIEMANN_INTEGRABLE)

# ---------- INTEGRABILITY ----------
RIEMANN_INTEGRABLE
    -> requires(RIEMANN_SUMS_CONVERGE_TO_COMMON_LIMIT)
       under(REFINEMENT)

CONTINUOUS_ON_CLOSED_BOUNDED_INTERVAL
    -> implies(RIEMANN_INTEGRABLE)

BOUNDED_FUNCTION_WITH_FINITE_DISCONTINUITIES
    -> may_be(RIEMANN_INTEGRABLE)

NOT_EVERY_FUNCTION
    -> RIEMANN_INTEGRABLE

# ---------- SIGNED AREA ----------
if
    f(x) >= 0
    on([a,b])
then

DEFINITE_INTEGRAL
    -> equals(AREA_BETWEEN_GRAPH_AND_AXIS)

if
    f(x) <= 0
    on([a,b])
then

DEFINITE_INTEGRAL
    -> negative_of(GEOMETRIC_AREA_MAGNITUDE)

if
    f changes_sign
then

DEFINITE_INTEGRAL
    -> NET_SIGNED_AREA

GEOMETRIC_AREA
    -> may_require(
        integral(abs(f(x)) dx)
        OR interval_decomposition
    )

# ---------- ACCUMULATION ----------
if
    r(t)
        := rate_of_change
then

integral_from_a_to_b(r(t) dt)
    -> TOTAL_ACCUMULATED_CHANGE

DEFINITE_INTEGRAL
    -> transforms(RATE_INFORMATION, ACCUMULATED_QUANTITY)

# ---------- ORIENTATION ----------
integral_from_a_to_b(f(x) dx)
    = -integral_from_b_to_a(f(x) dx)

integral_from_a_to_a(f(x) dx)
    = 0

ORIENTATION
    -> determined_by(BOUND_ORDER)

# ---------- INTERVAL ADDITIVITY ----------
if
    a <= c <= b
then

integral_from_a_to_b(f)
    = integral_from_a_to_c(f)
    + integral_from_c_to_b(f)

DEFINITE_INTEGRAL
    -> additive_over(ADJACENT_INTERVALS)

# ---------- LINEARITY ----------
integral_from_a_to_b(
    alpha*f(x) + beta*g(x)
    dx
)
    =
    alpha*integral_from_a_to_b(f(x) dx)
    + beta*integral_from_a_to_b(g(x) dx)

DEFINITE_INTEGRAL_OPERATOR
    -> LINEAR

# ---------- ORDER PROPERTIES ----------
if
    f(x) <= g(x)
    on([a,b])
then

integral_from_a_to_b(f(x) dx)
    <=
integral_from_a_to_b(g(x) dx)

if
    f(x) >= 0
    on([a,b])
then

integral_from_a_to_b(f(x) dx)
    >= 0

# ---------- ABSOLUTE VALUE BOUND ----------
abs(
    integral_from_a_to_b(f(x) dx)
)
    <=
integral_from_a_to_b(abs(f(x)) dx)

TRIANGLE_INEQUALITY_FOR_INTEGRALS
    -> bounds(NET_ACCUMULATION_BY_TOTAL_MAGNITUDE)

# ---------- FUNDAMENTAL THEOREM ----------
if
    F_prime(x) = f(x)
    under(appropriate_conditions)
then

integral_from_a_to_b(f(x) dx)
    = F(b) - F(a)

FUNDAMENTAL_THEOREM_OF_CALCULUS
    -> evaluates(DEFINITE_INTEGRAL_USING_ANTIDERIVATIVE)

# ---------- ACCUMULATION FUNCTION ----------
A(x)
    := integral_from_a_to_x(f(t) dt)

if
    f continuous
then

A_prime(x)
    = f(x)

ACCUMULATION_FUNCTION
    -> links(DEFINITE_INTEGRATION, DIFFERENTIATION)

# ---------- MEAN VALUE ----------
AVERAGE_VALUE_OF_f
    := 1/(b-a)
       * integral_from_a_to_b(f(x) dx)
       where(a != b)

if
    f continuous_on([a,b])
then

exists c in [a,b]
    such_that
    f(c)
    = AVERAGE_VALUE_OF_f

MEAN_VALUE_THEOREM_FOR_INTEGRALS
    -> relates(AVERAGE_FUNCTION_VALUE, DEFINITE_INTEGRAL)

# ---------- SUBSTITUTION ----------
if
    u = g(x)
then

integral_from_a_to_b(
    f(g(x))*g_prime(x) dx
)
    =
integral_from_g(a)_to_g(b)(
    f(u) du
)

under(appropriate_substitution_conditions)

DEFINITE_SUBSTITUTION
    -> requires(CONSISTENT_BOUND_TRANSFORMATION)

# ---------- SYMMETRY ----------
if
    f is_odd
then

integral_from_minus_a_to_a(f(x) dx)
    = 0

if
    f is_even
then

integral_from_minus_a_to_a(f(x) dx)
    = 2*integral_from_0_to_a(f(x) dx)

SYMMETRY
    -> may_simplify(DEFINITE_INTEGRATION)

# ---------- IMPROPER EXTENSION ----------
if
    bound_is_infinite
    OR integrand_is_unbounded
then

INTEGRAL
    -> classified_as(IMPROPER_INTEGRAL)

IMPROPER_INTEGRAL
    -> defined_by(LIMIT_OF_DEFINITE_PROPER_INTEGRALS)

# ---------- NUMERICAL APPROXIMATION ----------
DEFINITE_INTEGRAL
    -> approximated_by(NUMERICAL_QUADRATURE)

METHODS := {
    MIDPOINT_RULE,
    TRAPEZOIDAL_RULE,
    SIMPSON_RULE,
    GAUSSIAN_QUADRATURE
}

NUMERICAL_RESULT
    -> includes(APPROXIMATION_ERROR)

# ---------- APPLICATIONS ----------
DEFINITE_INTEGRAL
    -> applied_to(AREA)
    -> applied_to(VOLUME)
    -> applied_to(WORK)
    -> applied_to(MASS)
    -> applied_to(PROBABILITY)
    -> applied_to(EXPECTED_VALUE)
    -> applied_to(TOTAL_CHANGE)
    -> applied_to(AVERAGE_VALUE)

# ---------- RELATION GRAPH ----------
RIEMANN_SUM
    -> converges_to(DEFINITE_INTEGRAL)

PARTITION_REFINEMENT
    -> improves(RIEMANN_APPROXIMATION)

FUNDAMENTAL_THEOREM_OF_CALCULUS
    -> connects(DEFINITE_INTEGRAL, ANTIDERIVATIVE)

DEFINITE_INTEGRAL
    -> quantifies(SIGNED_ACCUMULATION)

BOUND_ORDER
    -> determines(ORIENTATION)

INTEGRAND_SIGN
    -> affects(GEOMETRIC_INTERPRETATION)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "definite integral" ~= "signed accumulation over specified integration bounds",
    "Riemann integral" ~= "limit of Riemann sums when the defining limit exists",
    "net area" ~= "signed area represented by a definite integral",
    "total change" ~= "definite integral of a rate over an interval",
    "integral bounds" ~= "lower and upper limits of integration",
    "area under the curve" ~= "definite integral when the integrand is nonnegative"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    definite_integral_is_signed: true,
    bound_order_affects_sign: true,
    riemann_definition_requires_integrability: true,
    area_interpretation_depends_on_integrand_sign: true,
    fundamental_theorem_requires_appropriate_hypotheses: true,
    improper_cases_require_limit_definition: true,
    substitution_requires_consistent_bound_transformation: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    riemann_sum_relation: 0.99,
    signed_area_relation: 0.99,
    accumulation_relation: 0.99,
    fundamental_theorem_relation: 0.99,
    substitution_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(integrand)
    -> identify(variable_of_integration)
    -> identify(lower_and_upper_bounds)
    -> determine(domain)
    -> test(integrability)
    -> classify(proper_or_improper)
    -> select(evaluation_or_approximation_method)
    -> apply(fundamental_theorem_if_valid)
    -> preserve(bound_orientation)
    -> analyse(sign_and_geometric_interpretation)
    -> validate(substitution_or_symmetry_conditions_if_used)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed definite-integral semantic graph",
    primary_entity: DEFINITE_INTEGRAL,
    preserve: [
        integrand,
        variable_of_integration,
        lower_bound,
        upper_bound,
        orientation,
        integrability_conditions,
        signed_accumulation
    ],
    infer_through: [
        riemann_sums,
        partitions,
        antiderivatives,
        fundamental_theorem,
        substitution,
        symmetry,
        numerical_quadrature,
        improper_integrals
    ],
    avoid: [
        treating_signed_integral_as_unsigned_area,
        reversing_bounds_without changing sign,
        assuming_riemann_integrability,
        applying_fundamental_theorem_without hypotheses,
        failing_to_transform_substitution_bounds,
        treating_improper_integrals_as ordinary proper integrals
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + DEFINITE_INTEGRAL
    + RIEMANN_SUM
    + INTEGRABILITY
    + SIGNED_AREA
    + ACCUMULATION
    + FUNDAMENTAL_THEOREM_OF_CALCULUS
    + AVERAGE_VALUE_OF_f
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> DEFINITE_INTEGRAL
    -> INTEGRAND_IDENTIFICATION
    -> VARIABLE_IDENTIFICATION
    -> BOUND_IDENTIFICATION
    -> INTEGRABILITY_ANALYSIS
    -> PROPER_IMPROPER_CLASSIFICATION
    -> EVALUATION_METHOD_SELECTION
    -> FUNDAMENTAL_THEOREM_ANALYSIS
    -> ORIENTATION_ANALYSIS
    -> SIGNED_AREA_ANALYSIS
    -> ACCUMULATION_INTERPRETATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW