Integration Theory Ontology

flow "IntegrationTheoryOntology" v1.0

# INTEGRATION THEORY ONTOLOGY — FLOW ALGEBRA
SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/measure-theory/integration-theory-ontology.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Measure Theory"
ENTITY := "Integration Theory"

INTEGRATION_THEORY := {
 type: MathematicalIntegrationFramework,
 domain: MeasureTheory,
 purpose: "Formalise integration of measurable functions with respect to measures, including construction, integrability, convergence, product integration and change of measure."
}

CONCEPTS := {
 INTEGRAL,
 MEASURE_SPACE,
 MEASURABLE_FUNCTION,
 SIMPLE_FUNCTION,
 LEBESGUE_INTEGRAL,
 RIEMANN_INTEGRAL,
 INTEGRABLE_FUNCTION,
 L1_SPACE,
 ALMOST_EVERYWHERE,
 MONOTONE_CONVERGENCE,
 FATOU_LEMMA,
 DOMINATED_CONVERGENCE,
 FUBINI_THEOREM,
 TONELLI_THEOREM,
 CHANGE_OF_VARIABLES,
 RADON_NIKODYM_DERIVATIVE
}

# ---------- INTEGRATION CONTEXT ----------
MEASURE_SPACE
 := (X,Sigma,mu)

function
 f:X -> extended_real_numbers

INTEGRATION
 -> combines(FUNCTION_AND_MEASURE)

notation:

integral_X(
 f dmu
)

# ---------- INDICATOR FUNCTION ----------
for measurable A:

indicator_A(x)
 :=
1 if x in A
0 otherwise

integral_X(
 indicator_A dmu
)
 =
mu(A)

INTEGRATION
 -> extends(MEASURE_FROM_SETS_TO_FUNCTIONS)

# ---------- SIMPLE FUNCTION ----------
phi
 :=
sum_from_k_1_to_n(
 a_k
 *
 indicator_(A_k)
)

with
 A_k measurable

SIMPLE_FUNCTION
 -> finite_measurable_value_structure

# ---------- SIMPLE INTEGRAL ----------
for nonnegative simple phi:

integral_X(
 phi dmu
)
 :=
sum_k(
 a_k*mu(A_k)
)

SIMPLE_FUNCTION_INTEGRAL
 -> foundational_measure_weighted_sum

# ---------- NONNEGATIVE LEBESGUE INTEGRAL ----------
for
 f>=0
 measurable

integral_X(
 f dmu
)
 :=
sup_{0<=phi<=f, phi simple}(
 integral_X(
  phi dmu
 )
)

NONNEGATIVE_INTEGRATION
 -> approximation_from_below

# ---------- SIGNED FUNCTION ----------
f
 =
f_positive
-
f_negative

where

f_positive
 := max(f,0)

f_negative
 := max(-f,0)

GENERAL_INTEGRAL
 :=
integral(f_positive dmu)
-
integral(f_negative dmu)

provided
 not_both_parts_have_infinite_integral

# ---------- INTEGRABILITY ----------
f
 -> INTEGRABLE

iff

integral_X(
 |f| dmu
)
 < infinity

INTEGRABILITY
 -> finite_absolute_integral

# ---------- L1 ----------
L1(mu)
 := {
 measurable f :
 integral(
  |f| dmu
 ) < infinity
}
 modulo(ALMOST_EVERYWHERE_EQUALITY)

||f||_1
 :=
integral(
 |f| dmu
)

L1
 -> BANACH_SPACE

# ---------- LINEARITY ----------
for integrable f,g:

integral(
 alpha*f + beta*g
 dmu
)
 =
alpha*integral(f dmu)
+
beta*integral(g dmu)

INTEGRAL
 -> LINEAR_FUNCTIONAL_ON(L1)

# ---------- MONOTONICITY ----------
if

f<=g
 almost_everywhere

then

integral(f dmu)
 <=
integral(g dmu)

under appropriate integrability/extended-integral context

INTEGRAL
 -> ORDER_PRESERVING

# ---------- TRIANGLE INEQUALITY ----------
if f integrable:

|
 integral(f dmu)
|
<=
integral(
 |f| dmu
)

ABSOLUTE_INTEGRAL
 -> controls(INTEGRAL_MAGNITUDE)

# ---------- MONOTONE CONVERGENCE ----------
if

0<=f_n
and
f_n increasing_to f
almost_everywhere

then

integral(f_n dmu)
 ->
integral(f dmu)

MONOTONE_CONVERGENCE_THEOREM
 -> exchanges(MONOTONE_LIMIT_AND_INTEGRAL)

# ---------- FATOU ----------
for nonnegative measurable f_n:

integral(
 liminf f_n
 dmu
)
<=
liminf(
 integral(f_n dmu)
)

FATOU_LEMMA
 -> lower_semicontinuity_of(INTEGRATION)

# ---------- DOMINATED CONVERGENCE ----------
if

f_n -> f
almost_everywhere

and

|f_n| <= g

with
 g integrable

then

integral(f_n dmu)
 ->
integral(f dmu)

and

integral(
 |f_n-f| dmu
)
 -> 0

DOMINATED_CONVERGENCE
 -> supports(LIMIT_INTERCHANGE_AND_L1_CONVERGENCE)

# ---------- RIEMANN INTEGRATION ----------
RIEMANN_INTEGRAL
 -> partitions(DOMAIN)
 -> uses(RECTANGULAR_SUMS)

for suitable bounded f on [a,b]:

Riemann_integrable
 -> integral_defined_by(LIMIT_OF_RIEMANN_SUMS)

RIEMANN_INTEGRATION
 -> classical_interval_based_framework

# ---------- LEBESGUE VS RIEMANN ----------
if
 f
 -> Riemann_integrable_on([a,b])

then

f
 -> Lebesgue_integrable

and

Riemann_integral
 =
Lebesgue_integral

LEBESGUE_INTEGRATION
 -> extends(RIEMANN_INTEGRATION)

# ---------- LEBESGUE CRITERION ----------
bounded
 f:[a,b]->R

is Riemann integrable

iff

set_of_discontinuities
 -> Lebesgue_measure_zero

LEBESGUE_CRITERION
 -> characterises(RIEMANN_INTEGRABILITY)

# ---------- IMPROPER INTEGRAL RELATION ----------
IMPROPER_RIEMANN_INTEGRAL
 -> limit_of(PROPER_INTEGRALS)

ABSOLUTELY_CONVERGENT_IMPROPER_INTEGRAL
 -> commonly_corresponds_to(LEBESGUE_INTEGRABILITY)

CONDITIONALLY_CONVERGENT_IMPROPER_INTEGRAL
 -/> L1_INTEGRABILITY

INTEGRATION_FRAMEWORK
 -> must_be_specified

# ---------- INTEGRAL OVER SET ----------
for measurable A:

integral_A(
 f dmu
)
 :=
integral_X(
 f*indicator_A
 dmu
)

SET_RESTRICTION
 -> localises(INTEGRATION)

# ---------- PRODUCT INTEGRATION ----------
measure spaces:

(X,Sigma,mu)
(Y,Tau,nu)

product:

(X x Y,
 Sigma tensor Tau,
 mu tensor nu)

MULTIPLE_INTEGRAL
 -> integral_with_respect_to(PRODUCT_MEASURE)

# ---------- TONELLI ----------
if
 f>=0
 measurable

then

integral_(XxY)(
 f d(mu tensor nu)
)
 =
iterated_integral_XY
 =
iterated_integral_YX

possibly infinite

TONELLI
 -> nonnegative_product_integration

# ---------- FUBINI ----------
if
 f
 -> integrable_on_product_space

then

product_integral
 =
iterated_integrals

and
 order_of_integration
 -> interchangeable

FUBINI
 -> integrable_product_integration

# ---------- CHANGE OF VARIABLES ----------
for suitable transformation
 T:E -> T(E)

integral_{T(E)}(
 f(y) dy
)
 =
integral_E(
 f(T(x))
 *
 |det(DT(x))|
 dx
)

JACOBIAN
 -> measure_scaling_factor

CHANGE_OF_VARIABLES
 -> transforms(INTEGRATION_DOMAIN_AND_DENSITY)

# ---------- PUSHFORWARD INTEGRATION ----------
measurable map

T:X->Y

pushforward
 T_sharp(mu)

then

integral_Y(
 g(y)
 d(T_sharp mu)(y)
)
 =
integral_X(
 g(T(x))
 dmu(x)
)

PUSHFORWARD
 -> abstract_change_of_variables

# ---------- ABSOLUTE CONTINUITY OF MEASURE ----------
nu << mu

if

mu(A)=0
 -> nu(A)=0

if suitable hypotheses hold:

nu(A)
 =
integral_A(
 h dmu
)

where

h
 =
dnu/dmu

RADON_NIKODYM
 -> converts(MEASURE_CHANGE_TO_DENSITY_INTEGRATION)

# ---------- EXPECTATION ----------
probability space:

(Omega,F,P)

random variable
 X

EXPECTATION:

E[X]
 :=
integral_Omega(
 X dP
)

PROBABILITY_EXPECTATION
 -> integration_with_respect_to(PROBABILITY_MEASURE)

# ---------- MOMENTS ----------
for random variable X:

E[|X|^p]
 =
integral(
 |X|^p dP
)

MOMENT
 -> integral_of(POWER_FUNCTION)

INTEGRATION_THEORY
 -> foundation_of(PROBABILITY_MOMENTS)

# ---------- PARAMETER-DEPENDENT INTEGRALS ----------
F(t)
 :=
integral_X(
 f(x,t)
 dmu(x)
)

DIFFERENTIATION_UNDER_INTEGRAL
 -> requires(DOMINATION_OR_OTHER_VALID_HYPOTHESES)

LIMIT_UNDER_INTEGRAL
 -> governed_by(CONVERGENCE_THEOREMS)

PARAMETER_INTEGRATION
 -> theorem_dependent

# ---------- ABSOLUTE CONTINUITY OF INTEGRAL ----------
if
 f in L1(mu)

then

small_measure_set
 -> small_integral_of_abs_f

formally:

for every epsilon>0
exists delta>0

such_that

mu(A)<delta

-> integral_A(
    |f| dmu
   ) < epsilon

INTEGRABLE_FUNCTION
 -> integral_absolutely_continuous_with_respect_to(MEASURE)

# ---------- HÖLDER ----------
if

1/p + 1/q = 1

f in Lp
g in Lq

then

integral(
 |f*g| dmu
)
<=
||f||_p
*
||g||_q

HOLDER_INEQUALITY
 -> controls(PRODUCT_INTEGRABILITY)

# ---------- MINKOWSKI ----------
for p>=1:

||f+g||_p
 <=
||f||_p
+
||g||_p

MINKOWSKI_INEQUALITY
 -> establishes(Lp_NORM_TRIANGLE_PROPERTY)

# ---------- APPLICATIONS ----------
INTEGRATION_THEORY
 -> applied_to(REAL_ANALYSIS)
 -> applied_to(PROBABILITY)
 -> applied_to(FOURIER_ANALYSIS)
 -> applied_to(FUNCTIONAL_ANALYSIS)
 -> applied_to(PDEs)
 -> applied_to(ERGODIC_THEORY)
 -> applied_to(STOCHASTIC_ANALYSIS)
 -> applied_to(MATHEMATICAL_PHYSICS)

# ---------- RELATION GRAPH ----------
MEASURE
 -> defines(INTEGRATION)

MEASURABLE_SET
 -> generates(INDICATOR_FUNCTION)

INDICATOR_FUNCTION
 -> generates(SIMPLE_FUNCTION)

SIMPLE_FUNCTION
 -> builds(LEBESGUE_INTEGRAL)

INTEGRABILITY
 -> generates(L1_SPACE)

CONVERGENCE_THEOREMS
 -> control(LIMIT_INTEGRAL_INTERCHANGE)

PRODUCT_MEASURE
 -> supports(MULTIPLE_INTEGRATION)

RADON_NIKODYM_DERIVATIVE
 -> represents(CHANGE_OF_MEASURE)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
 "integration theory" ~= "mathematical framework for defining and analysing integrals",
 "Lebesgue integration" ~= "measure-based integration constructed from measurable simple functions",
 "integrable function" ~= "measurable function with finite absolute integral in the L1 sense",
 "product integration" ~= "integration on a product measure space",
 "change of variables" ~= "transformation of an integral using a mapped measure or Jacobian factor",
 "expectation" ~= "Lebesgue integral with respect to a probability measure"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
 integration_framework_must_be_identified: true,
 Lebesgue_integrands_require_measurability: true,
 L1_integrability_requires_finite_absolute_integral: true,
 limit_integral_interchange_requires_theorem_hypotheses: true,
 Fubini_and_Tonelli_have_distinct_assumptions: true,
 change_of_variables_requires_mapping_specific_hypotheses: true,
 conditional_improper_integrability_must_not_be_confused_with_L1_integrability: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
 core_definition: 0.99,
 simple_function_relation: 0.99,
 integrability_relation: 0.99,
 convergence_theorem_relation: 0.99,
 product_integration_relation: 0.99,
 change_of_measure_relation: 0.99,
 semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
 identify(integration_framework_measure_space_and_integrand)
 -> verify(measurability_and_integrability)
 -> classify(simple_nonnegative_signed_or_Lp_context)
 -> evaluate_or_bound(integral)
 -> identify(limit_or_parameter_dependence)
 -> select(valid_convergence_theorem)
 -> analyse(product_space_with_Fubini_or_Tonelli_if_relevant)
 -> apply(change_of_variables_or_pushforward_if_requested)
 -> analyse(change_of_measure_via_Radon_Nikodym_if_present)
 -> validate(all_measure_integrability_and_mapping_hypotheses)
 -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
 parse_as: "typed integration-theory semantic graph",
 primary_entity: INTEGRATION_THEORY,
 preserve: [
  measure_space,
  integration_framework,
  integrand,
  measurability,
  integrability,
  domain,
  convergence_mode,
  product_structure
 ],
 infer_through: [
  indicator_integrals,
  simple_functions,
  Lebesgue_integrals,
  L1_spaces,
  convergence_theorems,
  Fubini_and_Tonelli,
  change_of_variables,
  Radon_Nikodym_densities
 ],
 avoid: [
  integrating_nonmeasurable_function_without extended context,
  confusing_Riemann_and_Lebesgue integrability,
  interchanging_limits_without hypotheses,
  applying_Fubini_when_only_Tonelli_conditions_hold,
  ignoring_absolute_integrability,
  applying_change_of_variables_without mapping conditions
 ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
 SOURCE_URL
 + ENTITY
 + CONCEPTS
 + INTEGRATION_THEORY
 + MEASURE_SPACE
 + MEASURABLE_FUNCTION
 + SIMPLE_FUNCTION
 + LEBESGUE_INTEGRAL
 + INTEGRABLE_FUNCTION
 + MONOTONE_CONVERGENCE
 + DOMINATED_CONVERGENCE
 + FUBINI_THEOREM
 + TONELLI_THEOREM
 + RADON_NIKODYM_DERIVATIVE
 + SEMANTIC_EQUIVALENCE
 + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
 -> INTEGRATION_THEORY
 -> FRAMEWORK_MEASURE_SPACE_IDENTIFICATION
 -> MEASURABILITY_INTEGRABILITY_ANALYSIS
 -> FUNCTION_CLASSIFICATION
 -> INTEGRAL_EVALUATION
 -> LIMIT_PARAMETER_ANALYSIS
 -> CONVERGENCE_THEOREM_APPLICATION
 -> PRODUCT_INTEGRATION_ANALYSIS
 -> CHANGE_VARIABLE_ANALYSIS
 -> CHANGE_OF_MEASURE_ANALYSIS
 -> HYPOTHESIS_VALIDATION
 -> RECURSIVE_REASONING(query)
 -> CONFIDENCE
 -> OUTPUT(semantic_result)

END FLOW