Integral Calculus Ontology

flow "IntegralCalculusOntology" v1.0

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

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

# ---------- CORE ENTITY ----------
INTEGRAL_CALCULUS := {
    type: MathematicalDiscipline,
    domain: Mathematics,
    parent: Calculus,
    purpose: "Formal study of integration, antiderivatives, accumulation, definite integrals, integral limits and their relationship to differentiation."
}

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

# ---------- DISCIPLINE STRUCTURE ----------
INTEGRAL_CALCULUS
    -> branch_of(CALCULUS)
    -> studies(INTEGRATION)
    -> studies(ANTIDERIVATIVES)
    -> studies(ACCUMULATION)
    -> studies(DEFINITE_INTEGRALS)
    -> depends_on(LIMIT_THEORY)
    -> connected_to(DIFFERENTIAL_CALCULUS)

# ---------- INTEGRATION ----------
INTEGRATION
    -> operation_on(FUNCTION_OR_QUANTITY)
    -> may_produce(ANTIDERIVATIVE)
    -> may_measure(ACCUMULATION)

INTEGRATION
    -> may_be(INDEFINITE)
    -> may_be(DEFINITE)
    -> may_be(IMPROPER)
    -> may_be(NUMERICAL)

# ---------- ANTIDERIVATIVE ----------
F
    -> ANTIDERIVATIVE_OF(f)
       iff
       F_prime(x) = f(x)

ANTIDERIVATIVE
    -> reverses(DIFFERENTIATION)
       up_to(ADDITIVE_CONSTANT)

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

where
    F_prime(x) = f(x)

C
    -> CONSTANT_OF_INTEGRATION

INDEFINITE_INTEGRAL
    -> FAMILY_OF_ANTIDERIVATIVES

# ---------- DEFINITE INTEGRAL ----------
integral_from_a_to_b(f(x) dx)
    -> DEFINITE_INTEGRAL

DEFINITE_INTEGRAL
    -> SIGNED_ACCUMULATION_OVER_INTERVAL
    -> scalar_value_in(REAL_SINGLE_VARIABLE_CONTEXT)

if
    f(x) >= 0
    on([a,b])
then
    DEFINITE_INTEGRAL
        -> equals(GEOMETRIC_AREA_UNDER_GRAPH)

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

DELTA_X_i
    := x_i - x_(i-1)

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

RIEMANN_INTEGRAL
    := limit(RIEMANN_SUM)
       as(max_partition_width -> 0)
       when(limit_exists_independently_of_valid_sample_choices)

RIEMANN_INTEGRABLE
    -> definite_integral_exists_under(RIEMANN_DEFINITION)

# ---------- INTEGRAND ----------
INTEGRAND
    := expression_inside_integral

VARIABLE_OF_INTEGRATION
    -> BOUND_VARIABLE

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

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

integral_from_a_to_a(f)
    = 0

ORIENTATION
    -> encoded_by(ORDER_OF_LIMITS)

# ---------- 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(
    alpha*f + beta*g
)
    = alpha*integral(f)
    + beta*integral(g)

INTEGRAL_OPERATOR
    -> LINEAR

# ---------- FUNDAMENTAL THEOREM PART I ----------
if
    f continuous_on_relevant_interval
    AND
    A(x)
        = integral_from_a_to_x(f(t) dt)
then

A_prime(x)
    = f(x)

ACCUMULATION_FUNCTION
    -> derivative_equals(INTEGRAND)
       under(FTC_CONDITIONS)

# ---------- FUNDAMENTAL THEOREM PART II ----------
if
    F_prime(x) = f(x)
then

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

FUNDAMENTAL_THEOREM_OF_CALCULUS
    -> links(DEFINITE_INTEGRATION, ANTIDIFFERENTIATION)

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

du
    = g_prime(x) dx

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

SUBSTITUTION
    -> reverse_structure_of(CHAIN_RULE)

for definite integrals:
    bounds
        -> transformed_consistently_into(u_domain)
        OR
        -> original_variable_restored_before_evaluation

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

therefore

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

INTEGRATION_BY_PARTS
    -> derived_from(PRODUCT_RULE)

# ---------- IMPROPER INTEGRAL ----------
IMPROPER_INTEGRAL
    -> may_have(INFINITE_BOUND)
    -> may_have(UNBOUNDED_INTEGRAND)

IMPROPER_INTEGRAL
    -> defined_via(LIMIT_OF_PROPER_INTEGRALS)

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

CONVERGENCE
    -> required_for(FINITE_IMPROPER_INTEGRAL_VALUE)

# ---------- ACCUMULATION ----------
ACCUMULATION
    -> aggregates(INFINITESIMAL_OR_LIMIT_BASED_CONTRIBUTIONS)

if
    rate = r(t)
then

TOTAL_CHANGE
    = integral_from_a_to_b(r(t) dt)

INTEGRAL
    -> recovers(ACCUMULATED_CHANGE_FROM_RATE)

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

AVERAGE_VALUE
    -> normalised_accumulation

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

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

NUMERICAL_APPROXIMATION
    -> has(ERROR)

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

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

ANTIDERIVATIVE
    -> defines(INDEFINITE_INTEGRAL)

RIEMANN_SUM
    -> approximates(DEFINITE_INTEGRAL)

FUNDAMENTAL_THEOREM_OF_CALCULUS
    -> connects(DERIVATIVE, INTEGRAL)

SUBSTITUTION
    -> reverses(CHAIN_RULE)

INTEGRATION_BY_PARTS
    -> reverses(PRODUCT_RULE)

IMPROPER_INTEGRAL
    -> depends_on(LIMIT_CONVERGENCE)

INTEGRAL
    -> quantifies(ACCUMULATION)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "integral calculus" ~= "calculus of integration and accumulation",
    "antiderivative" ~= "function whose derivative is the integrand",
    "indefinite integral" ~= "family of antiderivatives",
    "definite integral" ~= "signed accumulation between specified bounds",
    "Riemann integral" ~= "limit of Riemann sums when the defining limit exists",
    "accumulation function" ~= "function whose value is a definite integral with variable upper bound"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    indefinite_integral_requires_constant_of_integration: true,
    definite_integral_is_signed: true,
    riemann_integral_requires_integrability: true,
    improper_integral_requires_convergence: true,
    substitution_requires_consistent_variable_and_bound_handling: true,
    fundamental_theorem_requires_appropriate_hypotheses: true,
    variable_of_integration_is_bound: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    ontology_classification: 0.99,
    integration_structure: 0.99,
    antiderivative_relation: 0.99,
    riemann_integral_relation: 0.99,
    fundamental_theorem_relation: 0.99,
    improper_integral_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(integration_object)
    -> classify(integral_type)
    -> identify(integrand)
    -> identify(variable_of_integration)
    -> identify(bounds_if_present)
    -> test(integrability_or_convergence)
    -> select(integration_method)
    -> derive(antiderivative_or_limit_representation)
    -> apply(fundamental_theorem_if_valid)
    -> preserve(bound_orientation)
    -> interpret(accumulation)
    -> validate(domain_and_hypothesis_conditions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed integral-calculus ontology graph",
    primary_entity: INTEGRAL_CALCULUS,
    preserve: [
        integrand,
        bound_variable,
        limits_of_integration,
        orientation,
        convergence_conditions,
        theorem_hypotheses
    ],
    infer_through: [
        antiderivatives,
        definite_integrals,
        riemann_sums,
        improper_integrals,
        substitution,
        integration_by_parts,
        fundamental_theorem
    ],
    avoid: [
        omitting_constant_of_integration,
        treating_signed_integral_as_unsigned_area,
        assuming_improper_integral_convergence,
        changing_substitution_bounds_inconsistently,
        applying_fundamental_theorem_without hypotheses,
        confusing_integrand_and_antiderivative
    ]
}

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

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

# ---------- EXECUTION ----------
INPUT(query)
    -> INTEGRAL_CALCULUS
    -> INTEGRATION_OBJECT_IDENTIFICATION
    -> INTEGRAL_TYPE_CLASSIFICATION
    -> 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