Multiple Integral Ontology

flow "MultipleIntegralOntology" v1.0

# ============================================================
# MULTIPLE INTEGRAL ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
MULTIPLE_INTEGRAL := {
    type: MultivariableIntegral,
    domain: IntegralCalculus,
    purpose: "Represent accumulation of a multivariable function over a multidimensional region using two or more variables of integration."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    MULTIPLE_INTEGRAL,
    DOUBLE_INTEGRAL,
    TRIPLE_INTEGRAL,
    ITERATED_INTEGRAL,
    REGION_OF_INTEGRATION,
    INTEGRAND,
    VARIABLE_OF_INTEGRATION,
    AREA_ELEMENT,
    VOLUME_ELEMENT,
    FUBINI_THEOREM,
    TONELLI_THEOREM,
    JACOBIAN_DETERMINANT,
    CHANGE_OF_VARIABLES
}

# ---------- GENERAL STRUCTURE ----------
MULTIPLE_INTEGRAL
    -> integrates(MULTIVARIABLE_FUNCTION)
    -> over(MULTIDIMENSIONAL_REGION)
    -> uses(MULTIPLE_BOUND_VARIABLES)
    -> generalises(SINGLE_VARIABLE_DEFINITE_INTEGRAL)

# ---------- DOUBLE INTEGRAL ----------
DOUBLE_INTEGRAL
    := integral_integral_R(
        f(x,y) dA
    )

dA
    -> AREA_ELEMENT

R
    -> TWO_DIMENSIONAL_REGION

DOUBLE_INTEGRAL
    -> accumulates(FUNCTION_VALUES_OVER_AREA)

# ---------- TRIPLE INTEGRAL ----------
TRIPLE_INTEGRAL
    := integral_integral_integral_V(
        f(x,y,z) dV
    )

dV
    -> VOLUME_ELEMENT

V
    -> THREE_DIMENSIONAL_REGION

TRIPLE_INTEGRAL
    -> accumulates(FUNCTION_VALUES_OVER_VOLUME)

# ---------- HIGHER DIMENSIONS ----------
N_DIMENSIONAL_INTEGRAL
    := integral_over_Omega(
        f(x1,...,xn)
        dx1...dxn
    )

Omega
    -> subset_of(R^n)

MULTIPLE_INTEGRAL
    -> extends_to(ARBITRARY_FINITE_DIMENSION)

# ---------- ITERATED INTEGRAL ----------
ITERATED_INTEGRAL
    := integral(
        integral(
            f(x,y) dy
        ) dx
    )

ITERATED_INTEGRAL
    -> performs(SEQUENTIAL_SINGLE_VARIABLE_INTEGRATIONS)

INNER_INTEGRAL
    -> evaluated_first

OUTER_INTEGRAL
    -> evaluated_after(INNER_INTEGRAL)

# ---------- FUBINI THEOREM ----------
if
    f integrable_on(PRODUCT_REGION)
    under(FUBINI_CONDITIONS)
then

multiple_integral(f)
    = iterated_integral(f)

and
    ORDER_OF_INTEGRATION
        -> may_be_interchanged
           under(APPROPRIATE_CONDITIONS)

FUBINI_THEOREM
    -> connects(MULTIPLE_INTEGRAL, ITERATED_INTEGRALS)

# ---------- TONELLI THEOREM ----------
if
    f >= 0
    and measurable
then

TONELLI_THEOREM
    -> permits(ITERATED_INTEGRATION)
       possibly_with(INFINITE_VALUE)

TONELLI_THEOREM
    -> supports(ORDER_INTERCHANGE_FOR_NONNEGATIVE_FUNCTIONS)

# ---------- REGION TYPES ----------
RECTANGULAR_REGION
    := [a,b] x [c,d]

TYPE_I_REGION
    := {
        (x,y):
        a <= x <= b,
        g1(x) <= y <= g2(x)
    }

TYPE_II_REGION
    := {
        (x,y):
        c <= y <= d,
        h1(y) <= x <= h2(y)
    }

REGION_DESCRIPTION
    -> determines(INTEGRATION_BOUNDS)

# ---------- ORDER OF INTEGRATION ----------
ORDER_OF_INTEGRATION
    -> may_be(dx dy)
    -> may_be(dy dx)

CHANGING_ORDER
    -> requires(REDESCRIBING_REGION)

ORDER_CHANGE
    -/> merely_swap_symbols_without(BOUND_TRANSFORMATION)

# ---------- CONSTANT INTEGRAND ----------
if
    f(x,y) = 1
then

double_integral_R(1 dA)
    = AREA(R)

if
    f(x,y,z) = 1
then

triple_integral_V(1 dV)
    = VOLUME(V)

MULTIPLE_INTEGRAL
    -> generalises(GEOMETRIC_MEASURE)

# ---------- MASS ----------
if
    rho(x,y)
        := surface_density
then

MASS
    = double_integral_R(
        rho(x,y) dA
      )

if
    rho(x,y,z)
        := volume_density
then

MASS
    = triple_integral_V(
        rho(x,y,z) dV
      )

# ---------- AVERAGE VALUE ----------
AVERAGE_VALUE_OVER_REGION
    := 1/MEASURE(R)
       * integral_over_R(f dV_or_dA)

AVERAGE_VALUE
    -> normalised(MULTIDIMENSIONAL_ACCUMULATION)

# ---------- CHANGE OF VARIABLES ----------
TRANSFORMATION
    := T(u1,...,un)
       -> (x1,...,xn)

CHANGE_OF_VARIABLES
    -> replaces(COORDINATE_SYSTEM)

VOLUME_ELEMENT
    -> transformed_by(
        abs(JACOBIAN_DETERMINANT)
    )

dx1...dxn
    = abs(det(J_T))
      du1...dun

CHANGE_OF_VARIABLES_THEOREM
    -> preserves(INTEGRAL_VALUE)
       under(APPROPRIATE_CONDITIONS)

# ---------- POLAR COORDINATES ----------
x
    = r*cos(theta)

y
    = r*sin(theta)

JACOBIAN_DETERMINANT
    = r

dA
    = r dr dtheta

POLAR_COORDINATES
    -> useful_for(RADIAL_OR_CIRCULAR_REGIONS)

# ---------- CYLINDRICAL COORDINATES ----------
x
    = r*cos(theta)

y
    = r*sin(theta)

z
    = z

dV
    = r dr dtheta dz

CYLINDRICAL_COORDINATES
    -> useful_for(CYLINDRICAL_SYMMETRY)

# ---------- SPHERICAL COORDINATES ----------
SPHERICAL_COORDINATES
    -> parameterise(THREE_DIMENSIONAL_SPACE)

VOLUME_ELEMENT
    -> includes(JACOBIAN_SCALE_FACTOR)

under common convention:

dV
    = rho^2*sin(phi)
      d_rho d_phi d_theta

COORDINATE_CONVENTION
    -> must_be_specified

# ---------- IMPROPER MULTIPLE INTEGRALS ----------
MULTIPLE_INTEGRAL
    -> may_be(IMPROPER)

IMPROPER_CASE
    -> may_have(UNBOUNDED_REGION)
    -> may_have(UNBOUNDED_INTEGRAND)

CONVERGENCE
    -> requires(LIMIT_OR_MEASURE_THEORETIC_ANALYSIS)

# ---------- APPLICATIONS ----------
MULTIPLE_INTEGRAL
    -> applied_to(AREA)
    -> applied_to(VOLUME)
    -> applied_to(MASS)
    -> applied_to(CENTRE_OF_MASS)
    -> applied_to(MOMENTS_OF_INERTIA)
    -> applied_to(PROBABILITY)
    -> applied_to(EXPECTED_VALUE)
    -> applied_to(PHYSICS_FIELDS)

# ---------- RELATION GRAPH ----------
MULTIVARIABLE_FUNCTION
    -> integrated_by(MULTIPLE_INTEGRAL)

REGION_OF_INTEGRATION
    -> determines(BOUNDS)

FUBINI_THEOREM
    -> converts(MULTIPLE_INTEGRAL, ITERATED_INTEGRAL)

ORDER_CHANGE
    -> requires(REGION_REDESCRIPTION)

CHANGE_OF_VARIABLES
    -> uses(JACOBIAN_DETERMINANT)

CONSTANT_INTEGRAND_ONE
    -> returns(REGION_MEASURE)

DENSITY
    -> integrated_to(MASS)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "multiple integral" ~= "integral over a multidimensional domain",
    "double integral" ~= "two-variable accumulation over a two-dimensional region",
    "triple integral" ~= "three-variable accumulation over a three-dimensional region",
    "iterated integral" ~= "multiple integral evaluated as successive single-variable integrals under suitable conditions",
    "region of integration" ~= "multidimensional domain over which accumulation is performed",
    "Jacobian factor" ~= "absolute determinant scaling used in coordinate change"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    multiple_integral_requires_multidimensional_region: true,
    integration_variables_are_bound: true,
    order_interchange_requires_appropriate_conditions: true,
    changing_order_requires_consistent_region_bounds: true,
    coordinate_change_requires_jacobian_factor: true,
    jacobian_absolute_value_used_for_volume_scaling: true,
    improper_multiple_integrals_require_convergence_analysis: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    double_triple_structure: 0.99,
    iterated_integral_relation: 0.99,
    fubini_relation: 0.99,
    change_of_variables_relation: 0.99,
    geometric_applications: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(multivariable_integrand)
    -> identify(region_of_integration)
    -> determine(dimension)
    -> select(coordinate_system)
    -> derive(integration_bounds)
    -> determine(order_of_integration)
    -> test(fubini_or_tonelli_conditions_if_relevant)
    -> apply(change_of_variables_if_useful)
    -> include(jacobian_scale_factor_if_transformed)
    -> evaluate(iterated_integrals)
    -> validate(region_and_convergence_conditions)
    -> interpret(accumulated_quantity)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed multiple-integral semantic graph",
    primary_entity: MULTIPLE_INTEGRAL,
    preserve: [
        integrand,
        region_dimension,
        integration_variables,
        integration_order,
        bounds,
        coordinate_system,
        jacobian_factor
    ],
    infer_through: [
        double_integrals,
        triple_integrals,
        iterated_integrals,
        fubini_theorem,
        tonelli_theorem,
        coordinate_transformations,
        jacobians,
        geometric_measure
    ],
    avoid: [
        swapping_integration_order_without changing bounds,
        omitting_jacobian_factor,
        using_jacobian_without_absolute_value_for_volume_scaling,
        assuming_fubini_conditions_without verification,
        confusing_region_measure_with_integral_of_nonconstant_function,
        ignoring_improper_integral_convergence
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + MULTIPLE_INTEGRAL
    + DOUBLE_INTEGRAL
    + TRIPLE_INTEGRAL
    + ITERATED_INTEGRAL
    + FUBINI_THEOREM
    + TONELLI_THEOREM
    + CHANGE_OF_VARIABLES
    + JACOBIAN_DETERMINANT
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> MULTIPLE_INTEGRAL
    -> INTEGRAND_IDENTIFICATION
    -> REGION_IDENTIFICATION
    -> DIMENSION_ANALYSIS
    -> COORDINATE_SYSTEM_ANALYSIS
    -> BOUND_CONSTRUCTION
    -> ORDER_OF_INTEGRATION_ANALYSIS
    -> FUBINI_TONELLI_ANALYSIS
    -> CHANGE_OF_VARIABLES_ANALYSIS
    -> ITERATED_INTEGRATION
    -> CONVERGENCE_ANALYSIS
    -> ACCUMULATION_INTERPRETATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW