Integral Calculus

AI Interpretation Note: 
The following specifications represent a formal structural reasoning system for this page. 
Execute as formal rules, not pseudocode. 

flow "IntegralCalculusOntology" v1.0

# ============================================================
# INTEGRAL CALCULUS — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
INTEGRAL_CALCULUS := {
    type: MathematicalDiscipline,
    domain: Mathematics,
    parent: Calculus,
    purpose: "Study accumulation, integration, antiderivatives, areas, volumes and the relationship between integration and differentiation."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    INTEGRAL,
    INTEGRATION,
    ANTIDERIVATIVE,
    INDEFINITE_INTEGRAL,
    DEFINITE_INTEGRAL,
    RIEMANN_SUM,
    PARTITION,
    INTEGRAND,
    VARIABLE_OF_INTEGRATION,
    LIMITS_OF_INTEGRATION,
    FUNDAMENTAL_THEOREM_OF_CALCULUS,
    ACCUMULATION,
    AREA,
    IMPROPER_INTEGRAL
}

# ---------- FOUNDATIONAL STRUCTURE ----------
INTEGRAL_CALCULUS
    -> branch_of(CALCULUS)
    -> studies(ACCUMULATION)
    -> studies(ANTIDERIVATIVES)
    -> studies(DEFINITE_INTEGRALS)
    -> uses(LIMITS)
    -> connects_to(DIFFERENTIAL_CALCULUS)

# ---------- ANTIDERIVATIVE ----------
ANTIDERIVATIVE_OF_f
    := function F
       such_that
       F_prime(x) = f(x)

ANTIDERIVATIVE
    -> inverse_relation_to(DIFFERENTIATION)
       up_to(ADDITIVE_CONSTANT)

# ---------- INDEFINITE INTEGRAL ----------
INDEFINITE_INTEGRAL
    := integral(f(x) dx)
    = F(x) + C

where
    F_prime(x) = f(x)

C
    -> CONSTANT_OF_INTEGRATION

INDEFINITE_INTEGRAL
    -> represents(FAMILY_OF_ANTIDERIVATIVES)

# ---------- DEFINITE INTEGRAL ----------
DEFINITE_INTEGRAL
    := integral_from_a_to_b(f(x) dx)

DEFINITE_INTEGRAL
    -> represents(SIGNED_ACCUMULATION)
    -> may_represent(SIGNED_AREA)
    -> returns(SCALAR_VALUE)
       under(standard_real_single_variable_context)

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

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_partition_width -> 0)
       when(RIEMANN_INTEGRABLE)

# ---------- INTEGRAND ----------
INTEGRAND
    := function_or_expression_being_integrated

VARIABLE_OF_INTEGRATION
    -> bound_variable

integral(f(x) dx)
    ~= integral(f(t) dt)
       under(consistent_dummy_variable_renaming)

# ---------- LIMITS OF INTEGRATION ----------
LOWER_LIMIT
    := a

UPPER_LIMIT
    := b

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

# ---------- 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(INTERVALS)

# ---------- LINEARITY ----------
integral(a*f + b*g)
    = a*integral(f)
    + b*integral(g)

INTEGRATION_OPERATOR
    -> linear

# ---------- FUNDAMENTAL THEOREM OF CALCULUS ----------
FTC_PART_1:

if
    f continuous
    AND
    F(x) = integral_from_a_to_x(f(t) dt)
then

F_prime(x)
    = f(x)

FTC_PART_2:

if
    F_prime = f
then

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

FUNDAMENTAL_THEOREM_OF_CALCULUS
    -> connects(DIFFERENTIATION, INTEGRATION)

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

A_prime(x)
    = f(x)
       under(FTC_CONDITIONS)

ACCUMULATION
    -> local_rate_given_by(INTEGRAND)

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

integral_from_a_to_b(f(x) dx)
    -> AREA_UNDER_GRAPH

if
    f changes_sign
then

DEFINITE_INTEGRAL
    -> SIGNED_AREA

GEOMETRIC_AREA
    -> may_require(INTEGRAL_OF_ABSOLUTE_VALUE_OR_INTERVAL_DECOMPOSITION)

# ---------- AVERAGE VALUE ----------
AVERAGE_VALUE_OF_FUNCTION
    := 1/(b-a)
       * integral_from_a_to_b(f(x) dx)

AVERAGE_VALUE
    -> accumulation_normalised_by(INTERVAL_LENGTH)

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

du
    = g_prime(x) dx

SUBSTITUTION_RULE
    -> reverse_application_of(CHAIN_RULE)

integral(
    f(g(x))*g_prime(x) dx
)
    = integral(f(u) du)

# ---------- INTEGRATION BY PARTS ----------
PRODUCT_RULE:
    d(u*v)
        = u dv + v du

rearrange:

u dv
    = d(u*v) - v du

integrate:

integral(u dv)
    = u*v - integral(v du)

INTEGRATION_BY_PARTS
    -> derived_from(PRODUCT_RULE)

# ---------- IMPROPER INTEGRALS ----------
IMPROPER_INTEGRAL
    -> may_have(INFINITE_INTERVAL)
    -> may_have(UNBOUNDED_INTEGRAND)

IMPROPER_INTEGRAL
    -> defined_using(LIMIT)

example_structure:

integral_from_a_to_infinity(f(x) dx)
    := limit(
        integral_from_a_to_b(f(x) dx),
        b -> infinity
    )

IMPROPER_INTEGRAL
    -> may(CONVERGE)
    -> may(DIVERGE)

# ---------- NUMERICAL INTEGRATION ----------
NUMERICAL_INTEGRATION
    -> approximates(DEFINITE_INTEGRAL)

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

NUMERICAL_METHOD
    -> has(APPROXIMATION_ERROR)

# ---------- APPLICATIONS ----------
INTEGRAL_CALCULUS
    -> applied_to(AREA)
    -> applied_to(VOLUME)
    -> applied_to(ARC_LENGTH)
    -> applied_to(WORK)
    -> applied_to(PROBABILITY)
    -> applied_to(MASS)
    -> applied_to(CENTRE_OF_MASS)
    -> applied_to(ACCUMULATED_CHANGE)

# ---------- DIFFERENTIAL EQUATION RELATION ----------
if
    y_prime = f(x)
then

y
    = integral(f(x) dx)

INTEGRATION
    -> recovers(FUNCTION_FROM_RATE_OF_CHANGE)
       up_to(CONSTANT_AND_BOUNDARY_CONDITIONS)

# ---------- RELATION GRAPH ----------
LIMIT
    -> defines(RIEMANN_INTEGRAL)

RIEMANN_SUM
    -> approximates(DEFINITE_INTEGRAL)

ANTIDERIVATIVE
    -> defines(INDEFINITE_INTEGRAL)

FUNDAMENTAL_THEOREM_OF_CALCULUS
    -> links(ANTIDERIVATIVE, DEFINITE_INTEGRAL)

SUBSTITUTION
    -> reverses(CHAIN_RULE_STRUCTURE)

INTEGRATION_BY_PARTS
    -> reverses(PRODUCT_RULE_STRUCTURE)

INTEGRAL
    -> quantifies(ACCUMULATION)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "integral calculus" ~= "branch of calculus concerned with integration and accumulation",
    "indefinite integral" ~= "family of antiderivatives",
    "definite integral" ~= "signed accumulated quantity over specified bounds",
    "area under a curve" ~= "definite integral when integrand is nonnegative over the interval",
    "accumulation function" ~= "function defined by a variable-upper-limit definite integral",
    "integration" ~= "continuous accumulation operation under the relevant integral definition"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    indefinite_integral_requires_constant_of_integration: true,
    definite_integral_is_not_generally_unsigned_area: true,
    riemann_integral_requires_integrability_conditions: true,
    improper_integral_requires_limit_convergence: true,
    substitution_requires_valid_variable_transformation: true,
    fundamental_theorem_requires_appropriate_hypotheses: true,
    dummy_variable_name_does_not_change_integral_meaning: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    discipline_structure: 0.99,
    antiderivative_relation: 0.99,
    definite_integral_structure: 0.99,
    riemann_sum_relation: 0.99,
    fundamental_theorem_relation: 0.99,
    integration_methods: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(integral_or_accumulation_problem)
    -> classify(definite | indefinite | improper | numerical)
    -> identify(integrand)
    -> identify(variable_of_integration)
    -> identify(bounds_if_present)
    -> determine(integrability_or_convergence_conditions)
    -> select(antiderivative_or_integration_method)
    -> apply(substitution_or_parts_if_required)
    -> apply(fundamental_theorem_if_valid)
    -> interpret(accumulation_or_geometric_meaning)
    -> validate(domain_and_boundary_conditions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed integral-calculus semantic graph",
    primary_entity: INTEGRAL_CALCULUS,
    preserve: [
        integrand,
        variable_of_integration,
        integration_bounds,
        signed_accumulation,
        convergence_conditions,
        theorem_hypotheses
    ],
    infer_through: [
        antiderivatives,
        riemann_sums,
        definite_integrals,
        improper_integrals,
        substitutions,
        integration_by_parts,
        fundamental_theorem
    ],
    avoid: [
        omitting_constant_of_integration,
        treating_signed_integral_as_unsigned_area,
        assuming_improper_integral_converges,
        applying_fundamental_theorem_without hypotheses,
        changing_bounds_in_substitution_inconsistently,
        confusing_integrand_with_antiderivative
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + INTEGRAL_CALCULUS
    + ANTIDERIVATIVE
    + INDEFINITE_INTEGRAL
    + DEFINITE_INTEGRAL
    + RIEMANN_SUM
    + FUNDAMENTAL_THEOREM_OF_CALCULUS
    + IMPROPER_INTEGRAL
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> INTEGRAL_CALCULUS
    -> INTEGRAL_TYPE_IDENTIFICATION
    -> INTEGRAND_ANALYSIS
    -> VARIABLE_AND_BOUND_ANALYSIS
    -> INTEGRABILITY_ANALYSIS
    -> METHOD_SELECTION
    -> INTEGRATION_EXECUTION
    -> FUNDAMENTAL_THEOREM_ANALYSIS
    -> CONVERGENCE_ANALYSIS
    -> ACCUMULATION_INTERPRETATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW